mirror of
https://gitlab.gnome.org/GNOME/libxml2.git
synced 2024-12-24 21:33:51 +03:00
5c55332591
This reverts commit 4b698dbaec
.
lxml assumes that xmlDocSetRootElement works with non-elements.
51761 lines
1.3 MiB
51761 lines
1.3 MiB
/*
|
|
* testapi.c: libxml2 API tester program.
|
|
*
|
|
* Automatically generated by gentest.py from libxml2-api.xml
|
|
*
|
|
* See Copyright for the status of this software.
|
|
*
|
|
* daniel@veillard.com
|
|
*/
|
|
|
|
/* Disable deprecation warnings */
|
|
#define XML_DEPRECATED
|
|
|
|
#include "config.h"
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <libxml/xmlerror.h>
|
|
#include <libxml/catalog.h>
|
|
#include <libxml/relaxng.h>
|
|
#include <libxml/parser.h>
|
|
|
|
|
|
static int testlibxml2(void);
|
|
static int test_module(const char *module);
|
|
|
|
static int generic_errors = 0;
|
|
static int call_tests = 0;
|
|
static int function_tests = 0;
|
|
|
|
static xmlChar chartab[1024];
|
|
static int inttab[1024];
|
|
static unsigned long longtab[1024];
|
|
|
|
static xmlDocPtr api_doc = NULL;
|
|
static xmlDtdPtr api_dtd = NULL;
|
|
static xmlNodePtr api_root = NULL;
|
|
static xmlAttrPtr api_attr = NULL;
|
|
static xmlNsPtr api_ns = NULL;
|
|
|
|
static void
|
|
structured_errors(void *userData ATTRIBUTE_UNUSED,
|
|
const xmlError *error ATTRIBUTE_UNUSED) {
|
|
generic_errors++;
|
|
}
|
|
|
|
static void
|
|
free_api_doc(void) {
|
|
xmlFreeDoc(api_doc);
|
|
api_doc = NULL;
|
|
api_dtd = NULL;
|
|
api_root = NULL;
|
|
api_attr = NULL;
|
|
api_ns = NULL;
|
|
}
|
|
|
|
static xmlDocPtr
|
|
get_api_doc(void) {
|
|
if (api_doc == NULL) {
|
|
api_doc = xmlReadMemory("<!DOCTYPE root [<!ELEMENT root EMPTY>]><root xmlns:h='http://example.com/' h:foo='bar'/>", 88, "root_test", NULL, 0);
|
|
api_root = NULL;
|
|
api_attr = NULL;
|
|
}
|
|
return(api_doc);
|
|
}
|
|
|
|
static xmlDtdPtr
|
|
get_api_dtd(void) {
|
|
if ((api_dtd == NULL) || (api_dtd->type != XML_DTD_NODE)) {
|
|
get_api_doc();
|
|
if ((api_doc != NULL) && (api_doc->children != NULL) &&
|
|
(api_doc->children->type == XML_DTD_NODE))
|
|
api_dtd = (xmlDtdPtr) api_doc->children;
|
|
}
|
|
return(api_dtd);
|
|
}
|
|
|
|
static xmlNodePtr
|
|
get_api_root(void) {
|
|
if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) {
|
|
get_api_doc();
|
|
if ((api_doc != NULL) && (api_doc->children != NULL) &&
|
|
(api_doc->children->next != NULL) &&
|
|
(api_doc->children->next->type == XML_ELEMENT_NODE))
|
|
api_root = api_doc->children->next;
|
|
}
|
|
return(api_root);
|
|
}
|
|
|
|
static xmlNsPtr
|
|
get_api_ns(void) {
|
|
get_api_root();
|
|
if (api_root != NULL)
|
|
api_ns = api_root->nsDef;
|
|
return(api_ns);
|
|
}
|
|
|
|
static xmlAttrPtr
|
|
get_api_attr(void) {
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
|
|
static int nr = 0;
|
|
xmlChar name[20];
|
|
#endif
|
|
|
|
if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) {
|
|
get_api_root();
|
|
}
|
|
if (api_root == NULL)
|
|
return(NULL);
|
|
if (api_root->properties != NULL) {
|
|
api_attr = api_root->properties;
|
|
return(api_root->properties);
|
|
}
|
|
api_attr = NULL;
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
|
|
snprintf((char *) name, 20, "foo%d", nr++);
|
|
api_attr = xmlSetProp(api_root, name, (const xmlChar *) "bar");
|
|
#endif
|
|
return(api_attr);
|
|
}
|
|
|
|
static int quiet = 0;
|
|
|
|
int main(int argc, char **argv) {
|
|
int ret;
|
|
int blocks, mem;
|
|
|
|
#if defined(_WIN32)
|
|
setvbuf(stdout, NULL, _IONBF, 0);
|
|
setvbuf(stderr, NULL, _IONBF, 0);
|
|
|
|
printf("Skipping on Windows for now\n");
|
|
return(0);
|
|
#endif
|
|
|
|
memset(chartab, 0, sizeof(chartab));
|
|
strncpy((char *) chartab, " chartab\n", 20);
|
|
memset(inttab, 0, sizeof(inttab));
|
|
memset(longtab, 0, sizeof(longtab));
|
|
|
|
xmlInitParser();
|
|
#ifdef LIBXML_CATALOG_ENABLED
|
|
xmlInitializeCatalog();
|
|
#endif
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
xmlRelaxNGInitTypes();
|
|
#endif
|
|
|
|
LIBXML_TEST_VERSION
|
|
|
|
xmlSetStructuredErrorFunc(NULL, structured_errors);
|
|
xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
|
|
|
|
if (argc >= 2) {
|
|
if (!strcmp(argv[1], "-q")) {
|
|
quiet = 1;
|
|
if (argc >= 3)
|
|
ret = test_module(argv[2]);
|
|
else
|
|
ret = testlibxml2();
|
|
} else {
|
|
ret = test_module(argv[1]);
|
|
}
|
|
} else
|
|
ret = testlibxml2();
|
|
|
|
xmlCleanupParser();
|
|
blocks = xmlMemBlocks();
|
|
mem = xmlMemUsed();
|
|
if ((blocks != 0) || (mem != 0)) {
|
|
printf("testapi leaked %d bytes in %d blocks\n", mem, blocks);
|
|
ret = 1;
|
|
}
|
|
|
|
return (ret != 0);
|
|
}
|
|
|
|
#include <libxml/HTMLparser.h>
|
|
#include <libxml/HTMLtree.h>
|
|
#include <libxml/chvalid.h>
|
|
#include <libxml/dict.h>
|
|
#include <libxml/encoding.h>
|
|
#include <libxml/entities.h>
|
|
#include <libxml/hash.h>
|
|
#include <libxml/list.h>
|
|
#include <libxml/nanoftp.h>
|
|
#include <libxml/nanohttp.h>
|
|
#include <libxml/parser.h>
|
|
#include <libxml/parserInternals.h>
|
|
#include <libxml/pattern.h>
|
|
#include <libxml/relaxng.h>
|
|
#include <libxml/schemasInternals.h>
|
|
#include <libxml/schematron.h>
|
|
#include <libxml/tree.h>
|
|
#include <libxml/uri.h>
|
|
#include <libxml/valid.h>
|
|
#include <libxml/xinclude.h>
|
|
#include <libxml/xmlIO.h>
|
|
#include <libxml/xmlerror.h>
|
|
#include <libxml/xmlreader.h>
|
|
#include <libxml/xmlsave.h>
|
|
#include <libxml/xmlschemas.h>
|
|
#include <libxml/xmlschemastypes.h>
|
|
#include <libxml/xmlstring.h>
|
|
#include <libxml/xmlwriter.h>
|
|
#include <libxml/xpath.h>
|
|
#include <libxml/xpointer.h>
|
|
#include <libxml/debugXML.h>
|
|
|
|
/*
|
|
We need some "remote" addresses, but want to avoid getting into
|
|
name resolution delays, so we use these
|
|
*/
|
|
#define REMOTE1GOOD "http://localhost/"
|
|
#define REMOTE1BAD "http:http://http"
|
|
#define REMOTE2GOOD "ftp://localhost/foo"
|
|
|
|
#define gen_nb_void_ptr 2
|
|
|
|
static void *gen_void_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_void_ptr(int no ATTRIBUTE_UNUSED, void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_userdata 3
|
|
|
|
static void *gen_userdata(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return((void *) &call_tests);
|
|
if (no == 1) return((void *) -1);
|
|
return(NULL);
|
|
}
|
|
static void des_userdata(int no ATTRIBUTE_UNUSED, void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
|
|
#define gen_nb_int 4
|
|
|
|
static int gen_int(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(0);
|
|
if (no == 1) return(1);
|
|
if (no == 2) return(-1);
|
|
if (no == 3) return(122);
|
|
return(-1);
|
|
}
|
|
|
|
static void des_int(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_parseroptions 5
|
|
|
|
static int gen_parseroptions(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(XML_PARSE_NOBLANKS | XML_PARSE_RECOVER);
|
|
if (no == 1) return(XML_PARSE_NOENT | XML_PARSE_DTDLOAD | XML_PARSE_DTDATTR | XML_PARSE_DTDVALID | XML_PARSE_NOCDATA);
|
|
if (no == 2) return(XML_PARSE_XINCLUDE | XML_PARSE_NOXINCNODE | XML_PARSE_NSCLEAN);
|
|
if (no == 3) return(XML_PARSE_XINCLUDE | XML_PARSE_NODICT);
|
|
return(XML_PARSE_SAX1);
|
|
}
|
|
|
|
static void des_parseroptions(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#if 0
|
|
#define gen_nb_long 5
|
|
|
|
static long gen_long(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(0);
|
|
if (no == 1) return(1);
|
|
if (no == 2) return(-1);
|
|
if (no == 3) return(122);
|
|
return(-1);
|
|
}
|
|
|
|
static void des_long(int no ATTRIBUTE_UNUSED, long val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
#endif
|
|
|
|
#define gen_nb_xmlChar 4
|
|
|
|
static xmlChar gen_xmlChar(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return('a');
|
|
if (no == 1) return(' ');
|
|
if (no == 2) return((xmlChar) '\xf8');
|
|
return(0);
|
|
}
|
|
|
|
static void des_xmlChar(int no ATTRIBUTE_UNUSED, xmlChar val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_unsigned_int 3
|
|
|
|
static unsigned int gen_unsigned_int(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(0);
|
|
if (no == 1) return(1);
|
|
if (no == 2) return(122);
|
|
return((unsigned int) -1);
|
|
}
|
|
|
|
static void des_unsigned_int(int no ATTRIBUTE_UNUSED, unsigned int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_unsigned_long 4
|
|
|
|
static unsigned long gen_unsigned_long(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(0);
|
|
if (no == 1) return(1);
|
|
if (no == 2) return(122);
|
|
return((unsigned long) -1);
|
|
}
|
|
|
|
static void des_unsigned_long(int no ATTRIBUTE_UNUSED, unsigned long val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_unsigned_long_ptr 2
|
|
|
|
static unsigned long *gen_unsigned_long_ptr(int no, int nr) {
|
|
if (no == 0) return(&longtab[nr]);
|
|
return(NULL);
|
|
}
|
|
|
|
static void des_unsigned_long_ptr(int no ATTRIBUTE_UNUSED, unsigned long *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#endif /* LIBXML_SCHEMAS_ENABLED */
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
|
|
#define gen_nb_double 4
|
|
|
|
static double gen_double(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(0);
|
|
if (no == 1) return(-1.1);
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
if (no == 2) return(xmlXPathNAN);
|
|
#endif
|
|
return(-1);
|
|
}
|
|
|
|
static void des_double(int no ATTRIBUTE_UNUSED, double val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#endif /* defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
|
|
|
|
#define gen_nb_int_ptr 2
|
|
|
|
static int *gen_int_ptr(int no, int nr) {
|
|
if (no == 0) return(&inttab[nr]);
|
|
return(NULL);
|
|
}
|
|
|
|
static void des_int_ptr(int no ATTRIBUTE_UNUSED, int *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_const_char_ptr 4
|
|
|
|
static const char *gen_const_char_ptr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return((char *) "foo");
|
|
if (no == 1) return((char *) "<foo/>");
|
|
if (no == 2) return((char *) "test/ent2");
|
|
return(NULL);
|
|
}
|
|
static void des_const_char_ptr(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_xmlChar_ptr 2
|
|
|
|
static xmlChar *gen_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(&chartab[0]);
|
|
return(NULL);
|
|
}
|
|
static void des_xmlChar_ptr(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_FILE_ptr 2
|
|
|
|
static FILE *gen_FILE_ptr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(fopen("test.out", "a+"));
|
|
return(NULL);
|
|
}
|
|
static void des_FILE_ptr(int no ATTRIBUTE_UNUSED, FILE *val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL) fclose(val);
|
|
}
|
|
|
|
#ifdef LIBXML_DEBUG_ENABLED
|
|
#define gen_nb_debug_FILE_ptr 2
|
|
static FILE *gen_debug_FILE_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(fopen("test.out", "a+"));
|
|
}
|
|
static void des_debug_FILE_ptr(int no ATTRIBUTE_UNUSED, FILE *val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL) fclose(val);
|
|
}
|
|
#endif
|
|
|
|
#define gen_nb_const_xmlChar_ptr 5
|
|
|
|
static const xmlChar *gen_const_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return((xmlChar *) "foo");
|
|
if (no == 1) return((xmlChar *) "<foo/>");
|
|
if (no == 2) return((xmlChar *) "n" "\xf8" "ne");
|
|
if (no == 3) return((xmlChar *) " 2ab ");
|
|
return(NULL);
|
|
}
|
|
static void des_const_xmlChar_ptr(int no ATTRIBUTE_UNUSED, const xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_filepath 8
|
|
|
|
static const char *gen_filepath(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return("missing.xml");
|
|
if (no == 1) return("<foo/>");
|
|
if (no == 2) return("test/ent2");
|
|
if (no == 3) return("test/valid/REC-xml-19980210.xml");
|
|
if (no == 4) return("test/valid/dtds/xhtml1-strict.dtd");
|
|
if (no == 5) return(REMOTE1GOOD);
|
|
if (no == 6) return(REMOTE1BAD);
|
|
return(NULL);
|
|
}
|
|
static void des_filepath(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_eaten_name 2
|
|
|
|
static xmlChar *gen_eaten_name(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlStrdup(BAD_CAST "eaten"));
|
|
return(NULL);
|
|
}
|
|
static void des_eaten_name(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_fileoutput 6
|
|
|
|
static const char *gen_fileoutput(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return("missing/dir/missing.xml");
|
|
if (no == 1) return("<foo/>");
|
|
if (no == 2) return(REMOTE2GOOD);
|
|
if (no == 3) return(REMOTE1GOOD);
|
|
if (no == 4) return(REMOTE1BAD);
|
|
return(NULL);
|
|
}
|
|
static void des_fileoutput(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_xmlParserCtxtPtr 3
|
|
static xmlParserCtxtPtr gen_xmlParserCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlNewParserCtxt());
|
|
if (no == 1) return(xmlCreateMemoryParserCtxt("<doc/>", 6));
|
|
return(NULL);
|
|
}
|
|
static void des_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlParserCtxtPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL)
|
|
xmlFreeParserCtxt(val);
|
|
}
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED) || \
|
|
defined(LIBXML_VALID_ENABLED) || \
|
|
defined(LIBXML_PUSH_ENABLED)
|
|
#define gen_nb_xmlSAXHandlerPtr 2
|
|
static xmlSAXHandlerPtr gen_xmlSAXHandlerPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
(void) no;
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
if (no == 0) return((xmlSAXHandlerPtr) &xmlDefaultSAXHandler);
|
|
#endif
|
|
return(NULL);
|
|
}
|
|
static void des_xmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, xmlSAXHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
#endif
|
|
|
|
#define gen_nb_xmlValidCtxtPtr 2
|
|
static xmlValidCtxtPtr gen_xmlValidCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
(void) no;
|
|
#ifdef LIBXML_VALID_ENABLED
|
|
if (no == 0) return(xmlNewValidCtxt());
|
|
#endif
|
|
return(NULL);
|
|
}
|
|
static void des_xmlValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlValidCtxtPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
(void) val;
|
|
#ifdef LIBXML_VALID_ENABLED
|
|
if (val != NULL)
|
|
xmlFreeValidCtxt(val);
|
|
#endif
|
|
}
|
|
|
|
#define gen_nb_xmlParserInputBufferPtr 8
|
|
|
|
static xmlParserInputBufferPtr gen_xmlParserInputBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlParserInputBufferCreateFilename("missing.xml", XML_CHAR_ENCODING_NONE));
|
|
if (no == 1) return(xmlParserInputBufferCreateFilename("<foo/>", XML_CHAR_ENCODING_NONE));
|
|
if (no == 2) return(xmlParserInputBufferCreateFilename("test/ent2", XML_CHAR_ENCODING_NONE));
|
|
if (no == 3) return(xmlParserInputBufferCreateFilename("test/valid/REC-xml-19980210.xml", XML_CHAR_ENCODING_NONE));
|
|
if (no == 4) return(xmlParserInputBufferCreateFilename("test/valid/dtds/xhtml1-strict.dtd", XML_CHAR_ENCODING_NONE));
|
|
if (no == 5) return(xmlParserInputBufferCreateFilename(REMOTE1GOOD, XML_CHAR_ENCODING_NONE));
|
|
if (no == 6) return(xmlParserInputBufferCreateFilename(REMOTE1BAD, XML_CHAR_ENCODING_NONE));
|
|
return(NULL);
|
|
}
|
|
static void des_xmlParserInputBufferPtr(int no ATTRIBUTE_UNUSED, xmlParserInputBufferPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
xmlFreeParserInputBuffer(val);
|
|
}
|
|
|
|
#define gen_nb_xmlDocPtr 4
|
|
static xmlDocPtr gen_xmlDocPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlNewDoc(BAD_CAST "1.0"));
|
|
if (no == 1) return(xmlReadMemory("<foo/>", 6, "test", NULL, 0));
|
|
if (no == 2) return(xmlReadMemory("<!DOCTYPE foo []> <foo/>", 24, "test", NULL, 0));
|
|
return(NULL);
|
|
}
|
|
static void des_xmlDocPtr(int no ATTRIBUTE_UNUSED, xmlDocPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
|
|
xmlFreeDoc(val);
|
|
}
|
|
|
|
#define gen_nb_xmlAttrPtr 2
|
|
static xmlAttrPtr gen_xmlAttrPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(get_api_attr());
|
|
return(NULL);
|
|
}
|
|
static void des_xmlAttrPtr(int no, xmlAttrPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) free_api_doc();
|
|
}
|
|
|
|
#define gen_nb_xmlDictPtr 2
|
|
static xmlDictPtr gen_xmlDictPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlDictCreate());
|
|
return(NULL);
|
|
}
|
|
static void des_xmlDictPtr(int no ATTRIBUTE_UNUSED, xmlDictPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL)
|
|
xmlDictFree(val);
|
|
}
|
|
|
|
#define gen_nb_xmlNodePtr 3
|
|
static xmlNodePtr gen_xmlNodePtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL));
|
|
if (no == 1) return(get_api_root());
|
|
return(NULL);
|
|
/* if (no == 2) return((xmlNodePtr) get_api_doc()); */
|
|
}
|
|
static void des_xmlNodePtr(int no, xmlNodePtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 1) {
|
|
free_api_doc();
|
|
} else if (val != NULL) {
|
|
xmlUnlinkNode(val);
|
|
xmlFreeNode(val);
|
|
}
|
|
}
|
|
|
|
#define gen_nb_xmlDtdPtr 3
|
|
static xmlDtdPtr gen_xmlDtdPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0)
|
|
return(xmlNewDtd(NULL, BAD_CAST "dtd", BAD_CAST"foo", BAD_CAST"bar"));
|
|
if (no == 1) return(get_api_dtd());
|
|
return(NULL);
|
|
}
|
|
static void des_xmlDtdPtr(int no, xmlDtdPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 1) free_api_doc();
|
|
else if (val != NULL) {
|
|
xmlUnlinkNode((xmlNodePtr) val);
|
|
xmlFreeNode((xmlNodePtr) val);
|
|
}
|
|
}
|
|
|
|
#define gen_nb_xmlNsPtr 2
|
|
static xmlNsPtr gen_xmlNsPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(get_api_ns());
|
|
return(NULL);
|
|
}
|
|
static void des_xmlNsPtr(int no, xmlNsPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) free_api_doc();
|
|
}
|
|
|
|
#define gen_nb_xmlNodePtr_in 3
|
|
static xmlNodePtr gen_xmlNodePtr_in(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL));
|
|
if (no == 0) return(xmlNewText(BAD_CAST "text"));
|
|
return(NULL);
|
|
}
|
|
static void des_xmlNodePtr_in(int no ATTRIBUTE_UNUSED, xmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#ifdef LIBXML_WRITER_ENABLED
|
|
#define gen_nb_xmlTextWriterPtr 2
|
|
static xmlTextWriterPtr gen_xmlTextWriterPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlNewTextWriterFilename("test.out", 0));
|
|
return(NULL);
|
|
}
|
|
static void des_xmlTextWriterPtr(int no ATTRIBUTE_UNUSED, xmlTextWriterPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL) xmlFreeTextWriter(val);
|
|
}
|
|
#endif
|
|
|
|
#ifdef LIBXML_READER_ENABLED
|
|
#define gen_nb_xmlTextReaderPtr 4
|
|
static xmlTextReaderPtr gen_xmlTextReaderPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlNewTextReaderFilename("test/ent2"));
|
|
if (no == 1) return(xmlNewTextReaderFilename("test/valid/REC-xml-19980210.xml"));
|
|
if (no == 2) return(xmlNewTextReaderFilename("test/valid/dtds/xhtml1-strict.dtd"));
|
|
return(NULL);
|
|
}
|
|
static void des_xmlTextReaderPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL) xmlFreeTextReader(val);
|
|
}
|
|
#endif
|
|
|
|
#define gen_nb_xmlBufferPtr 3
|
|
static const xmlChar *static_buf_content = (xmlChar *)"a static buffer";
|
|
static xmlBufferPtr gen_xmlBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlBufferCreate());
|
|
if (no == 1) return(xmlBufferCreateStatic((void *)static_buf_content, 13));
|
|
return(NULL);
|
|
}
|
|
static void des_xmlBufferPtr(int no ATTRIBUTE_UNUSED, xmlBufferPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL) {
|
|
xmlBufferFree(val);
|
|
}
|
|
}
|
|
|
|
#define gen_nb_xmlListPtr 2
|
|
static xmlListPtr gen_xmlListPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlListCreate(NULL, NULL));
|
|
return(NULL);
|
|
}
|
|
static void des_xmlListPtr(int no ATTRIBUTE_UNUSED, xmlListPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL) {
|
|
xmlListDelete(val);
|
|
}
|
|
}
|
|
|
|
#define gen_nb_xmlHashTablePtr 2
|
|
static xmlHashTablePtr gen_xmlHashTablePtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlHashCreate(10));
|
|
return(NULL);
|
|
}
|
|
static void des_xmlHashTablePtr(int no ATTRIBUTE_UNUSED, xmlHashTablePtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL) {
|
|
xmlHashFree(val, NULL);
|
|
}
|
|
}
|
|
|
|
#include <libxml/xpathInternals.h>
|
|
|
|
#ifdef LIBXML_XPATH_ENABLED
|
|
#define gen_nb_xmlXPathObjectPtr 5
|
|
static xmlXPathObjectPtr gen_xmlXPathObjectPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlXPathNewString(BAD_CAST "string object"));
|
|
if (no == 1) return(xmlXPathNewFloat(1.1));
|
|
if (no == 2) return(xmlXPathNewBoolean(1));
|
|
if (no == 3) return(xmlXPathNewNodeSet(NULL));
|
|
return(NULL);
|
|
}
|
|
static void des_xmlXPathObjectPtr(int no ATTRIBUTE_UNUSED, xmlXPathObjectPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL) {
|
|
xmlXPathFreeObject(val);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef LIBXML_OUTPUT_ENABLED
|
|
#define gen_nb_xmlOutputBufferPtr 2
|
|
static xmlOutputBufferPtr gen_xmlOutputBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlOutputBufferCreateFilename("test.out", NULL, 0));
|
|
return(NULL);
|
|
}
|
|
static void des_xmlOutputBufferPtr(int no ATTRIBUTE_UNUSED, xmlOutputBufferPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL) {
|
|
xmlOutputBufferClose(val);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef LIBXML_HTTP_ENABLED
|
|
#define gen_nb_xmlNanoHTTPCtxtPtr 1
|
|
static void *gen_xmlNanoHTTPCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlNanoHTTPOpen(REMOTE1GOOD, NULL));
|
|
if (no == 1) return(xmlNanoHTTPOpen(REMOTE2GOOD, NULL));
|
|
if (no == 2) return(xmlNanoHTTPOpen(REMOTE1BAD, NULL));
|
|
return(NULL);
|
|
}
|
|
static void des_xmlNanoHTTPCtxtPtr(int no ATTRIBUTE_UNUSED, void *val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL) {
|
|
xmlNanoHTTPClose(val);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#define gen_nb_xmlCharEncoding 4
|
|
static xmlCharEncoding gen_xmlCharEncoding(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(XML_CHAR_ENCODING_UTF8);
|
|
if (no == 1) return(XML_CHAR_ENCODING_NONE);
|
|
if (no == 2) return(XML_CHAR_ENCODING_8859_1);
|
|
return(XML_CHAR_ENCODING_ERROR);
|
|
}
|
|
static void des_xmlCharEncoding(int no ATTRIBUTE_UNUSED, xmlCharEncoding val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
|
|
|
|
#define gen_nb_xmlExpCtxtPtr 1
|
|
static xmlExpCtxtPtr gen_xmlExpCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_xmlExpCtxtPtr(int no ATTRIBUTE_UNUSED, xmlExpCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_xmlExpNodePtr 1
|
|
static xmlExpNodePtr gen_xmlExpNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_xmlExpNodePtr(int no ATTRIBUTE_UNUSED, xmlExpNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
#define gen_nb_xmlSchemaPtr 1
|
|
static xmlSchemaPtr gen_xmlSchemaPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_xmlSchemaPtr(int no ATTRIBUTE_UNUSED, xmlSchemaPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_xmlSchemaValidCtxtPtr 1
|
|
static xmlSchemaValidCtxtPtr gen_xmlSchemaValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_xmlSchemaValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchemaValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#endif /* LIBXML_SCHEMAS_ENABLED */
|
|
|
|
#define gen_nb_xmlHashDeallocator 2
|
|
static void
|
|
test_xmlHashDeallocator(void *payload ATTRIBUTE_UNUSED,
|
|
const xmlChar *name ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
static xmlHashDeallocator gen_xmlHashDeallocator(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(test_xmlHashDeallocator);
|
|
return(NULL);
|
|
}
|
|
static void des_xmlHashDeallocator(int no ATTRIBUTE_UNUSED, xmlHashDeallocator val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
|
|
static void desret_int(int val ATTRIBUTE_UNUSED) {
|
|
}
|
|
static void desret_xmlChar(xmlChar val ATTRIBUTE_UNUSED) {
|
|
}
|
|
static void desret_long(long val ATTRIBUTE_UNUSED) {
|
|
}
|
|
static void desret_unsigned_long(unsigned long val ATTRIBUTE_UNUSED) {
|
|
}
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
static void desret_double(double val ATTRIBUTE_UNUSED) {
|
|
}
|
|
#endif
|
|
static void desret_xmlCharEncoding(xmlCharEncoding val ATTRIBUTE_UNUSED) {
|
|
}
|
|
#if 0
|
|
static void desret_const_void_ptr(void *val ATTRIBUTE_UNUSED) {
|
|
}
|
|
#endif
|
|
static void desret_void_ptr(void *val ATTRIBUTE_UNUSED) {
|
|
}
|
|
static void desret_const_char_ptr(const char *val ATTRIBUTE_UNUSED) {
|
|
}
|
|
static void desret_const_xmlChar_ptr(const xmlChar *val ATTRIBUTE_UNUSED) {
|
|
}
|
|
static void desret_xmlChar_ptr(xmlChar *val) {
|
|
if (val != NULL)
|
|
xmlFree(val);
|
|
}
|
|
static void desret_xmlDocPtr(xmlDocPtr val) {
|
|
if (val != api_doc)
|
|
xmlFreeDoc(val);
|
|
}
|
|
static void desret_xmlDictPtr(xmlDictPtr val) {
|
|
xmlDictFree(val);
|
|
}
|
|
#ifdef LIBXML_OUTPUT_ENABLED
|
|
static void desret_xmlOutputBufferPtr(xmlOutputBufferPtr val) {
|
|
xmlOutputBufferClose(val);
|
|
}
|
|
#endif
|
|
#ifdef LIBXML_READER_ENABLED
|
|
static void desret_xmlTextReaderPtr(xmlTextReaderPtr val) {
|
|
xmlFreeTextReader(val);
|
|
}
|
|
#endif
|
|
static void desret_xmlNodePtr(xmlNodePtr val) {
|
|
if ((val != NULL) && (val != api_root) && (val != (xmlNodePtr) api_doc)) {
|
|
xmlUnlinkNode(val);
|
|
xmlFreeNode(val);
|
|
}
|
|
}
|
|
static void desret_xmlAttrPtr(xmlAttrPtr val) {
|
|
if (val != NULL) {
|
|
xmlUnlinkNode((xmlNodePtr) val);
|
|
xmlFreeNode((xmlNodePtr) val);
|
|
}
|
|
}
|
|
static void desret_xmlEntityPtr(xmlEntityPtr val) {
|
|
if (val != NULL) {
|
|
xmlUnlinkNode((xmlNodePtr) val);
|
|
xmlFreeNode((xmlNodePtr) val);
|
|
}
|
|
}
|
|
static void desret_xmlElementPtr(xmlElementPtr val) {
|
|
if (val != NULL) {
|
|
xmlUnlinkNode((xmlNodePtr) val);
|
|
}
|
|
}
|
|
static void desret_xmlAttributePtr(xmlAttributePtr val) {
|
|
if (val != NULL) {
|
|
xmlUnlinkNode((xmlNodePtr) val);
|
|
}
|
|
}
|
|
static void desret_xmlNsPtr(xmlNsPtr val ATTRIBUTE_UNUSED) {
|
|
}
|
|
static void desret_xmlDtdPtr(xmlDtdPtr val) {
|
|
desret_xmlNodePtr((xmlNodePtr)val);
|
|
}
|
|
#ifdef LIBXML_XPATH_ENABLED
|
|
static void desret_xmlXPathObjectPtr(xmlXPathObjectPtr val) {
|
|
xmlXPathFreeObject(val);
|
|
}
|
|
static void desret_xmlNodeSetPtr(xmlNodeSetPtr val) {
|
|
xmlXPathFreeNodeSet(val);
|
|
}
|
|
#endif
|
|
static void desret_xmlParserCtxtPtr(xmlParserCtxtPtr val) {
|
|
xmlFreeParserCtxt(val);
|
|
}
|
|
static void desret_xmlParserInputBufferPtr(xmlParserInputBufferPtr val) {
|
|
xmlFreeParserInputBuffer(val);
|
|
}
|
|
static void desret_xmlParserInputPtr(xmlParserInputPtr val) {
|
|
xmlFreeInputStream(val);
|
|
}
|
|
#ifdef LIBXML_WRITER_ENABLED
|
|
static void desret_xmlTextWriterPtr(xmlTextWriterPtr val) {
|
|
xmlFreeTextWriter(val);
|
|
}
|
|
#endif
|
|
static void desret_xmlBufferPtr(xmlBufferPtr val) {
|
|
xmlBufferFree(val);
|
|
}
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
static void desret_xmlSchemaParserCtxtPtr(xmlSchemaParserCtxtPtr val) {
|
|
xmlSchemaFreeParserCtxt(val);
|
|
}
|
|
static void desret_xmlSchemaTypePtr(xmlSchemaTypePtr val ATTRIBUTE_UNUSED) {
|
|
}
|
|
static void desret_xmlRelaxNGParserCtxtPtr(xmlRelaxNGParserCtxtPtr val) {
|
|
xmlRelaxNGFreeParserCtxt(val);
|
|
}
|
|
#endif
|
|
#ifdef LIBXML_HTML_ENABLED
|
|
static void desret_const_htmlEntityDesc_ptr(const htmlEntityDesc * val ATTRIBUTE_UNUSED) {
|
|
}
|
|
#endif
|
|
#ifdef LIBXML_HTTP_ENABLED
|
|
static void desret_xmlNanoHTTPCtxtPtr(void *val) {
|
|
xmlNanoHTTPClose(val);
|
|
}
|
|
#endif
|
|
/* cut and pasted from autogenerated to avoid troubles */
|
|
#define gen_nb_const_xmlChar_ptr_ptr 1
|
|
static const xmlChar **
|
|
gen_const_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_const_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, const xmlChar ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_unsigned_char_ptr 1
|
|
static unsigned char * gen_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, unsigned char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_const_unsigned_char_ptr 1
|
|
static const unsigned char *
|
|
gen_const_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_const_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, const unsigned char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#ifdef LIBXML_HTML_ENABLED
|
|
#define gen_nb_htmlDocPtr 3
|
|
static htmlDocPtr gen_htmlDocPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(htmlNewDoc(NULL, NULL));
|
|
if (no == 1) return(htmlReadMemory("<html/>", 7, "test", NULL, 0));
|
|
return(NULL);
|
|
}
|
|
static void des_htmlDocPtr(int no ATTRIBUTE_UNUSED, htmlDocPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
|
|
xmlFreeDoc(val);
|
|
}
|
|
static void desret_htmlDocPtr(htmlDocPtr val) {
|
|
if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
|
|
xmlFreeDoc(val);
|
|
}
|
|
#define gen_nb_htmlParserCtxtPtr 3
|
|
static htmlParserCtxtPtr gen_htmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 0) return(xmlNewParserCtxt());
|
|
if (no == 1) return(htmlCreateMemoryParserCtxt("<html/>", 7));
|
|
return(NULL);
|
|
}
|
|
static void des_htmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, htmlParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL)
|
|
htmlFreeParserCtxt(val);
|
|
}
|
|
static void desret_htmlParserCtxtPtr(htmlParserCtxtPtr val) {
|
|
if (val != NULL)
|
|
htmlFreeParserCtxt(val);
|
|
}
|
|
#endif
|
|
|
|
#ifdef LIBXML_XPATH_ENABLED
|
|
#define gen_nb_xmlNodeSetPtr 1
|
|
static xmlNodeSetPtr gen_xmlNodeSetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_xmlNodeSetPtr(int no ATTRIBUTE_UNUSED, xmlNodeSetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
#endif
|
|
|
|
#ifdef LIBXML_DEBUG_ENABLED
|
|
#ifdef LIBXML_XPATH_ENABLED
|
|
#define gen_nb_xmlShellCtxtPtr 1
|
|
static xmlShellCtxtPtr gen_xmlShellCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_xmlShellCtxtPtr(int no ATTRIBUTE_UNUSED, xmlShellCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef LIBXML_PATTERN_ENABLED
|
|
#define gen_nb_xmlPatternPtr 1
|
|
static xmlPatternPtr gen_xmlPatternPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_xmlPatternPtr(int no ATTRIBUTE_UNUSED, xmlPatternPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
#endif
|
|
|
|
#define gen_nb_xmlElementContentPtr 1
|
|
static xmlElementContentPtr gen_xmlElementContentPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_xmlElementContentPtr(int no ATTRIBUTE_UNUSED, xmlElementContentPtr val, int nr ATTRIBUTE_UNUSED) {
|
|
if (val != NULL)
|
|
xmlFreeElementContent(val);
|
|
}
|
|
static void desret_xmlElementContentPtr(xmlElementContentPtr val) {
|
|
if (val != NULL)
|
|
xmlFreeElementContent(val);
|
|
}
|
|
|
|
#define gen_nb_xmlParserNodeInfoSeqPtr 1
|
|
static xmlParserNodeInfoSeqPtr gen_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, xmlParserNodeInfoSeqPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
static void desret_const_xmlParserNodeInfo_ptr(const xmlParserNodeInfo *val ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#if defined(LIBXML_MODULES_ENABLED) || defined(LIBXML_READER_ENABLED) || \
|
|
defined(LIBXML_SCHEMAS_ENABLED)
|
|
#define gen_nb_void_ptr_ptr 1
|
|
static void ** gen_void_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
return(NULL);
|
|
}
|
|
static void des_void_ptr_ptr(int no ATTRIBUTE_UNUSED, void ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
#endif
|
|
|
|
/************************************************************************
|
|
* *
|
|
* WARNING: end of the manually maintained part of the test code *
|
|
* do not remove or alter the CUT HERE line *
|
|
* *
|
|
************************************************************************/
|
|
|
|
/* CUT HERE: everything below that line is generated */
|
|
#ifdef LIBXML_HTML_ENABLED
|
|
static void desret_htmlStatus(htmlStatus val ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#endif
|
|
|
|
#define gen_nb_xmlAttributeDefault 4
|
|
static xmlAttributeDefault gen_xmlAttributeDefault(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 1) return(XML_ATTRIBUTE_FIXED);
|
|
if (no == 2) return(XML_ATTRIBUTE_IMPLIED);
|
|
if (no == 3) return(XML_ATTRIBUTE_NONE);
|
|
if (no == 4) return(XML_ATTRIBUTE_REQUIRED);
|
|
return(0);
|
|
}
|
|
|
|
static void des_xmlAttributeDefault(int no ATTRIBUTE_UNUSED, xmlAttributeDefault val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_xmlAttributeType 4
|
|
static xmlAttributeType gen_xmlAttributeType(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 1) return(XML_ATTRIBUTE_CDATA);
|
|
if (no == 2) return(XML_ATTRIBUTE_ENTITIES);
|
|
if (no == 3) return(XML_ATTRIBUTE_ENTITY);
|
|
if (no == 4) return(XML_ATTRIBUTE_ENUMERATION);
|
|
return(0);
|
|
}
|
|
|
|
static void des_xmlAttributeType(int no ATTRIBUTE_UNUSED, xmlAttributeType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_xmlBufferAllocationScheme 4
|
|
static xmlBufferAllocationScheme gen_xmlBufferAllocationScheme(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 1) return(XML_BUFFER_ALLOC_BOUNDED);
|
|
if (no == 2) return(XML_BUFFER_ALLOC_DOUBLEIT);
|
|
if (no == 3) return(XML_BUFFER_ALLOC_EXACT);
|
|
if (no == 4) return(XML_BUFFER_ALLOC_HYBRID);
|
|
return(0);
|
|
}
|
|
|
|
static void des_xmlBufferAllocationScheme(int no ATTRIBUTE_UNUSED, xmlBufferAllocationScheme val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
static void desret_xmlBufferAllocationScheme(xmlBufferAllocationScheme val ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#ifdef LIBXML_CATALOG_ENABLED
|
|
#define gen_nb_xmlCatalogAllow 4
|
|
static xmlCatalogAllow gen_xmlCatalogAllow(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 1) return(XML_CATA_ALLOW_ALL);
|
|
if (no == 2) return(XML_CATA_ALLOW_DOCUMENT);
|
|
if (no == 3) return(XML_CATA_ALLOW_GLOBAL);
|
|
if (no == 4) return(XML_CATA_ALLOW_NONE);
|
|
return(0);
|
|
}
|
|
|
|
static void des_xmlCatalogAllow(int no ATTRIBUTE_UNUSED, xmlCatalogAllow val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
static void desret_xmlCatalogAllow(xmlCatalogAllow val ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef LIBXML_CATALOG_ENABLED
|
|
#define gen_nb_xmlCatalogPrefer 3
|
|
static xmlCatalogPrefer gen_xmlCatalogPrefer(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 1) return(XML_CATA_PREFER_NONE);
|
|
if (no == 2) return(XML_CATA_PREFER_PUBLIC);
|
|
if (no == 3) return(XML_CATA_PREFER_SYSTEM);
|
|
return(0);
|
|
}
|
|
|
|
static void des_xmlCatalogPrefer(int no ATTRIBUTE_UNUSED, xmlCatalogPrefer val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
static void desret_xmlCatalogPrefer(xmlCatalogPrefer val ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#endif
|
|
|
|
#define gen_nb_xmlElementContentType 4
|
|
static xmlElementContentType gen_xmlElementContentType(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 1) return(XML_ELEMENT_CONTENT_ELEMENT);
|
|
if (no == 2) return(XML_ELEMENT_CONTENT_OR);
|
|
if (no == 3) return(XML_ELEMENT_CONTENT_PCDATA);
|
|
if (no == 4) return(XML_ELEMENT_CONTENT_SEQ);
|
|
return(0);
|
|
}
|
|
|
|
static void des_xmlElementContentType(int no ATTRIBUTE_UNUSED, xmlElementContentType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_xmlElementTypeVal 4
|
|
static xmlElementTypeVal gen_xmlElementTypeVal(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 1) return(XML_ELEMENT_TYPE_ANY);
|
|
if (no == 2) return(XML_ELEMENT_TYPE_ELEMENT);
|
|
if (no == 3) return(XML_ELEMENT_TYPE_EMPTY);
|
|
if (no == 4) return(XML_ELEMENT_TYPE_MIXED);
|
|
return(0);
|
|
}
|
|
|
|
static void des_xmlElementTypeVal(int no ATTRIBUTE_UNUSED, xmlElementTypeVal val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#define gen_nb_xmlFeature 4
|
|
static xmlFeature gen_xmlFeature(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 1) return(XML_WITH_AUTOMATA);
|
|
if (no == 2) return(XML_WITH_C14N);
|
|
if (no == 3) return(XML_WITH_CATALOG);
|
|
if (no == 4) return(XML_WITH_DEBUG);
|
|
return(0);
|
|
}
|
|
|
|
static void des_xmlFeature(int no ATTRIBUTE_UNUSED, xmlFeature val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
static void desret_xmlParserErrors(xmlParserErrors val ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
#define gen_nb_xmlSchemaValType 4
|
|
static xmlSchemaValType gen_xmlSchemaValType(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 1) return(XML_SCHEMAS_ANYSIMPLETYPE);
|
|
if (no == 2) return(XML_SCHEMAS_ANYTYPE);
|
|
if (no == 3) return(XML_SCHEMAS_ANYURI);
|
|
if (no == 4) return(XML_SCHEMAS_BASE64BINARY);
|
|
return(0);
|
|
}
|
|
|
|
static void des_xmlSchemaValType(int no ATTRIBUTE_UNUSED, xmlSchemaValType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
static void desret_xmlSchemaValType(xmlSchemaValType val ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
#define gen_nb_xmlSchemaWhitespaceValueType 4
|
|
static xmlSchemaWhitespaceValueType gen_xmlSchemaWhitespaceValueType(int no, int nr ATTRIBUTE_UNUSED) {
|
|
if (no == 1) return(XML_SCHEMA_WHITESPACE_COLLAPSE);
|
|
if (no == 2) return(XML_SCHEMA_WHITESPACE_PRESERVE);
|
|
if (no == 3) return(XML_SCHEMA_WHITESPACE_REPLACE);
|
|
if (no == 4) return(XML_SCHEMA_WHITESPACE_UNKNOWN);
|
|
return(0);
|
|
}
|
|
|
|
static void des_xmlSchemaWhitespaceValueType(int no ATTRIBUTE_UNUSED, xmlSchemaWhitespaceValueType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
|
|
}
|
|
|
|
#endif
|
|
|
|
#include <libxml/HTMLparser.h>
|
|
#include <libxml/HTMLtree.h>
|
|
#include <libxml/SAX2.h>
|
|
#include <libxml/c14n.h>
|
|
#include <libxml/catalog.h>
|
|
#include <libxml/chvalid.h>
|
|
#include <libxml/debugXML.h>
|
|
#include <libxml/dict.h>
|
|
#include <libxml/encoding.h>
|
|
#include <libxml/entities.h>
|
|
#include <libxml/hash.h>
|
|
#include <libxml/list.h>
|
|
#include <libxml/nanohttp.h>
|
|
#include <libxml/parser.h>
|
|
#include <libxml/parserInternals.h>
|
|
#include <libxml/pattern.h>
|
|
#include <libxml/relaxng.h>
|
|
#include <libxml/schemasInternals.h>
|
|
#include <libxml/schematron.h>
|
|
#include <libxml/tree.h>
|
|
#include <libxml/uri.h>
|
|
#include <libxml/valid.h>
|
|
#include <libxml/xinclude.h>
|
|
#include <libxml/xmlIO.h>
|
|
#include <libxml/xmlautomata.h>
|
|
#include <libxml/xmlerror.h>
|
|
#include <libxml/xmlmodule.h>
|
|
#include <libxml/xmlreader.h>
|
|
#include <libxml/xmlregexp.h>
|
|
#include <libxml/xmlsave.h>
|
|
#include <libxml/xmlschemas.h>
|
|
#include <libxml/xmlschemastypes.h>
|
|
#include <libxml/xmlstring.h>
|
|
#include <libxml/xmlunicode.h>
|
|
#include <libxml/xmlwriter.h>
|
|
#include <libxml/xpath.h>
|
|
#include <libxml/xpathInternals.h>
|
|
#include <libxml/xpointer.h>
|
|
static int test_HTMLparser(void);
|
|
static int test_HTMLtree(void);
|
|
static int test_SAX2(void);
|
|
static int test_c14n(void);
|
|
static int test_catalog(void);
|
|
static int test_chvalid(void);
|
|
static int test_debugXML(void);
|
|
static int test_dict(void);
|
|
static int test_encoding(void);
|
|
static int test_entities(void);
|
|
static int test_hash(void);
|
|
static int test_list(void);
|
|
static int test_nanohttp(void);
|
|
static int test_parser(void);
|
|
static int test_parserInternals(void);
|
|
static int test_pattern(void);
|
|
static int test_relaxng(void);
|
|
static int test_schemasInternals(void);
|
|
static int test_schematron(void);
|
|
static int test_tree(void);
|
|
static int test_uri(void);
|
|
static int test_valid(void);
|
|
static int test_xinclude(void);
|
|
static int test_xmlIO(void);
|
|
static int test_xmlautomata(void);
|
|
static int test_xmlerror(void);
|
|
static int test_xmlmodule(void);
|
|
static int test_xmlreader(void);
|
|
static int test_xmlregexp(void);
|
|
static int test_xmlsave(void);
|
|
static int test_xmlschemas(void);
|
|
static int test_xmlschemastypes(void);
|
|
static int test_xmlstring(void);
|
|
static int test_xmlunicode(void);
|
|
static int test_xmlwriter(void);
|
|
static int test_xpath(void);
|
|
static int test_xpathInternals(void);
|
|
static int test_xpointer(void);
|
|
|
|
/**
|
|
* testlibxml2:
|
|
*
|
|
* Main entry point of the tester for the full libxml2 module,
|
|
* it calls all the tester entry point for each module.
|
|
*
|
|
* Returns the number of error found
|
|
*/
|
|
static int
|
|
testlibxml2(void)
|
|
{
|
|
int test_ret = 0;
|
|
|
|
test_ret += test_HTMLparser();
|
|
test_ret += test_HTMLtree();
|
|
test_ret += test_SAX2();
|
|
test_ret += test_c14n();
|
|
test_ret += test_catalog();
|
|
test_ret += test_chvalid();
|
|
test_ret += test_debugXML();
|
|
test_ret += test_dict();
|
|
test_ret += test_encoding();
|
|
test_ret += test_entities();
|
|
test_ret += test_hash();
|
|
test_ret += test_list();
|
|
test_ret += test_nanohttp();
|
|
test_ret += test_parser();
|
|
test_ret += test_parserInternals();
|
|
test_ret += test_pattern();
|
|
test_ret += test_relaxng();
|
|
test_ret += test_schemasInternals();
|
|
test_ret += test_schematron();
|
|
test_ret += test_tree();
|
|
test_ret += test_uri();
|
|
test_ret += test_valid();
|
|
test_ret += test_xinclude();
|
|
test_ret += test_xmlIO();
|
|
test_ret += test_xmlautomata();
|
|
test_ret += test_xmlerror();
|
|
test_ret += test_xmlmodule();
|
|
test_ret += test_xmlreader();
|
|
test_ret += test_xmlregexp();
|
|
test_ret += test_xmlsave();
|
|
test_ret += test_xmlschemas();
|
|
test_ret += test_xmlschemastypes();
|
|
test_ret += test_xmlstring();
|
|
test_ret += test_xmlunicode();
|
|
test_ret += test_xmlwriter();
|
|
test_ret += test_xpath();
|
|
test_ret += test_xpathInternals();
|
|
test_ret += test_xpointer();
|
|
|
|
printf("Total: %d functions, %d tests, %d errors\n",
|
|
function_tests, call_tests, test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_UTF8ToHtml(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned char * out; /* a pointer to an array of bytes to store the result */
|
|
int n_out;
|
|
int * outlen; /* the length of @out */
|
|
int n_outlen;
|
|
const unsigned char * in; /* a pointer to an array of UTF-8 chars */
|
|
int n_in;
|
|
int * inlen; /* the length of @in */
|
|
int n_inlen;
|
|
|
|
for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
|
|
for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
|
|
for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
|
|
for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_unsigned_char_ptr(n_out, 0);
|
|
outlen = gen_int_ptr(n_outlen, 1);
|
|
in = gen_const_unsigned_char_ptr(n_in, 2);
|
|
inlen = gen_int_ptr(n_inlen, 3);
|
|
|
|
ret_val = UTF8ToHtml(out, outlen, in, inlen);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_char_ptr(n_out, out, 0);
|
|
des_int_ptr(n_outlen, outlen, 1);
|
|
des_const_unsigned_char_ptr(n_in, in, 2);
|
|
des_int_ptr(n_inlen, inlen, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in UTF8ToHtml",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_outlen);
|
|
printf(" %d", n_in);
|
|
printf(" %d", n_inlen);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_HTML_ENABLED
|
|
|
|
#define gen_nb_const_htmlElemDesc_ptr 1
|
|
#define gen_const_htmlElemDesc_ptr(no, nr) NULL
|
|
#define des_const_htmlElemDesc_ptr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_htmlAttrAllowed(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlStatus ret_val;
|
|
const htmlElemDesc * elt; /* HTML element */
|
|
int n_elt;
|
|
const xmlChar * attr; /* HTML attribute */
|
|
int n_attr;
|
|
int legacy; /* whether to allow deprecated attributes */
|
|
int n_legacy;
|
|
|
|
for (n_elt = 0;n_elt < gen_nb_const_htmlElemDesc_ptr;n_elt++) {
|
|
for (n_attr = 0;n_attr < gen_nb_const_xmlChar_ptr;n_attr++) {
|
|
for (n_legacy = 0;n_legacy < gen_nb_int;n_legacy++) {
|
|
mem_base = xmlMemBlocks();
|
|
elt = gen_const_htmlElemDesc_ptr(n_elt, 0);
|
|
attr = gen_const_xmlChar_ptr(n_attr, 1);
|
|
legacy = gen_int(n_legacy, 2);
|
|
|
|
ret_val = htmlAttrAllowed(elt, attr, legacy);
|
|
desret_htmlStatus(ret_val);
|
|
call_tests++;
|
|
des_const_htmlElemDesc_ptr(n_elt, elt, 0);
|
|
des_const_xmlChar_ptr(n_attr, attr, 1);
|
|
des_int(n_legacy, legacy, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlAttrAllowed",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_elt);
|
|
printf(" %d", n_attr);
|
|
printf(" %d", n_legacy);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_HTML_ENABLED
|
|
|
|
#define gen_nb_htmlNodePtr 1
|
|
#define gen_htmlNodePtr(no, nr) NULL
|
|
#define des_htmlNodePtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_htmlAutoCloseTag(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
htmlDocPtr doc; /* the HTML document */
|
|
int n_doc;
|
|
const xmlChar * name; /* The tag name */
|
|
int n_name;
|
|
htmlNodePtr elem; /* the HTML element */
|
|
int n_elem;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_elem = 0;n_elem < gen_nb_htmlNodePtr;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_htmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
elem = gen_htmlNodePtr(n_elem, 2);
|
|
|
|
ret_val = htmlAutoCloseTag(doc, name, elem);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_htmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_htmlNodePtr(n_elem, elem, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlAutoCloseTag",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlCreateFileParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlParserCtxtPtr ret_val;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
const char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
|
|
int n_encoding;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_fileoutput(n_filename, 0);
|
|
encoding = gen_const_char_ptr(n_encoding, 1);
|
|
|
|
ret_val = htmlCreateFileParserCtxt(filename, encoding);
|
|
desret_htmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_filename, filename, 0);
|
|
des_const_char_ptr(n_encoding, encoding, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlCreateFileParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_encoding);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlCreateMemoryParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlParserCtxtPtr ret_val;
|
|
const char * buffer; /* a pointer to a char array */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
mem_base = xmlMemBlocks();
|
|
buffer = gen_const_char_ptr(n_buffer, 0);
|
|
size = gen_int(n_size, 1);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = htmlCreateMemoryParserCtxt(buffer, size);
|
|
desret_htmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_buffer, buffer, 0);
|
|
des_int(n_size, size, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlCreateMemoryParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_HTML_ENABLED
|
|
|
|
#define gen_nb_htmlSAXHandlerPtr 1
|
|
#define gen_htmlSAXHandlerPtr(no, nr) NULL
|
|
#define des_htmlSAXHandlerPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_htmlCreatePushParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED)
|
|
int mem_base;
|
|
htmlParserCtxtPtr ret_val;
|
|
htmlSAXHandlerPtr sax; /* a SAX handler */
|
|
int n_sax;
|
|
void * user_data; /* The user data returned on SAX callbacks */
|
|
int n_user_data;
|
|
const char * chunk; /* a pointer to an array of chars */
|
|
int n_chunk;
|
|
int size; /* number of chars in the array */
|
|
int n_size;
|
|
const char * filename; /* an optional file name or URI */
|
|
int n_filename;
|
|
xmlCharEncoding enc; /* an optional encoding */
|
|
int n_enc;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
|
|
for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
|
|
for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_htmlSAXHandlerPtr(n_sax, 0);
|
|
user_data = gen_userdata(n_user_data, 1);
|
|
chunk = gen_const_char_ptr(n_chunk, 2);
|
|
size = gen_int(n_size, 3);
|
|
filename = gen_fileoutput(n_filename, 4);
|
|
enc = gen_xmlCharEncoding(n_enc, 5);
|
|
if ((chunk != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST chunk)))
|
|
size = 0;
|
|
|
|
ret_val = htmlCreatePushParserCtxt(sax, user_data, chunk, size, filename, enc);
|
|
desret_htmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_htmlSAXHandlerPtr(n_sax, sax, 0);
|
|
des_userdata(n_user_data, user_data, 1);
|
|
des_const_char_ptr(n_chunk, chunk, 2);
|
|
des_int(n_size, size, 3);
|
|
des_fileoutput(n_filename, filename, 4);
|
|
des_xmlCharEncoding(n_enc, enc, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlCreatePushParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_user_data);
|
|
printf(" %d", n_chunk);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_enc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlCtxtReadDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlDocPtr ret_val;
|
|
htmlParserCtxtPtr ctxt; /* an HTML parser context */
|
|
int n_ctxt;
|
|
const xmlChar * str; /* a pointer to a zero terminated string */
|
|
int n_str;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of htmlParserOption(s) */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
|
|
str = gen_const_xmlChar_ptr(n_str, 1);
|
|
URL = gen_filepath(n_URL, 2);
|
|
encoding = gen_const_char_ptr(n_encoding, 3);
|
|
options = gen_int(n_options, 4);
|
|
|
|
ret_val = htmlCtxtReadDoc(ctxt, str, URL, encoding, options);
|
|
desret_htmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_str, str, 1);
|
|
des_filepath(n_URL, URL, 2);
|
|
des_const_char_ptr(n_encoding, encoding, 3);
|
|
des_int(n_options, options, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlCtxtReadDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlCtxtReadFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
htmlDocPtr ret_val;
|
|
htmlParserCtxtPtr ctxt; /* an HTML parser context */
|
|
int n_ctxt;
|
|
const char * filename; /* a file or URL */
|
|
int n_filename;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of htmlParserOption(s) */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
|
|
filename = gen_filepath(n_filename, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
options = gen_int(n_options, 3);
|
|
|
|
ret_val = htmlCtxtReadFile(ctxt, filename, encoding, options);
|
|
desret_htmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_filepath(n_filename, filename, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
des_int(n_options, options, 3);
|
|
xmlResetLastError();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlCtxtReadMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlDocPtr ret_val;
|
|
htmlParserCtxtPtr ctxt; /* an HTML parser context */
|
|
int n_ctxt;
|
|
const char * buffer; /* a pointer to a char array */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of htmlParserOption(s) */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
|
|
buffer = gen_const_char_ptr(n_buffer, 1);
|
|
size = gen_int(n_size, 2);
|
|
URL = gen_filepath(n_URL, 3);
|
|
encoding = gen_const_char_ptr(n_encoding, 4);
|
|
options = gen_int(n_options, 5);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = htmlCtxtReadMemory(ctxt, buffer, size, URL, encoding, options);
|
|
desret_htmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_char_ptr(n_buffer, buffer, 1);
|
|
des_int(n_size, size, 2);
|
|
des_filepath(n_URL, URL, 3);
|
|
des_const_char_ptr(n_encoding, encoding, 4);
|
|
des_int(n_options, options, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlCtxtReadMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlCtxtReset(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlParserCtxtPtr ctxt; /* an HTML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
htmlCtxtReset(ctxt);
|
|
call_tests++;
|
|
des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlCtxtReset",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlCtxtUseOptions(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
htmlParserCtxtPtr ctxt; /* an HTML parser context */
|
|
int n_ctxt;
|
|
int options; /* a combination of htmlParserOption(s) */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
|
|
options = gen_int(n_options, 1);
|
|
|
|
ret_val = htmlCtxtUseOptions(ctxt, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_options, options, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlCtxtUseOptions",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlElementAllowedHere(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const htmlElemDesc * parent; /* HTML parent element */
|
|
int n_parent;
|
|
const xmlChar * elt; /* HTML element */
|
|
int n_elt;
|
|
|
|
for (n_parent = 0;n_parent < gen_nb_const_htmlElemDesc_ptr;n_parent++) {
|
|
for (n_elt = 0;n_elt < gen_nb_const_xmlChar_ptr;n_elt++) {
|
|
mem_base = xmlMemBlocks();
|
|
parent = gen_const_htmlElemDesc_ptr(n_parent, 0);
|
|
elt = gen_const_xmlChar_ptr(n_elt, 1);
|
|
|
|
ret_val = htmlElementAllowedHere(parent, elt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_htmlElemDesc_ptr(n_parent, parent, 0);
|
|
des_const_xmlChar_ptr(n_elt, elt, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlElementAllowedHere",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_parent);
|
|
printf(" %d", n_elt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlElementStatusHere(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlStatus ret_val;
|
|
const htmlElemDesc * parent; /* HTML parent element */
|
|
int n_parent;
|
|
const htmlElemDesc * elt; /* HTML element */
|
|
int n_elt;
|
|
|
|
for (n_parent = 0;n_parent < gen_nb_const_htmlElemDesc_ptr;n_parent++) {
|
|
for (n_elt = 0;n_elt < gen_nb_const_htmlElemDesc_ptr;n_elt++) {
|
|
mem_base = xmlMemBlocks();
|
|
parent = gen_const_htmlElemDesc_ptr(n_parent, 0);
|
|
elt = gen_const_htmlElemDesc_ptr(n_elt, 1);
|
|
|
|
ret_val = htmlElementStatusHere(parent, elt);
|
|
desret_htmlStatus(ret_val);
|
|
call_tests++;
|
|
des_const_htmlElemDesc_ptr(n_parent, parent, 0);
|
|
des_const_htmlElemDesc_ptr(n_elt, elt, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlElementStatusHere",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_parent);
|
|
printf(" %d", n_elt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlEncodeEntities(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned char * out; /* a pointer to an array of bytes to store the result */
|
|
int n_out;
|
|
int * outlen; /* the length of @out */
|
|
int n_outlen;
|
|
const unsigned char * in; /* a pointer to an array of UTF-8 chars */
|
|
int n_in;
|
|
int * inlen; /* the length of @in */
|
|
int n_inlen;
|
|
int quoteChar; /* the quote character to escape (' or ") or zero. */
|
|
int n_quoteChar;
|
|
|
|
for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
|
|
for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
|
|
for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
|
|
for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
|
|
for (n_quoteChar = 0;n_quoteChar < gen_nb_int;n_quoteChar++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_unsigned_char_ptr(n_out, 0);
|
|
outlen = gen_int_ptr(n_outlen, 1);
|
|
in = gen_const_unsigned_char_ptr(n_in, 2);
|
|
inlen = gen_int_ptr(n_inlen, 3);
|
|
quoteChar = gen_int(n_quoteChar, 4);
|
|
|
|
ret_val = htmlEncodeEntities(out, outlen, in, inlen, quoteChar);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_char_ptr(n_out, out, 0);
|
|
des_int_ptr(n_outlen, outlen, 1);
|
|
des_const_unsigned_char_ptr(n_in, in, 2);
|
|
des_int_ptr(n_inlen, inlen, 3);
|
|
des_int(n_quoteChar, quoteChar, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlEncodeEntities",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_outlen);
|
|
printf(" %d", n_in);
|
|
printf(" %d", n_inlen);
|
|
printf(" %d", n_quoteChar);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlEntityLookup(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
const htmlEntityDesc * ret_val;
|
|
const xmlChar * name; /* the entity name */
|
|
int n_name;
|
|
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
name = gen_const_xmlChar_ptr(n_name, 0);
|
|
|
|
ret_val = htmlEntityLookup(name);
|
|
desret_const_htmlEntityDesc_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_name, name, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlEntityLookup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlEntityValueLookup(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
const htmlEntityDesc * ret_val;
|
|
unsigned int value; /* the entity's unicode value */
|
|
int n_value;
|
|
|
|
for (n_value = 0;n_value < gen_nb_unsigned_int;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
value = gen_unsigned_int(n_value, 0);
|
|
|
|
ret_val = htmlEntityValueLookup(value);
|
|
desret_const_htmlEntityDesc_ptr(ret_val);
|
|
call_tests++;
|
|
des_unsigned_int(n_value, value, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlEntityValueLookup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlHandleOmittedElem(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int val; /* int 0 or 1 */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_int;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_int(n_val, 0);
|
|
|
|
ret_val = htmlHandleOmittedElem(val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlHandleOmittedElem",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlInitAutoClose(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
htmlInitAutoClose();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlInitAutoClose",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlIsAutoClosed(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
htmlDocPtr doc; /* the HTML document */
|
|
int n_doc;
|
|
htmlNodePtr elem; /* the HTML element */
|
|
int n_elem;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_htmlNodePtr;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_htmlDocPtr(n_doc, 0);
|
|
elem = gen_htmlNodePtr(n_elem, 1);
|
|
|
|
ret_val = htmlIsAutoClosed(doc, elem);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_htmlDocPtr(n_doc, doc, 0);
|
|
des_htmlNodePtr(n_elem, elem, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlIsAutoClosed",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlIsScriptAttribute(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * name; /* an attribute name */
|
|
int n_name;
|
|
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
name = gen_const_xmlChar_ptr(n_name, 0);
|
|
|
|
ret_val = htmlIsScriptAttribute(name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_name, name, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlIsScriptAttribute",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlNewParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlParserCtxtPtr ret_val;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
ret_val = htmlNewParserCtxt();
|
|
desret_htmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlNewParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_HTML_ENABLED
|
|
|
|
#define gen_nb_const_htmlSAXHandler_ptr 1
|
|
#define gen_const_htmlSAXHandler_ptr(no, nr) NULL
|
|
#define des_const_htmlSAXHandler_ptr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_htmlNewSAXParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlParserCtxtPtr ret_val;
|
|
const htmlSAXHandler * sax; /* SAX handler */
|
|
int n_sax;
|
|
void * userData; /* user data */
|
|
int n_userData;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_const_htmlSAXHandler_ptr;n_sax++) {
|
|
for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_const_htmlSAXHandler_ptr(n_sax, 0);
|
|
userData = gen_userdata(n_userData, 1);
|
|
|
|
ret_val = htmlNewSAXParserCtxt(sax, userData);
|
|
desret_htmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_const_htmlSAXHandler_ptr(n_sax, sax, 0);
|
|
des_userdata(n_userData, userData, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlNewSAXParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_userData);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlNodeStatus(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlStatus ret_val;
|
|
htmlNodePtr node; /* an htmlNodePtr in a tree */
|
|
int n_node;
|
|
int legacy; /* whether to allow deprecated elements (YES is faster here for Element nodes) */
|
|
int n_legacy;
|
|
|
|
for (n_node = 0;n_node < gen_nb_htmlNodePtr;n_node++) {
|
|
for (n_legacy = 0;n_legacy < gen_nb_int;n_legacy++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_htmlNodePtr(n_node, 0);
|
|
legacy = gen_int(n_legacy, 1);
|
|
|
|
ret_val = htmlNodeStatus(node, legacy);
|
|
desret_htmlStatus(ret_val);
|
|
call_tests++;
|
|
des_htmlNodePtr(n_node, node, 0);
|
|
des_int(n_legacy, legacy, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlNodeStatus",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_legacy);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlParseCharRef(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
htmlParserCtxtPtr ctxt; /* an HTML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = htmlParseCharRef(ctxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlParseCharRef",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlParseChunk(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
htmlParserCtxtPtr ctxt; /* an HTML parser context */
|
|
int n_ctxt;
|
|
const char * chunk; /* an char array */
|
|
int n_chunk;
|
|
int size; /* the size in byte of the chunk */
|
|
int n_size;
|
|
int terminate; /* last chunk indicator */
|
|
int n_terminate;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
|
|
chunk = gen_const_char_ptr(n_chunk, 1);
|
|
size = gen_int(n_size, 2);
|
|
terminate = gen_int(n_terminate, 3);
|
|
if ((chunk != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST chunk)))
|
|
size = 0;
|
|
|
|
ret_val = htmlParseChunk(ctxt, chunk, size, terminate);
|
|
if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_char_ptr(n_chunk, chunk, 1);
|
|
des_int(n_size, size, 2);
|
|
des_int(n_terminate, terminate, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlParseChunk",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_chunk);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_terminate);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlParseDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlDocPtr ret_val;
|
|
const xmlChar * cur; /* a pointer to an array of xmlChar */
|
|
int n_cur;
|
|
const char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
|
|
int n_encoding;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_xmlChar_ptr(n_cur, 0);
|
|
encoding = gen_const_char_ptr(n_encoding, 1);
|
|
|
|
ret_val = htmlParseDoc(cur, encoding);
|
|
desret_htmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_cur, cur, 0);
|
|
des_const_char_ptr(n_encoding, encoding, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlParseDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlParseDocument(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
htmlParserCtxtPtr ctxt; /* an HTML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = htmlParseDocument(ctxt);
|
|
if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlParseDocument",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlParseElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlParserCtxtPtr ctxt; /* an HTML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
htmlParseElement(ctxt);
|
|
call_tests++;
|
|
des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlParseElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlParseEntityRef(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
const htmlEntityDesc * ret_val;
|
|
htmlParserCtxtPtr ctxt; /* an HTML parser context */
|
|
int n_ctxt;
|
|
const xmlChar ** str; /* location to store the entity name */
|
|
int n_str;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
|
|
str = gen_const_xmlChar_ptr_ptr(n_str, 1);
|
|
|
|
ret_val = htmlParseEntityRef(ctxt, str);
|
|
desret_const_htmlEntityDesc_ptr(ret_val);
|
|
call_tests++;
|
|
des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr_ptr(n_str, str, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlParseEntityRef",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlParseFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
htmlDocPtr ret_val;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
const char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
|
|
int n_encoding;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
filename = gen_filepath(n_filename, 0);
|
|
encoding = gen_const_char_ptr(n_encoding, 1);
|
|
|
|
ret_val = htmlParseFile(filename, encoding);
|
|
desret_htmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
des_const_char_ptr(n_encoding, encoding, 1);
|
|
xmlResetLastError();
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlReadDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlDocPtr ret_val;
|
|
const xmlChar * cur; /* a pointer to a zero terminated string */
|
|
int n_cur;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of htmlParserOption(s) */
|
|
int n_options;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_xmlChar_ptr(n_cur, 0);
|
|
URL = gen_filepath(n_URL, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
options = gen_int(n_options, 3);
|
|
|
|
ret_val = htmlReadDoc(cur, URL, encoding, options);
|
|
desret_htmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_cur, cur, 0);
|
|
des_filepath(n_URL, URL, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
des_int(n_options, options, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlReadDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlReadFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlDocPtr ret_val;
|
|
const char * filename; /* a file or URL */
|
|
int n_filename;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of htmlParserOption(s) */
|
|
int n_options;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
encoding = gen_const_char_ptr(n_encoding, 1);
|
|
options = gen_int(n_options, 2);
|
|
|
|
ret_val = htmlReadFile(filename, encoding, options);
|
|
desret_htmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
des_const_char_ptr(n_encoding, encoding, 1);
|
|
des_int(n_options, options, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlReadFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlReadMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlDocPtr ret_val;
|
|
const char * buffer; /* a pointer to a char array */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of htmlParserOption(s) */
|
|
int n_options;
|
|
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
buffer = gen_const_char_ptr(n_buffer, 0);
|
|
size = gen_int(n_size, 1);
|
|
URL = gen_filepath(n_URL, 2);
|
|
encoding = gen_const_char_ptr(n_encoding, 3);
|
|
options = gen_int(n_options, 4);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = htmlReadMemory(buffer, size, URL, encoding, options);
|
|
desret_htmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_buffer, buffer, 0);
|
|
des_int(n_size, size, 1);
|
|
des_filepath(n_URL, URL, 2);
|
|
des_const_char_ptr(n_encoding, encoding, 3);
|
|
des_int(n_options, options, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlReadMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlSAXParseDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlDocPtr ret_val;
|
|
const xmlChar * cur; /* a pointer to an array of xmlChar */
|
|
int n_cur;
|
|
const char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
|
|
int n_encoding;
|
|
htmlSAXHandlerPtr sax; /* the SAX handler block */
|
|
int n_sax;
|
|
void * userData; /* if using SAX, this pointer will be provided on callbacks. */
|
|
int n_userData;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
|
|
for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_xmlChar_ptr(n_cur, 0);
|
|
encoding = gen_const_char_ptr(n_encoding, 1);
|
|
sax = gen_htmlSAXHandlerPtr(n_sax, 2);
|
|
userData = gen_userdata(n_userData, 3);
|
|
|
|
ret_val = htmlSAXParseDoc(cur, encoding, sax, userData);
|
|
desret_htmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_cur, cur, 0);
|
|
des_const_char_ptr(n_encoding, encoding, 1);
|
|
des_htmlSAXHandlerPtr(n_sax, sax, 2);
|
|
des_userdata(n_userData, userData, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlSAXParseDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_userData);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlSAXParseFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlDocPtr ret_val;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
const char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
|
|
int n_encoding;
|
|
htmlSAXHandlerPtr sax; /* the SAX handler block */
|
|
int n_sax;
|
|
void * userData; /* if using SAX, this pointer will be provided on callbacks. */
|
|
int n_userData;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
|
|
for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
encoding = gen_const_char_ptr(n_encoding, 1);
|
|
sax = gen_htmlSAXHandlerPtr(n_sax, 2);
|
|
userData = gen_userdata(n_userData, 3);
|
|
|
|
ret_val = htmlSAXParseFile(filename, encoding, sax, userData);
|
|
desret_htmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
des_const_char_ptr(n_encoding, encoding, 1);
|
|
des_htmlSAXHandlerPtr(n_sax, sax, 2);
|
|
des_userdata(n_userData, userData, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlSAXParseFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_userData);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlTagLookup(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_HTMLparser(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing HTMLparser : 35 of 41 functions ...\n");
|
|
test_ret += test_UTF8ToHtml();
|
|
test_ret += test_htmlAttrAllowed();
|
|
test_ret += test_htmlAutoCloseTag();
|
|
test_ret += test_htmlCreateFileParserCtxt();
|
|
test_ret += test_htmlCreateMemoryParserCtxt();
|
|
test_ret += test_htmlCreatePushParserCtxt();
|
|
test_ret += test_htmlCtxtReadDoc();
|
|
test_ret += test_htmlCtxtReadFile();
|
|
test_ret += test_htmlCtxtReadMemory();
|
|
test_ret += test_htmlCtxtReset();
|
|
test_ret += test_htmlCtxtUseOptions();
|
|
test_ret += test_htmlElementAllowedHere();
|
|
test_ret += test_htmlElementStatusHere();
|
|
test_ret += test_htmlEncodeEntities();
|
|
test_ret += test_htmlEntityLookup();
|
|
test_ret += test_htmlEntityValueLookup();
|
|
test_ret += test_htmlHandleOmittedElem();
|
|
test_ret += test_htmlInitAutoClose();
|
|
test_ret += test_htmlIsAutoClosed();
|
|
test_ret += test_htmlIsScriptAttribute();
|
|
test_ret += test_htmlNewParserCtxt();
|
|
test_ret += test_htmlNewSAXParserCtxt();
|
|
test_ret += test_htmlNodeStatus();
|
|
test_ret += test_htmlParseCharRef();
|
|
test_ret += test_htmlParseChunk();
|
|
test_ret += test_htmlParseDoc();
|
|
test_ret += test_htmlParseDocument();
|
|
test_ret += test_htmlParseElement();
|
|
test_ret += test_htmlParseEntityRef();
|
|
test_ret += test_htmlParseFile();
|
|
test_ret += test_htmlReadDoc();
|
|
test_ret += test_htmlReadFile();
|
|
test_ret += test_htmlReadMemory();
|
|
test_ret += test_htmlSAXParseDoc();
|
|
test_ret += test_htmlSAXParseFile();
|
|
test_ret += test_htmlTagLookup();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module HTMLparser: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_htmlDocContentDumpFormatOutput(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlOutputBufferPtr buf; /* the HTML buffer output */
|
|
int n_buf;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
const char * encoding; /* the encoding string (unused) */
|
|
int n_encoding;
|
|
int format; /* should formatting spaces been added */
|
|
int n_format;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlOutputBufferPtr(n_buf, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
format = gen_int(n_format, 3);
|
|
|
|
htmlDocContentDumpFormatOutput(buf, cur, encoding, format);
|
|
call_tests++;
|
|
des_xmlOutputBufferPtr(n_buf, buf, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
des_int(n_format, format, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlDocContentDumpFormatOutput",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_format);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlDocContentDumpOutput(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlOutputBufferPtr buf; /* the HTML buffer output */
|
|
int n_buf;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
const char * encoding; /* the encoding string (unused) */
|
|
int n_encoding;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlOutputBufferPtr(n_buf, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
|
|
htmlDocContentDumpOutput(buf, cur, encoding);
|
|
call_tests++;
|
|
des_xmlOutputBufferPtr(n_buf, buf, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlDocContentDumpOutput",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlDocDump(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
FILE * f; /* the FILE* */
|
|
int n_f;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
|
|
for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
f = gen_FILE_ptr(n_f, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
|
|
ret_val = htmlDocDump(f, cur);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_FILE_ptr(n_f, f, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlDocDump",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_f);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlChar_ptr_ptr 1
|
|
#define gen_xmlChar_ptr_ptr(no, nr) NULL
|
|
#define des_xmlChar_ptr_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_htmlDocDumpMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
xmlChar ** mem; /* OUT: the memory pointer */
|
|
int n_mem;
|
|
int * size; /* OUT: the memory length */
|
|
int n_size;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
|
|
for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlDocPtr(n_cur, 0);
|
|
mem = gen_xmlChar_ptr_ptr(n_mem, 1);
|
|
size = gen_int_ptr(n_size, 2);
|
|
|
|
htmlDocDumpMemory(cur, mem, size);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_cur, cur, 0);
|
|
des_xmlChar_ptr_ptr(n_mem, mem, 1);
|
|
des_int_ptr(n_size, size, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlDocDumpMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_mem);
|
|
printf(" %d", n_size);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlDocDumpMemoryFormat(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
xmlChar ** mem; /* OUT: the memory pointer */
|
|
int n_mem;
|
|
int * size; /* OUT: the memory length */
|
|
int n_size;
|
|
int format; /* should formatting spaces been added */
|
|
int n_format;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
|
|
for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlDocPtr(n_cur, 0);
|
|
mem = gen_xmlChar_ptr_ptr(n_mem, 1);
|
|
size = gen_int_ptr(n_size, 2);
|
|
format = gen_int(n_format, 3);
|
|
|
|
htmlDocDumpMemoryFormat(cur, mem, size, format);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_cur, cur, 0);
|
|
des_xmlChar_ptr_ptr(n_mem, mem, 1);
|
|
des_int_ptr(n_size, size, 2);
|
|
des_int(n_format, format, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlDocDumpMemoryFormat",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_mem);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_format);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlGetMetaEncoding(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
htmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_htmlDocPtr(n_doc, 0);
|
|
|
|
ret_val = htmlGetMetaEncoding(doc);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_htmlDocPtr(n_doc, doc, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlGetMetaEncoding",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlIsBooleanAttr(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * name; /* the name of the attribute to check */
|
|
int n_name;
|
|
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
name = gen_const_xmlChar_ptr(n_name, 0);
|
|
|
|
ret_val = htmlIsBooleanAttr(name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_name, name, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlIsBooleanAttr",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlNewDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlDocPtr ret_val;
|
|
const xmlChar * URI; /* URI for the dtd, or NULL */
|
|
int n_URI;
|
|
const xmlChar * ExternalID; /* the external ID of the DTD, or NULL */
|
|
int n_ExternalID;
|
|
|
|
for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
|
|
for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
|
|
mem_base = xmlMemBlocks();
|
|
URI = gen_const_xmlChar_ptr(n_URI, 0);
|
|
ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
|
|
|
|
ret_val = htmlNewDoc(URI, ExternalID);
|
|
desret_htmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_URI, URI, 0);
|
|
des_const_xmlChar_ptr(n_ExternalID, ExternalID, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlNewDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URI);
|
|
printf(" %d", n_ExternalID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlNewDocNoDtD(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
htmlDocPtr ret_val;
|
|
const xmlChar * URI; /* URI for the dtd, or NULL */
|
|
int n_URI;
|
|
const xmlChar * ExternalID; /* the external ID of the DTD, or NULL */
|
|
int n_ExternalID;
|
|
|
|
for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
|
|
for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
|
|
mem_base = xmlMemBlocks();
|
|
URI = gen_const_xmlChar_ptr(n_URI, 0);
|
|
ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
|
|
|
|
ret_val = htmlNewDocNoDtD(URI, ExternalID);
|
|
desret_htmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_URI, URI, 0);
|
|
des_const_xmlChar_ptr(n_ExternalID, ExternalID, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlNewDocNoDtD",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URI);
|
|
printf(" %d", n_ExternalID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlNodeDump(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlBufferPtr buf; /* the HTML buffer output */
|
|
int n_buf;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr cur; /* the current node */
|
|
int n_cur;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
cur = gen_xmlNodePtr(n_cur, 2);
|
|
|
|
ret_val = htmlNodeDump(buf, doc, cur);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_cur, cur, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlNodeDump",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlNodeDumpFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
FILE * out; /* the FILE pointer */
|
|
int n_out;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr cur; /* the current node */
|
|
int n_cur;
|
|
|
|
for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_FILE_ptr(n_out, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
cur = gen_xmlNodePtr(n_cur, 2);
|
|
|
|
htmlNodeDumpFile(out, doc, cur);
|
|
call_tests++;
|
|
des_FILE_ptr(n_out, out, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_cur, cur, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlNodeDumpFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlNodeDumpFileFormat(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
FILE * out; /* the FILE pointer */
|
|
int n_out;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr cur; /* the current node */
|
|
int n_cur;
|
|
const char * encoding; /* the document encoding */
|
|
int n_encoding;
|
|
int format; /* should formatting spaces been added */
|
|
int n_format;
|
|
|
|
for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_FILE_ptr(n_out, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
cur = gen_xmlNodePtr(n_cur, 2);
|
|
encoding = gen_const_char_ptr(n_encoding, 3);
|
|
format = gen_int(n_format, 4);
|
|
|
|
ret_val = htmlNodeDumpFileFormat(out, doc, cur, encoding, format);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_FILE_ptr(n_out, out, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_cur, cur, 2);
|
|
des_const_char_ptr(n_encoding, encoding, 3);
|
|
des_int(n_format, format, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlNodeDumpFileFormat",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_format);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlNodeDumpFormatOutput(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlOutputBufferPtr buf; /* the HTML buffer output */
|
|
int n_buf;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr cur; /* the current node */
|
|
int n_cur;
|
|
const char * encoding; /* the encoding string (unused) */
|
|
int n_encoding;
|
|
int format; /* should formatting spaces been added */
|
|
int n_format;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlOutputBufferPtr(n_buf, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
cur = gen_xmlNodePtr(n_cur, 2);
|
|
encoding = gen_const_char_ptr(n_encoding, 3);
|
|
format = gen_int(n_format, 4);
|
|
|
|
htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);
|
|
call_tests++;
|
|
des_xmlOutputBufferPtr(n_buf, buf, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_cur, cur, 2);
|
|
des_const_char_ptr(n_encoding, encoding, 3);
|
|
des_int(n_format, format, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlNodeDumpFormatOutput",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_format);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlNodeDumpOutput(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlOutputBufferPtr buf; /* the HTML buffer output */
|
|
int n_buf;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr cur; /* the current node */
|
|
int n_cur;
|
|
const char * encoding; /* the encoding string (unused) */
|
|
int n_encoding;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlOutputBufferPtr(n_buf, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
cur = gen_xmlNodePtr(n_cur, 2);
|
|
encoding = gen_const_char_ptr(n_encoding, 3);
|
|
|
|
htmlNodeDumpOutput(buf, doc, cur, encoding);
|
|
call_tests++;
|
|
des_xmlOutputBufferPtr(n_buf, buf, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_cur, cur, 2);
|
|
des_const_char_ptr(n_encoding, encoding, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlNodeDumpOutput",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlSaveFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * filename; /* the filename (or URL) */
|
|
int n_filename;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_fileoutput(n_filename, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
|
|
ret_val = htmlSaveFile(filename, cur);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_filename, filename, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlSaveFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlSaveFileEnc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
const char * encoding; /* the document encoding */
|
|
int n_encoding;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_fileoutput(n_filename, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
|
|
ret_val = htmlSaveFileEnc(filename, cur, encoding);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_filename, filename, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlSaveFileEnc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlSaveFileFormat(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
const char * encoding; /* the document encoding */
|
|
int n_encoding;
|
|
int format; /* should formatting spaces been added */
|
|
int n_format;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_fileoutput(n_filename, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
format = gen_int(n_format, 3);
|
|
|
|
ret_val = htmlSaveFileFormat(filename, cur, encoding, format);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_filename, filename, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
des_int(n_format, format, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlSaveFileFormat",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_format);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_htmlSetMetaEncoding(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
htmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * encoding; /* the encoding string */
|
|
int n_encoding;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_xmlChar_ptr;n_encoding++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_htmlDocPtr(n_doc, 0);
|
|
encoding = gen_const_xmlChar_ptr(n_encoding, 1);
|
|
|
|
ret_val = htmlSetMetaEncoding(doc, encoding);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_htmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_encoding, encoding, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlSetMetaEncoding",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_encoding);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_HTMLtree(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing HTMLtree : 18 of 18 functions ...\n");
|
|
test_ret += test_htmlDocContentDumpFormatOutput();
|
|
test_ret += test_htmlDocContentDumpOutput();
|
|
test_ret += test_htmlDocDump();
|
|
test_ret += test_htmlDocDumpMemory();
|
|
test_ret += test_htmlDocDumpMemoryFormat();
|
|
test_ret += test_htmlGetMetaEncoding();
|
|
test_ret += test_htmlIsBooleanAttr();
|
|
test_ret += test_htmlNewDoc();
|
|
test_ret += test_htmlNewDocNoDtD();
|
|
test_ret += test_htmlNodeDump();
|
|
test_ret += test_htmlNodeDumpFile();
|
|
test_ret += test_htmlNodeDumpFileFormat();
|
|
test_ret += test_htmlNodeDumpFormatOutput();
|
|
test_ret += test_htmlNodeDumpOutput();
|
|
test_ret += test_htmlSaveFile();
|
|
test_ret += test_htmlSaveFileEnc();
|
|
test_ret += test_htmlSaveFileFormat();
|
|
test_ret += test_htmlSetMetaEncoding();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module HTMLtree: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_htmlDefaultSAXHandlerInit(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
#ifdef LIBXML_HTML_ENABLED
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
htmlDefaultSAXHandlerInit();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in htmlDefaultSAXHandlerInit",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDefaultSAXHandlerInit(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlDefaultSAXHandlerInit();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDefaultSAXHandlerInit",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlEnumerationPtr 1
|
|
#define gen_xmlEnumerationPtr(no, nr) NULL
|
|
#define des_xmlEnumerationPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlSAX2AttributeDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * elem; /* the name of the element */
|
|
int n_elem;
|
|
const xmlChar * fullname; /* the attribute name */
|
|
int n_fullname;
|
|
int type; /* the attribute type */
|
|
int n_type;
|
|
int def; /* the type of default value */
|
|
int n_def;
|
|
const xmlChar * defaultValue; /* the attribute default value */
|
|
int n_defaultValue;
|
|
xmlEnumerationPtr tree; /* the tree of enumerated value set */
|
|
int n_tree;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
|
|
for (n_fullname = 0;n_fullname < gen_nb_const_xmlChar_ptr;n_fullname++) {
|
|
for (n_type = 0;n_type < gen_nb_int;n_type++) {
|
|
for (n_def = 0;n_def < gen_nb_int;n_def++) {
|
|
for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) {
|
|
for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
elem = gen_const_xmlChar_ptr(n_elem, 1);
|
|
fullname = gen_const_xmlChar_ptr(n_fullname, 2);
|
|
type = gen_int(n_type, 3);
|
|
def = gen_int(n_def, 4);
|
|
defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 5);
|
|
tree = gen_xmlEnumerationPtr(n_tree, 6);
|
|
|
|
xmlSAX2AttributeDecl(ctx, elem, fullname, type, def, defaultValue, tree);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_elem, elem, 1);
|
|
des_const_xmlChar_ptr(n_fullname, fullname, 2);
|
|
des_int(n_type, type, 3);
|
|
des_int(n_def, def, 4);
|
|
des_const_xmlChar_ptr(n_defaultValue, defaultValue, 5);
|
|
des_xmlEnumerationPtr(n_tree, tree, 6);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2AttributeDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_fullname);
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_def);
|
|
printf(" %d", n_defaultValue);
|
|
printf(" %d", n_tree);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2CDataBlock(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * value; /* The pcdata content */
|
|
int n_value;
|
|
int len; /* the block length */
|
|
int n_len;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((value != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST value)))
|
|
len = 0;
|
|
|
|
xmlSAX2CDataBlock(ctx, value, len);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2CDataBlock",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2Characters(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * ch; /* a xmlChar string */
|
|
int n_ch;
|
|
int len; /* the number of xmlChar */
|
|
int n_len;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_ch = 0;n_ch < gen_nb_const_xmlChar_ptr;n_ch++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
ch = gen_const_xmlChar_ptr(n_ch, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((ch != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST ch)))
|
|
len = 0;
|
|
|
|
xmlSAX2Characters(ctx, ch, len);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_ch, ch, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2Characters",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_ch);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2Comment(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * value; /* the xmlSAX2Comment content */
|
|
int n_value;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
|
|
xmlSAX2Comment(ctx, value);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2Comment",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2ElementDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * name; /* the element name */
|
|
int n_name;
|
|
int type; /* the element type */
|
|
int n_type;
|
|
xmlElementContentPtr content; /* the element value tree */
|
|
int n_content;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_type = 0;n_type < gen_nb_int;n_type++) {
|
|
for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
type = gen_int(n_type, 2);
|
|
content = gen_xmlElementContentPtr(n_content, 3);
|
|
|
|
xmlSAX2ElementDecl(ctx, name, type, content);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_int(n_type, type, 2);
|
|
des_xmlElementContentPtr(n_content, content, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2ElementDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2EndDocument(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
|
|
xmlSAX2EndDocument(ctx);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2EndDocument",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2EndElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * name; /* The element name */
|
|
int n_name;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
xmlSAX2EndElement(ctx, name);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2EndElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2EndElementNs(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * localname; /* the local name of the element */
|
|
int n_localname;
|
|
const xmlChar * prefix; /* the element namespace prefix if available */
|
|
int n_prefix;
|
|
const xmlChar * URI; /* the element namespace name if available */
|
|
int n_URI;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_localname = 0;n_localname < gen_nb_const_xmlChar_ptr;n_localname++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
localname = gen_const_xmlChar_ptr(n_localname, 1);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 2);
|
|
URI = gen_const_xmlChar_ptr(n_URI, 3);
|
|
|
|
xmlSAX2EndElementNs(ctx, localname, prefix, URI);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_localname, localname, 1);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 2);
|
|
des_const_xmlChar_ptr(n_URI, URI, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2EndElementNs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_localname);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_URI);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2EntityDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * name; /* the entity name */
|
|
int n_name;
|
|
int type; /* the entity type */
|
|
int n_type;
|
|
const xmlChar * publicId; /* The public ID of the entity */
|
|
int n_publicId;
|
|
const xmlChar * systemId; /* The system ID of the entity */
|
|
int n_systemId;
|
|
xmlChar * content; /* the entity value (without processing). */
|
|
int n_content;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_type = 0;n_type < gen_nb_int;n_type++) {
|
|
for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
|
|
for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
|
|
for (n_content = 0;n_content < gen_nb_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
type = gen_int(n_type, 2);
|
|
publicId = gen_const_xmlChar_ptr(n_publicId, 3);
|
|
systemId = gen_const_xmlChar_ptr(n_systemId, 4);
|
|
content = gen_xmlChar_ptr(n_content, 5);
|
|
|
|
xmlSAX2EntityDecl(ctx, name, type, publicId, systemId, content);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_int(n_type, type, 2);
|
|
des_const_xmlChar_ptr(n_publicId, publicId, 3);
|
|
des_const_xmlChar_ptr(n_systemId, systemId, 4);
|
|
des_xmlChar_ptr(n_content, content, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2EntityDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_publicId);
|
|
printf(" %d", n_systemId);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2ExternalSubset(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * name; /* the root element name */
|
|
int n_name;
|
|
const xmlChar * ExternalID; /* the external ID */
|
|
int n_ExternalID;
|
|
const xmlChar * SystemID; /* the SYSTEM ID (e.g. filename or URL) */
|
|
int n_SystemID;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
|
|
for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
|
|
SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
|
|
|
|
xmlSAX2ExternalSubset(ctx, name, ExternalID, SystemID);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_ExternalID, ExternalID, 2);
|
|
des_const_xmlChar_ptr(n_SystemID, SystemID, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2ExternalSubset",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_ExternalID);
|
|
printf(" %d", n_SystemID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2GetColumnNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
|
|
ret_val = xmlSAX2GetColumnNumber(ctx);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2GetColumnNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2GetEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlEntityPtr ret_val;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * name; /* The entity name */
|
|
int n_name;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlSAX2GetEntity(ctx, name);
|
|
desret_xmlEntityPtr(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2GetEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2GetLineNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
|
|
ret_val = xmlSAX2GetLineNumber(ctx);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2GetLineNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2GetParameterEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlEntityPtr ret_val;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * name; /* The entity name */
|
|
int n_name;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlSAX2GetParameterEntity(ctx, name);
|
|
desret_xmlEntityPtr(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2GetParameterEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2GetPublicId(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
|
|
ret_val = xmlSAX2GetPublicId(ctx);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2GetPublicId",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2GetSystemId(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
|
|
ret_val = xmlSAX2GetSystemId(ctx);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2GetSystemId",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2HasExternalSubset(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
|
|
ret_val = xmlSAX2HasExternalSubset(ctx);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2HasExternalSubset",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2HasInternalSubset(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
|
|
ret_val = xmlSAX2HasInternalSubset(ctx);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2HasInternalSubset",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2IgnorableWhitespace(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * ch; /* a xmlChar string */
|
|
int n_ch;
|
|
int len; /* the number of xmlChar */
|
|
int n_len;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_ch = 0;n_ch < gen_nb_const_xmlChar_ptr;n_ch++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
ch = gen_const_xmlChar_ptr(n_ch, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((ch != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST ch)))
|
|
len = 0;
|
|
|
|
xmlSAX2IgnorableWhitespace(ctx, ch, len);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_ch, ch, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2IgnorableWhitespace",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_ch);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlSAXHandler_ptr 1
|
|
#define gen_xmlSAXHandler_ptr(no, nr) NULL
|
|
#define des_xmlSAXHandler_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlSAX2InitDefaultSAXHandler(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlSAXHandler * hdlr; /* the SAX handler */
|
|
int n_hdlr;
|
|
int warning; /* flag if non-zero sets the handler warning procedure */
|
|
int n_warning;
|
|
|
|
for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
|
|
for (n_warning = 0;n_warning < gen_nb_int;n_warning++) {
|
|
mem_base = xmlMemBlocks();
|
|
hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
|
|
warning = gen_int(n_warning, 1);
|
|
|
|
xmlSAX2InitDefaultSAXHandler(hdlr, warning);
|
|
call_tests++;
|
|
des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
|
|
des_int(n_warning, warning, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2InitDefaultSAXHandler",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hdlr);
|
|
printf(" %d", n_warning);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2InitHtmlDefaultSAXHandler(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
xmlSAXHandler * hdlr; /* the SAX handler */
|
|
int n_hdlr;
|
|
|
|
for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
|
|
mem_base = xmlMemBlocks();
|
|
hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
|
|
|
|
xmlSAX2InitHtmlDefaultSAXHandler(hdlr);
|
|
call_tests++;
|
|
des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2InitHtmlDefaultSAXHandler",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hdlr);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2InternalSubset(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * name; /* the root element name */
|
|
int n_name;
|
|
const xmlChar * ExternalID; /* the external ID */
|
|
int n_ExternalID;
|
|
const xmlChar * SystemID; /* the SYSTEM ID (e.g. filename or URL) */
|
|
int n_SystemID;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
|
|
for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
|
|
SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
|
|
|
|
xmlSAX2InternalSubset(ctx, name, ExternalID, SystemID);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_ExternalID, ExternalID, 2);
|
|
des_const_xmlChar_ptr(n_SystemID, SystemID, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2InternalSubset",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_ExternalID);
|
|
printf(" %d", n_SystemID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2IsStandalone(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
|
|
ret_val = xmlSAX2IsStandalone(ctx);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2IsStandalone",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2NotationDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * name; /* The name of the notation */
|
|
int n_name;
|
|
const xmlChar * publicId; /* The public ID of the entity */
|
|
int n_publicId;
|
|
const xmlChar * systemId; /* The system ID of the entity */
|
|
int n_systemId;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
|
|
for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
publicId = gen_const_xmlChar_ptr(n_publicId, 2);
|
|
systemId = gen_const_xmlChar_ptr(n_systemId, 3);
|
|
|
|
xmlSAX2NotationDecl(ctx, name, publicId, systemId);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_publicId, publicId, 2);
|
|
des_const_xmlChar_ptr(n_systemId, systemId, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2NotationDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_publicId);
|
|
printf(" %d", n_systemId);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2ProcessingInstruction(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * target; /* the target name */
|
|
int n_target;
|
|
const xmlChar * data; /* the PI data's */
|
|
int n_data;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
|
|
for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
target = gen_const_xmlChar_ptr(n_target, 1);
|
|
data = gen_const_xmlChar_ptr(n_data, 2);
|
|
|
|
xmlSAX2ProcessingInstruction(ctx, target, data);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_target, target, 1);
|
|
des_const_xmlChar_ptr(n_data, data, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2ProcessingInstruction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_target);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2Reference(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * name; /* The entity name */
|
|
int n_name;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
xmlSAX2Reference(ctx, name);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2Reference",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2ResolveEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr ret_val;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * publicId; /* The public ID of the entity */
|
|
int n_publicId;
|
|
const xmlChar * systemId; /* The system ID of the entity */
|
|
int n_systemId;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
|
|
for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
publicId = gen_const_xmlChar_ptr(n_publicId, 1);
|
|
systemId = gen_const_xmlChar_ptr(n_systemId, 2);
|
|
|
|
ret_val = xmlSAX2ResolveEntity(ctx, publicId, systemId);
|
|
desret_xmlParserInputPtr(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_publicId, publicId, 1);
|
|
des_const_xmlChar_ptr(n_systemId, systemId, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2ResolveEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_publicId);
|
|
printf(" %d", n_systemId);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlSAXLocatorPtr 1
|
|
#define gen_xmlSAXLocatorPtr(no, nr) NULL
|
|
#define des_xmlSAXLocatorPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlSAX2SetDocumentLocator(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
xmlSAXLocatorPtr loc; /* A SAX Locator */
|
|
int n_loc;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_loc = 0;n_loc < gen_nb_xmlSAXLocatorPtr;n_loc++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
loc = gen_xmlSAXLocatorPtr(n_loc, 1);
|
|
|
|
xmlSAX2SetDocumentLocator(ctx, loc);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_xmlSAXLocatorPtr(n_loc, loc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2SetDocumentLocator",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_loc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2StartDocument(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
|
|
xmlSAX2StartDocument(ctx);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2StartDocument",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2StartElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * fullname; /* The element name, including namespace prefix */
|
|
int n_fullname;
|
|
const xmlChar ** atts; /* An array of name/value attributes pairs, NULL terminated */
|
|
int n_atts;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_fullname = 0;n_fullname < gen_nb_const_xmlChar_ptr;n_fullname++) {
|
|
for (n_atts = 0;n_atts < gen_nb_const_xmlChar_ptr_ptr;n_atts++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
fullname = gen_const_xmlChar_ptr(n_fullname, 1);
|
|
atts = gen_const_xmlChar_ptr_ptr(n_atts, 2);
|
|
|
|
xmlSAX2StartElement(ctx, fullname, atts);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_fullname, fullname, 1);
|
|
des_const_xmlChar_ptr_ptr(n_atts, atts, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2StartElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_fullname);
|
|
printf(" %d", n_atts);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2StartElementNs(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * localname; /* the local name of the element */
|
|
int n_localname;
|
|
const xmlChar * prefix; /* the element namespace prefix if available */
|
|
int n_prefix;
|
|
const xmlChar * URI; /* the element namespace name if available */
|
|
int n_URI;
|
|
int nb_namespaces; /* number of namespace definitions on that node */
|
|
int n_nb_namespaces;
|
|
const xmlChar ** namespaces; /* pointer to the array of prefix/URI pairs namespace definitions */
|
|
int n_namespaces;
|
|
int nb_attributes; /* the number of attributes on that node */
|
|
int n_nb_attributes;
|
|
int nb_defaulted; /* the number of defaulted attributes. */
|
|
int n_nb_defaulted;
|
|
const xmlChar ** attributes; /* pointer to the array of (localname/prefix/URI/value/end) attribute values. */
|
|
int n_attributes;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_localname = 0;n_localname < gen_nb_const_xmlChar_ptr;n_localname++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
|
|
for (n_nb_namespaces = 0;n_nb_namespaces < gen_nb_int;n_nb_namespaces++) {
|
|
for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) {
|
|
for (n_nb_attributes = 0;n_nb_attributes < gen_nb_int;n_nb_attributes++) {
|
|
for (n_nb_defaulted = 0;n_nb_defaulted < gen_nb_int;n_nb_defaulted++) {
|
|
for (n_attributes = 0;n_attributes < gen_nb_const_xmlChar_ptr_ptr;n_attributes++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
localname = gen_const_xmlChar_ptr(n_localname, 1);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 2);
|
|
URI = gen_const_xmlChar_ptr(n_URI, 3);
|
|
nb_namespaces = gen_int(n_nb_namespaces, 4);
|
|
namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 5);
|
|
nb_attributes = gen_int(n_nb_attributes, 6);
|
|
nb_defaulted = gen_int(n_nb_defaulted, 7);
|
|
attributes = gen_const_xmlChar_ptr_ptr(n_attributes, 8);
|
|
|
|
xmlSAX2StartElementNs(ctx, localname, prefix, URI, nb_namespaces, namespaces, nb_attributes, nb_defaulted, attributes);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_localname, localname, 1);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 2);
|
|
des_const_xmlChar_ptr(n_URI, URI, 3);
|
|
des_int(n_nb_namespaces, nb_namespaces, 4);
|
|
des_const_xmlChar_ptr_ptr(n_namespaces, namespaces, 5);
|
|
des_int(n_nb_attributes, nb_attributes, 6);
|
|
des_int(n_nb_defaulted, nb_defaulted, 7);
|
|
des_const_xmlChar_ptr_ptr(n_attributes, attributes, 8);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2StartElementNs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_localname);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_URI);
|
|
printf(" %d", n_nb_namespaces);
|
|
printf(" %d", n_namespaces);
|
|
printf(" %d", n_nb_attributes);
|
|
printf(" %d", n_nb_defaulted);
|
|
printf(" %d", n_attributes);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAX2UnparsedEntityDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* the user data (XML parser context) */
|
|
int n_ctx;
|
|
const xmlChar * name; /* The name of the entity */
|
|
int n_name;
|
|
const xmlChar * publicId; /* The public ID of the entity */
|
|
int n_publicId;
|
|
const xmlChar * systemId; /* The system ID of the entity */
|
|
int n_systemId;
|
|
const xmlChar * notationName; /* the name of the notation */
|
|
int n_notationName;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
|
|
for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
|
|
for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
publicId = gen_const_xmlChar_ptr(n_publicId, 2);
|
|
systemId = gen_const_xmlChar_ptr(n_systemId, 3);
|
|
notationName = gen_const_xmlChar_ptr(n_notationName, 4);
|
|
|
|
xmlSAX2UnparsedEntityDecl(ctx, name, publicId, systemId, notationName);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_publicId, publicId, 2);
|
|
des_const_xmlChar_ptr(n_systemId, systemId, 3);
|
|
des_const_xmlChar_ptr(n_notationName, notationName, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAX2UnparsedEntityDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_publicId);
|
|
printf(" %d", n_systemId);
|
|
printf(" %d", n_notationName);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAXDefaultVersion(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
int version; /* the version, 1 or 2 */
|
|
int n_version;
|
|
|
|
for (n_version = 0;n_version < gen_nb_int;n_version++) {
|
|
mem_base = xmlMemBlocks();
|
|
version = gen_int(n_version, 0);
|
|
|
|
{
|
|
int original_version = xmlSAXDefaultVersion(2);
|
|
|
|
|
|
ret_val = xmlSAXDefaultVersion(version);
|
|
|
|
(void)xmlSAXDefaultVersion(original_version);
|
|
}
|
|
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_version, version, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAXDefaultVersion",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_version);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAXVersion(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSAXHandler * hdlr; /* the SAX handler */
|
|
int n_hdlr;
|
|
int version; /* the version, 1 or 2 */
|
|
int n_version;
|
|
|
|
for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
|
|
for (n_version = 0;n_version < gen_nb_int;n_version++) {
|
|
mem_base = xmlMemBlocks();
|
|
hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
|
|
version = gen_int(n_version, 1);
|
|
|
|
ret_val = xmlSAXVersion(hdlr, version);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
|
|
des_int(n_version, version, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAXVersion",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hdlr);
|
|
printf(" %d", n_version);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_SAX2(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing SAX2 : 36 of 36 functions ...\n");
|
|
test_ret += test_htmlDefaultSAXHandlerInit();
|
|
test_ret += test_xmlDefaultSAXHandlerInit();
|
|
test_ret += test_xmlSAX2AttributeDecl();
|
|
test_ret += test_xmlSAX2CDataBlock();
|
|
test_ret += test_xmlSAX2Characters();
|
|
test_ret += test_xmlSAX2Comment();
|
|
test_ret += test_xmlSAX2ElementDecl();
|
|
test_ret += test_xmlSAX2EndDocument();
|
|
test_ret += test_xmlSAX2EndElement();
|
|
test_ret += test_xmlSAX2EndElementNs();
|
|
test_ret += test_xmlSAX2EntityDecl();
|
|
test_ret += test_xmlSAX2ExternalSubset();
|
|
test_ret += test_xmlSAX2GetColumnNumber();
|
|
test_ret += test_xmlSAX2GetEntity();
|
|
test_ret += test_xmlSAX2GetLineNumber();
|
|
test_ret += test_xmlSAX2GetParameterEntity();
|
|
test_ret += test_xmlSAX2GetPublicId();
|
|
test_ret += test_xmlSAX2GetSystemId();
|
|
test_ret += test_xmlSAX2HasExternalSubset();
|
|
test_ret += test_xmlSAX2HasInternalSubset();
|
|
test_ret += test_xmlSAX2IgnorableWhitespace();
|
|
test_ret += test_xmlSAX2InitDefaultSAXHandler();
|
|
test_ret += test_xmlSAX2InitHtmlDefaultSAXHandler();
|
|
test_ret += test_xmlSAX2InternalSubset();
|
|
test_ret += test_xmlSAX2IsStandalone();
|
|
test_ret += test_xmlSAX2NotationDecl();
|
|
test_ret += test_xmlSAX2ProcessingInstruction();
|
|
test_ret += test_xmlSAX2Reference();
|
|
test_ret += test_xmlSAX2ResolveEntity();
|
|
test_ret += test_xmlSAX2SetDocumentLocator();
|
|
test_ret += test_xmlSAX2StartDocument();
|
|
test_ret += test_xmlSAX2StartElement();
|
|
test_ret += test_xmlSAX2StartElementNs();
|
|
test_ret += test_xmlSAX2UnparsedEntityDecl();
|
|
test_ret += test_xmlSAXDefaultVersion();
|
|
test_ret += test_xmlSAXVersion();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module SAX2: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlC14NDocDumpMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_C14N_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* the XML document for canonization */
|
|
int n_doc;
|
|
xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
|
|
int n_nodes;
|
|
int mode; /* the c14n mode (see @xmlC14NMode) */
|
|
int n_mode;
|
|
xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */
|
|
int n_inclusive_ns_prefixes;
|
|
int with_comments; /* include comments in the result (!=0) or not (==0) */
|
|
int n_with_comments;
|
|
xmlChar ** doc_txt_ptr; /* the memory pointer for allocated canonical XML text; the caller of this functions is responsible for calling xmlFree() to free allocated memory */
|
|
int n_doc_txt_ptr;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
|
|
for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
|
|
for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
|
|
for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
|
|
for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
nodes = gen_xmlNodeSetPtr(n_nodes, 1);
|
|
mode = gen_int(n_mode, 2);
|
|
inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
|
|
with_comments = gen_int(n_with_comments, 4);
|
|
doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 5);
|
|
|
|
ret_val = xmlC14NDocDumpMemory(doc, nodes, mode, inclusive_ns_prefixes, with_comments, doc_txt_ptr);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNodeSetPtr(n_nodes, nodes, 1);
|
|
des_int(n_mode, mode, 2);
|
|
des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
|
|
des_int(n_with_comments, with_comments, 4);
|
|
des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlC14NDocDumpMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_nodes);
|
|
printf(" %d", n_mode);
|
|
printf(" %d", n_inclusive_ns_prefixes);
|
|
printf(" %d", n_with_comments);
|
|
printf(" %d", n_doc_txt_ptr);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlC14NDocSave(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_C14N_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* the XML document for canonization */
|
|
int n_doc;
|
|
xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
|
|
int n_nodes;
|
|
int mode; /* the c14n mode (see @xmlC14NMode) */
|
|
int n_mode;
|
|
xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */
|
|
int n_inclusive_ns_prefixes;
|
|
int with_comments; /* include comments in the result (!=0) or not (==0) */
|
|
int n_with_comments;
|
|
const char * filename; /* the filename to store canonical XML image */
|
|
int n_filename;
|
|
int compression; /* the compression level (zlib required): -1 - libxml default, 0 - uncompressed, >0 - compression level */
|
|
int n_compression;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
|
|
for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
|
|
for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
|
|
for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
nodes = gen_xmlNodeSetPtr(n_nodes, 1);
|
|
mode = gen_int(n_mode, 2);
|
|
inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
|
|
with_comments = gen_int(n_with_comments, 4);
|
|
filename = gen_fileoutput(n_filename, 5);
|
|
compression = gen_int(n_compression, 6);
|
|
|
|
ret_val = xmlC14NDocSave(doc, nodes, mode, inclusive_ns_prefixes, with_comments, filename, compression);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNodeSetPtr(n_nodes, nodes, 1);
|
|
des_int(n_mode, mode, 2);
|
|
des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
|
|
des_int(n_with_comments, with_comments, 4);
|
|
des_fileoutput(n_filename, filename, 5);
|
|
des_int(n_compression, compression, 6);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlC14NDocSave",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_nodes);
|
|
printf(" %d", n_mode);
|
|
printf(" %d", n_inclusive_ns_prefixes);
|
|
printf(" %d", n_with_comments);
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_compression);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlC14NDocSaveTo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_C14N_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* the XML document for canonization */
|
|
int n_doc;
|
|
xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
|
|
int n_nodes;
|
|
int mode; /* the c14n mode (see @xmlC14NMode) */
|
|
int n_mode;
|
|
xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */
|
|
int n_inclusive_ns_prefixes;
|
|
int with_comments; /* include comments in the result (!=0) or not (==0) */
|
|
int n_with_comments;
|
|
xmlOutputBufferPtr buf; /* the output buffer to store canonical XML; this buffer MUST have encoder==NULL because C14N requires UTF-8 output */
|
|
int n_buf;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
|
|
for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
|
|
for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
|
|
for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
|
|
for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
nodes = gen_xmlNodeSetPtr(n_nodes, 1);
|
|
mode = gen_int(n_mode, 2);
|
|
inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
|
|
with_comments = gen_int(n_with_comments, 4);
|
|
buf = gen_xmlOutputBufferPtr(n_buf, 5);
|
|
|
|
ret_val = xmlC14NDocSaveTo(doc, nodes, mode, inclusive_ns_prefixes, with_comments, buf);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNodeSetPtr(n_nodes, nodes, 1);
|
|
des_int(n_mode, mode, 2);
|
|
des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
|
|
des_int(n_with_comments, with_comments, 4);
|
|
des_xmlOutputBufferPtr(n_buf, buf, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlC14NDocSaveTo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_nodes);
|
|
printf(" %d", n_mode);
|
|
printf(" %d", n_inclusive_ns_prefixes);
|
|
printf(" %d", n_with_comments);
|
|
printf(" %d", n_buf);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlC14NExecute(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_c14n(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing c14n : 3 of 4 functions ...\n");
|
|
test_ret += test_xmlC14NDocDumpMemory();
|
|
test_ret += test_xmlC14NDocSave();
|
|
test_ret += test_xmlC14NDocSaveTo();
|
|
test_ret += test_xmlC14NExecute();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module c14n: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
#ifdef LIBXML_CATALOG_ENABLED
|
|
|
|
#define gen_nb_xmlCatalogPtr 1
|
|
#define gen_xmlCatalogPtr(no, nr) NULL
|
|
#define des_xmlCatalogPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlACatalogAdd(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlCatalogPtr catal; /* a Catalog */
|
|
int n_catal;
|
|
const xmlChar * type; /* the type of record to add to the catalog */
|
|
int n_type;
|
|
const xmlChar * orig; /* the system, public or prefix to match */
|
|
int n_orig;
|
|
const xmlChar * replace; /* the replacement value for the match */
|
|
int n_replace;
|
|
|
|
for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
|
|
for (n_type = 0;n_type < gen_nb_const_xmlChar_ptr;n_type++) {
|
|
for (n_orig = 0;n_orig < gen_nb_const_xmlChar_ptr;n_orig++) {
|
|
for (n_replace = 0;n_replace < gen_nb_const_xmlChar_ptr;n_replace++) {
|
|
mem_base = xmlMemBlocks();
|
|
catal = gen_xmlCatalogPtr(n_catal, 0);
|
|
type = gen_const_xmlChar_ptr(n_type, 1);
|
|
orig = gen_const_xmlChar_ptr(n_orig, 2);
|
|
replace = gen_const_xmlChar_ptr(n_replace, 3);
|
|
|
|
ret_val = xmlACatalogAdd(catal, type, orig, replace);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlCatalogPtr(n_catal, catal, 0);
|
|
des_const_xmlChar_ptr(n_type, type, 1);
|
|
des_const_xmlChar_ptr(n_orig, orig, 2);
|
|
des_const_xmlChar_ptr(n_replace, replace, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlACatalogAdd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_catal);
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_orig);
|
|
printf(" %d", n_replace);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlACatalogDump(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlCatalogPtr catal; /* a Catalog */
|
|
int n_catal;
|
|
FILE * out; /* the file. */
|
|
int n_out;
|
|
|
|
for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
|
|
for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
|
|
mem_base = xmlMemBlocks();
|
|
catal = gen_xmlCatalogPtr(n_catal, 0);
|
|
out = gen_FILE_ptr(n_out, 1);
|
|
|
|
xmlACatalogDump(catal, out);
|
|
call_tests++;
|
|
des_xmlCatalogPtr(n_catal, catal, 0);
|
|
des_FILE_ptr(n_out, out, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlACatalogDump",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_catal);
|
|
printf(" %d", n_out);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlACatalogRemove(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlCatalogPtr catal; /* a Catalog */
|
|
int n_catal;
|
|
const xmlChar * value; /* the value to remove */
|
|
int n_value;
|
|
|
|
for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
catal = gen_xmlCatalogPtr(n_catal, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
|
|
ret_val = xmlACatalogRemove(catal, value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlCatalogPtr(n_catal, catal, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlACatalogRemove",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_catal);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlACatalogResolve(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlCatalogPtr catal; /* a Catalog */
|
|
int n_catal;
|
|
const xmlChar * pubID; /* the public ID string */
|
|
int n_pubID;
|
|
const xmlChar * sysID; /* the system ID string */
|
|
int n_sysID;
|
|
|
|
for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
|
|
for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
|
|
for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
|
|
mem_base = xmlMemBlocks();
|
|
catal = gen_xmlCatalogPtr(n_catal, 0);
|
|
pubID = gen_const_xmlChar_ptr(n_pubID, 1);
|
|
sysID = gen_const_xmlChar_ptr(n_sysID, 2);
|
|
|
|
ret_val = xmlACatalogResolve(catal, pubID, sysID);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlCatalogPtr(n_catal, catal, 0);
|
|
des_const_xmlChar_ptr(n_pubID, pubID, 1);
|
|
des_const_xmlChar_ptr(n_sysID, sysID, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlACatalogResolve",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_catal);
|
|
printf(" %d", n_pubID);
|
|
printf(" %d", n_sysID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlACatalogResolvePublic(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlCatalogPtr catal; /* a Catalog */
|
|
int n_catal;
|
|
const xmlChar * pubID; /* the public ID string */
|
|
int n_pubID;
|
|
|
|
for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
|
|
for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
|
|
mem_base = xmlMemBlocks();
|
|
catal = gen_xmlCatalogPtr(n_catal, 0);
|
|
pubID = gen_const_xmlChar_ptr(n_pubID, 1);
|
|
|
|
ret_val = xmlACatalogResolvePublic(catal, pubID);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlCatalogPtr(n_catal, catal, 0);
|
|
des_const_xmlChar_ptr(n_pubID, pubID, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlACatalogResolvePublic",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_catal);
|
|
printf(" %d", n_pubID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlACatalogResolveSystem(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlCatalogPtr catal; /* a Catalog */
|
|
int n_catal;
|
|
const xmlChar * sysID; /* the system ID string */
|
|
int n_sysID;
|
|
|
|
for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
|
|
for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
|
|
mem_base = xmlMemBlocks();
|
|
catal = gen_xmlCatalogPtr(n_catal, 0);
|
|
sysID = gen_const_xmlChar_ptr(n_sysID, 1);
|
|
|
|
ret_val = xmlACatalogResolveSystem(catal, sysID);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlCatalogPtr(n_catal, catal, 0);
|
|
des_const_xmlChar_ptr(n_sysID, sysID, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlACatalogResolveSystem",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_catal);
|
|
printf(" %d", n_sysID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlACatalogResolveURI(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlCatalogPtr catal; /* a Catalog */
|
|
int n_catal;
|
|
const xmlChar * URI; /* the URI */
|
|
int n_URI;
|
|
|
|
for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
|
|
for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
|
|
mem_base = xmlMemBlocks();
|
|
catal = gen_xmlCatalogPtr(n_catal, 0);
|
|
URI = gen_const_xmlChar_ptr(n_URI, 1);
|
|
|
|
ret_val = xmlACatalogResolveURI(catal, URI);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlCatalogPtr(n_catal, catal, 0);
|
|
des_const_xmlChar_ptr(n_URI, URI, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlACatalogResolveURI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_catal);
|
|
printf(" %d", n_URI);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogAdd(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * type; /* the type of record to add to the catalog */
|
|
int n_type;
|
|
const xmlChar * orig; /* the system, public or prefix to match */
|
|
int n_orig;
|
|
const xmlChar * replace; /* the replacement value for the match */
|
|
int n_replace;
|
|
|
|
for (n_type = 0;n_type < gen_nb_const_xmlChar_ptr;n_type++) {
|
|
for (n_orig = 0;n_orig < gen_nb_const_xmlChar_ptr;n_orig++) {
|
|
for (n_replace = 0;n_replace < gen_nb_const_xmlChar_ptr;n_replace++) {
|
|
mem_base = xmlMemBlocks();
|
|
type = gen_const_xmlChar_ptr(n_type, 0);
|
|
orig = gen_const_xmlChar_ptr(n_orig, 1);
|
|
replace = gen_const_xmlChar_ptr(n_replace, 2);
|
|
|
|
ret_val = xmlCatalogAdd(type, orig, replace);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_type, type, 0);
|
|
des_const_xmlChar_ptr(n_orig, orig, 1);
|
|
des_const_xmlChar_ptr(n_replace, replace, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCatalogAdd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_orig);
|
|
printf(" %d", n_replace);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogCleanup(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
|
|
|
|
xmlCatalogCleanup();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogConvert(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int ret_val;
|
|
|
|
|
|
ret_val = xmlCatalogConvert();
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogDump(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
FILE * out; /* the file. */
|
|
int n_out;
|
|
|
|
for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_FILE_ptr(n_out, 0);
|
|
|
|
xmlCatalogDump(out);
|
|
call_tests++;
|
|
des_FILE_ptr(n_out, out, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCatalogDump",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogGetDefaults(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlCatalogAllow ret_val;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
ret_val = xmlCatalogGetDefaults();
|
|
desret_xmlCatalogAllow(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCatalogGetDefaults",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogIsEmpty(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlCatalogPtr catal; /* should this create an SGML catalog */
|
|
int n_catal;
|
|
|
|
for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
|
|
mem_base = xmlMemBlocks();
|
|
catal = gen_xmlCatalogPtr(n_catal, 0);
|
|
|
|
ret_val = xmlCatalogIsEmpty(catal);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlCatalogPtr(n_catal, catal, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCatalogIsEmpty",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_catal);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogLocalResolve(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
void * catalogs; /* a document's list of catalogs */
|
|
int n_catalogs;
|
|
const xmlChar * pubID; /* the public ID string */
|
|
int n_pubID;
|
|
const xmlChar * sysID; /* the system ID string */
|
|
int n_sysID;
|
|
|
|
for (n_catalogs = 0;n_catalogs < gen_nb_void_ptr;n_catalogs++) {
|
|
for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
|
|
for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
|
|
mem_base = xmlMemBlocks();
|
|
catalogs = gen_void_ptr(n_catalogs, 0);
|
|
pubID = gen_const_xmlChar_ptr(n_pubID, 1);
|
|
sysID = gen_const_xmlChar_ptr(n_sysID, 2);
|
|
|
|
ret_val = xmlCatalogLocalResolve(catalogs, pubID, sysID);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_catalogs, catalogs, 0);
|
|
des_const_xmlChar_ptr(n_pubID, pubID, 1);
|
|
des_const_xmlChar_ptr(n_sysID, sysID, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCatalogLocalResolve",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_catalogs);
|
|
printf(" %d", n_pubID);
|
|
printf(" %d", n_sysID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogLocalResolveURI(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
void * catalogs; /* a document's list of catalogs */
|
|
int n_catalogs;
|
|
const xmlChar * URI; /* the URI */
|
|
int n_URI;
|
|
|
|
for (n_catalogs = 0;n_catalogs < gen_nb_void_ptr;n_catalogs++) {
|
|
for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
|
|
mem_base = xmlMemBlocks();
|
|
catalogs = gen_void_ptr(n_catalogs, 0);
|
|
URI = gen_const_xmlChar_ptr(n_URI, 1);
|
|
|
|
ret_val = xmlCatalogLocalResolveURI(catalogs, URI);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_catalogs, catalogs, 0);
|
|
des_const_xmlChar_ptr(n_URI, URI, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCatalogLocalResolveURI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_catalogs);
|
|
printf(" %d", n_URI);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogRemove(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int ret_val;
|
|
const xmlChar * value; /* the value to remove */
|
|
int n_value;
|
|
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
value = gen_const_xmlChar_ptr(n_value, 0);
|
|
|
|
ret_val = xmlCatalogRemove(value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_value, value, 0);
|
|
xmlResetLastError();
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogResolve(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
xmlChar * ret_val;
|
|
const xmlChar * pubID; /* the public ID string */
|
|
int n_pubID;
|
|
const xmlChar * sysID; /* the system ID string */
|
|
int n_sysID;
|
|
|
|
for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
|
|
for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
|
|
pubID = gen_const_xmlChar_ptr(n_pubID, 0);
|
|
sysID = gen_const_xmlChar_ptr(n_sysID, 1);
|
|
|
|
ret_val = xmlCatalogResolve(pubID, sysID);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_pubID, pubID, 0);
|
|
des_const_xmlChar_ptr(n_sysID, sysID, 1);
|
|
xmlResetLastError();
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogResolvePublic(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * pubID; /* the public ID string */
|
|
int n_pubID;
|
|
|
|
for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
|
|
mem_base = xmlMemBlocks();
|
|
pubID = gen_const_xmlChar_ptr(n_pubID, 0);
|
|
|
|
ret_val = xmlCatalogResolvePublic(pubID);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_pubID, pubID, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCatalogResolvePublic",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_pubID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogResolveSystem(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * sysID; /* the system ID string */
|
|
int n_sysID;
|
|
|
|
for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
|
|
mem_base = xmlMemBlocks();
|
|
sysID = gen_const_xmlChar_ptr(n_sysID, 0);
|
|
|
|
ret_val = xmlCatalogResolveSystem(sysID);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_sysID, sysID, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCatalogResolveSystem",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sysID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogResolveURI(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * URI; /* the URI */
|
|
int n_URI;
|
|
|
|
for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
|
|
mem_base = xmlMemBlocks();
|
|
URI = gen_const_xmlChar_ptr(n_URI, 0);
|
|
|
|
ret_val = xmlCatalogResolveURI(URI);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_URI, URI, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCatalogResolveURI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URI);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogSetDefaultPrefer(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlCatalogPrefer ret_val;
|
|
xmlCatalogPrefer prefer; /* the default preference for delegation */
|
|
int n_prefer;
|
|
|
|
for (n_prefer = 0;n_prefer < gen_nb_xmlCatalogPrefer;n_prefer++) {
|
|
mem_base = xmlMemBlocks();
|
|
prefer = gen_xmlCatalogPrefer(n_prefer, 0);
|
|
|
|
ret_val = xmlCatalogSetDefaultPrefer(prefer);
|
|
desret_xmlCatalogPrefer(ret_val);
|
|
call_tests++;
|
|
des_xmlCatalogPrefer(n_prefer, prefer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCatalogSetDefaultPrefer",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_prefer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCatalogSetDefaults(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlCatalogAllow allow; /* what catalogs should be accepted */
|
|
int n_allow;
|
|
|
|
for (n_allow = 0;n_allow < gen_nb_xmlCatalogAllow;n_allow++) {
|
|
mem_base = xmlMemBlocks();
|
|
allow = gen_xmlCatalogAllow(n_allow, 0);
|
|
|
|
xmlCatalogSetDefaults(allow);
|
|
call_tests++;
|
|
des_xmlCatalogAllow(n_allow, allow, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCatalogSetDefaults",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_allow);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlConvertSGMLCatalog(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlCatalogPtr catal; /* the catalog */
|
|
int n_catal;
|
|
|
|
for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
|
|
mem_base = xmlMemBlocks();
|
|
catal = gen_xmlCatalogPtr(n_catal, 0);
|
|
|
|
ret_val = xmlConvertSGMLCatalog(catal);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlCatalogPtr(n_catal, catal, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlConvertSGMLCatalog",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_catal);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlInitializeCatalog(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlInitializeCatalog();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlInitializeCatalog",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlLoadACatalog(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlLoadCatalog(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int ret_val;
|
|
const char * filename; /* a file path */
|
|
int n_filename;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
filename = gen_filepath(n_filename, 0);
|
|
|
|
ret_val = xmlLoadCatalog(filename);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
xmlResetLastError();
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlLoadCatalogs(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
const char * pathss; /* a list of directories separated by a colon or a space. */
|
|
int n_pathss;
|
|
|
|
for (n_pathss = 0;n_pathss < gen_nb_const_char_ptr;n_pathss++) {
|
|
pathss = gen_const_char_ptr(n_pathss, 0);
|
|
|
|
xmlLoadCatalogs(pathss);
|
|
call_tests++;
|
|
des_const_char_ptr(n_pathss, pathss, 0);
|
|
xmlResetLastError();
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlLoadSGMLSuperCatalog(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewCatalog(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseCatalogFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_CATALOG_ENABLED)
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
|
|
ret_val = xmlParseCatalogFile(filename);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseCatalogFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_catalog(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing catalog : 27 of 36 functions ...\n");
|
|
test_ret += test_xmlACatalogAdd();
|
|
test_ret += test_xmlACatalogDump();
|
|
test_ret += test_xmlACatalogRemove();
|
|
test_ret += test_xmlACatalogResolve();
|
|
test_ret += test_xmlACatalogResolvePublic();
|
|
test_ret += test_xmlACatalogResolveSystem();
|
|
test_ret += test_xmlACatalogResolveURI();
|
|
test_ret += test_xmlCatalogAdd();
|
|
test_ret += test_xmlCatalogCleanup();
|
|
test_ret += test_xmlCatalogConvert();
|
|
test_ret += test_xmlCatalogDump();
|
|
test_ret += test_xmlCatalogGetDefaults();
|
|
test_ret += test_xmlCatalogIsEmpty();
|
|
test_ret += test_xmlCatalogLocalResolve();
|
|
test_ret += test_xmlCatalogLocalResolveURI();
|
|
test_ret += test_xmlCatalogRemove();
|
|
test_ret += test_xmlCatalogResolve();
|
|
test_ret += test_xmlCatalogResolvePublic();
|
|
test_ret += test_xmlCatalogResolveSystem();
|
|
test_ret += test_xmlCatalogResolveURI();
|
|
test_ret += test_xmlCatalogSetDefaultPrefer();
|
|
test_ret += test_xmlCatalogSetDefaults();
|
|
test_ret += test_xmlConvertSGMLCatalog();
|
|
test_ret += test_xmlInitializeCatalog();
|
|
test_ret += test_xmlLoadACatalog();
|
|
test_ret += test_xmlLoadCatalog();
|
|
test_ret += test_xmlLoadCatalogs();
|
|
test_ret += test_xmlLoadSGMLSuperCatalog();
|
|
test_ret += test_xmlNewCatalog();
|
|
test_ret += test_xmlParseCatalogFile();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module catalog: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
#define gen_nb_const_xmlChRangeGroup_ptr 1
|
|
#define gen_const_xmlChRangeGroup_ptr(no, nr) NULL
|
|
#define des_const_xmlChRangeGroup_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlCharInRange(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned int val; /* character to be validated */
|
|
int n_val;
|
|
const xmlChRangeGroup * rptr; /* pointer to range to be used to validate */
|
|
int n_rptr;
|
|
|
|
for (n_val = 0;n_val < gen_nb_unsigned_int;n_val++) {
|
|
for (n_rptr = 0;n_rptr < gen_nb_const_xmlChRangeGroup_ptr;n_rptr++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_unsigned_int(n_val, 0);
|
|
rptr = gen_const_xmlChRangeGroup_ptr(n_rptr, 1);
|
|
|
|
ret_val = xmlCharInRange(val, rptr);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_int(n_val, val, 0);
|
|
des_const_xmlChRangeGroup_ptr(n_rptr, rptr, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCharInRange",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf(" %d", n_rptr);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsBaseChar(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned int ch; /* character to validate */
|
|
int n_ch;
|
|
|
|
for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
|
|
mem_base = xmlMemBlocks();
|
|
ch = gen_unsigned_int(n_ch, 0);
|
|
|
|
ret_val = xmlIsBaseChar(ch);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_int(n_ch, ch, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsBaseChar",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ch);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsBlank(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned int ch; /* character to validate */
|
|
int n_ch;
|
|
|
|
for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
|
|
mem_base = xmlMemBlocks();
|
|
ch = gen_unsigned_int(n_ch, 0);
|
|
|
|
ret_val = xmlIsBlank(ch);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_int(n_ch, ch, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsBlank",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ch);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsChar(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned int ch; /* character to validate */
|
|
int n_ch;
|
|
|
|
for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
|
|
mem_base = xmlMemBlocks();
|
|
ch = gen_unsigned_int(n_ch, 0);
|
|
|
|
ret_val = xmlIsChar(ch);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_int(n_ch, ch, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsChar",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ch);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsCombining(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned int ch; /* character to validate */
|
|
int n_ch;
|
|
|
|
for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
|
|
mem_base = xmlMemBlocks();
|
|
ch = gen_unsigned_int(n_ch, 0);
|
|
|
|
ret_val = xmlIsCombining(ch);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_int(n_ch, ch, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsCombining",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ch);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsDigit(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned int ch; /* character to validate */
|
|
int n_ch;
|
|
|
|
for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
|
|
mem_base = xmlMemBlocks();
|
|
ch = gen_unsigned_int(n_ch, 0);
|
|
|
|
ret_val = xmlIsDigit(ch);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_int(n_ch, ch, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsDigit",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ch);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsExtender(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned int ch; /* character to validate */
|
|
int n_ch;
|
|
|
|
for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
|
|
mem_base = xmlMemBlocks();
|
|
ch = gen_unsigned_int(n_ch, 0);
|
|
|
|
ret_val = xmlIsExtender(ch);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_int(n_ch, ch, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsExtender",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ch);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsIdeographic(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned int ch; /* character to validate */
|
|
int n_ch;
|
|
|
|
for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
|
|
mem_base = xmlMemBlocks();
|
|
ch = gen_unsigned_int(n_ch, 0);
|
|
|
|
ret_val = xmlIsIdeographic(ch);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_int(n_ch, ch, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsIdeographic",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ch);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsPubidChar(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned int ch; /* character to validate */
|
|
int n_ch;
|
|
|
|
for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
|
|
mem_base = xmlMemBlocks();
|
|
ch = gen_unsigned_int(n_ch, 0);
|
|
|
|
ret_val = xmlIsPubidChar(ch);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_int(n_ch, ch, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsPubidChar",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ch);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_chvalid(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing chvalid : 9 of 9 functions ...\n");
|
|
test_ret += test_xmlCharInRange();
|
|
test_ret += test_xmlIsBaseChar();
|
|
test_ret += test_xmlIsBlank();
|
|
test_ret += test_xmlIsChar();
|
|
test_ret += test_xmlIsCombining();
|
|
test_ret += test_xmlIsDigit();
|
|
test_ret += test_xmlIsExtender();
|
|
test_ret += test_xmlIsIdeographic();
|
|
test_ret += test_xmlIsPubidChar();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module chvalid: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlBoolToText(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
const char * ret_val;
|
|
int boolval; /* a bool to turn into text */
|
|
int n_boolval;
|
|
|
|
for (n_boolval = 0;n_boolval < gen_nb_int;n_boolval++) {
|
|
mem_base = xmlMemBlocks();
|
|
boolval = gen_int(n_boolval, 0);
|
|
|
|
ret_val = xmlBoolToText(boolval);
|
|
desret_const_char_ptr(ret_val);
|
|
call_tests++;
|
|
des_int(n_boolval, boolval, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBoolToText",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_boolval);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDebugCheckDocument(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
|
|
for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_debug_FILE_ptr(n_output, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
|
|
ret_val = xmlDebugCheckDocument(output, doc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_debug_FILE_ptr(n_output, output, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDebugCheckDocument",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDebugDumpAttr(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
xmlAttrPtr attr; /* the attribute */
|
|
int n_attr;
|
|
int depth; /* the indentation level. */
|
|
int n_depth;
|
|
|
|
for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
|
|
for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
|
|
for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_debug_FILE_ptr(n_output, 0);
|
|
attr = gen_xmlAttrPtr(n_attr, 1);
|
|
depth = gen_int(n_depth, 2);
|
|
|
|
xmlDebugDumpAttr(output, attr, depth);
|
|
call_tests++;
|
|
des_debug_FILE_ptr(n_output, output, 0);
|
|
des_xmlAttrPtr(n_attr, attr, 1);
|
|
des_int(n_depth, depth, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDebugDumpAttr",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_attr);
|
|
printf(" %d", n_depth);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDebugDumpAttrList(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
xmlAttrPtr attr; /* the attribute list */
|
|
int n_attr;
|
|
int depth; /* the indentation level. */
|
|
int n_depth;
|
|
|
|
for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
|
|
for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
|
|
for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_debug_FILE_ptr(n_output, 0);
|
|
attr = gen_xmlAttrPtr(n_attr, 1);
|
|
depth = gen_int(n_depth, 2);
|
|
|
|
xmlDebugDumpAttrList(output, attr, depth);
|
|
call_tests++;
|
|
des_debug_FILE_ptr(n_output, output, 0);
|
|
des_xmlAttrPtr(n_attr, attr, 1);
|
|
des_int(n_depth, depth, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDebugDumpAttrList",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_attr);
|
|
printf(" %d", n_depth);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDebugDumpDTD(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
xmlDtdPtr dtd; /* the DTD */
|
|
int n_dtd;
|
|
|
|
for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
|
|
for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_debug_FILE_ptr(n_output, 0);
|
|
dtd = gen_xmlDtdPtr(n_dtd, 1);
|
|
|
|
xmlDebugDumpDTD(output, dtd);
|
|
call_tests++;
|
|
des_debug_FILE_ptr(n_output, output, 0);
|
|
des_xmlDtdPtr(n_dtd, dtd, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDebugDumpDTD",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_dtd);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDebugDumpDocument(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
|
|
for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_debug_FILE_ptr(n_output, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
|
|
xmlDebugDumpDocument(output, doc);
|
|
call_tests++;
|
|
des_debug_FILE_ptr(n_output, output, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDebugDumpDocument",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDebugDumpDocumentHead(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
|
|
for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_debug_FILE_ptr(n_output, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
|
|
xmlDebugDumpDocumentHead(output, doc);
|
|
call_tests++;
|
|
des_debug_FILE_ptr(n_output, output, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDebugDumpDocumentHead",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDebugDumpEntities(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
|
|
for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_debug_FILE_ptr(n_output, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
|
|
xmlDebugDumpEntities(output, doc);
|
|
call_tests++;
|
|
des_debug_FILE_ptr(n_output, output, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDebugDumpEntities",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDebugDumpNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
xmlNodePtr node; /* the node */
|
|
int n_node;
|
|
int depth; /* the indentation level. */
|
|
int n_depth;
|
|
|
|
for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_debug_FILE_ptr(n_output, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
depth = gen_int(n_depth, 2);
|
|
|
|
xmlDebugDumpNode(output, node, depth);
|
|
call_tests++;
|
|
des_debug_FILE_ptr(n_output, output, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
des_int(n_depth, depth, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDebugDumpNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_depth);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDebugDumpNodeList(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
xmlNodePtr node; /* the node list */
|
|
int n_node;
|
|
int depth; /* the indentation level. */
|
|
int n_depth;
|
|
|
|
for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_debug_FILE_ptr(n_output, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
depth = gen_int(n_depth, 2);
|
|
|
|
xmlDebugDumpNodeList(output, node, depth);
|
|
call_tests++;
|
|
des_debug_FILE_ptr(n_output, output, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
des_int(n_depth, depth, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDebugDumpNodeList",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_depth);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDebugDumpOneNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
xmlNodePtr node; /* the node */
|
|
int n_node;
|
|
int depth; /* the indentation level. */
|
|
int n_depth;
|
|
|
|
for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_debug_FILE_ptr(n_output, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
depth = gen_int(n_depth, 2);
|
|
|
|
xmlDebugDumpOneNode(output, node, depth);
|
|
call_tests++;
|
|
des_debug_FILE_ptr(n_output, output, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
des_int(n_depth, depth, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDebugDumpOneNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_depth);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDebugDumpString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
const xmlChar * str; /* the string */
|
|
int n_str;
|
|
|
|
for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_debug_FILE_ptr(n_output, 0);
|
|
str = gen_const_xmlChar_ptr(n_str, 1);
|
|
|
|
xmlDebugDumpString(output, str);
|
|
call_tests++;
|
|
des_debug_FILE_ptr(n_output, output, 0);
|
|
des_const_xmlChar_ptr(n_str, str, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDebugDumpString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlLsCountNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodePtr node; /* the node to count */
|
|
int n_node;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
|
|
ret_val = xmlLsCountNode(node);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlLsCountNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlLsOneNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
xmlNodePtr node; /* the node to dump */
|
|
int n_node;
|
|
|
|
for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_debug_FILE_ptr(n_output, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
|
|
xmlLsOneNode(output, node);
|
|
call_tests++;
|
|
des_debug_FILE_ptr(n_output, output, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlLsOneNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlShell(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_char_ptr 1
|
|
#define gen_char_ptr(no, nr) NULL
|
|
#define des_char_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlShellBase(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlShellCtxtPtr ctxt; /* the shell context */
|
|
int n_ctxt;
|
|
char * arg; /* unused */
|
|
int n_arg;
|
|
xmlNodePtr node; /* a node */
|
|
int n_node;
|
|
xmlNodePtr node2; /* unused */
|
|
int n_node2;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
|
|
for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
|
|
arg = gen_char_ptr(n_arg, 1);
|
|
node = gen_xmlNodePtr(n_node, 2);
|
|
node2 = gen_xmlNodePtr(n_node2, 3);
|
|
|
|
ret_val = xmlShellBase(ctxt, arg, node, node2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_char_ptr(n_arg, arg, 1);
|
|
des_xmlNodePtr(n_node, node, 2);
|
|
des_xmlNodePtr(n_node2, node2, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlShellBase",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_arg);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_node2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlShellCat(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlShellCtxtPtr ctxt; /* the shell context */
|
|
int n_ctxt;
|
|
char * arg; /* unused */
|
|
int n_arg;
|
|
xmlNodePtr node; /* a node */
|
|
int n_node;
|
|
xmlNodePtr node2; /* unused */
|
|
int n_node2;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
|
|
for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
|
|
arg = gen_char_ptr(n_arg, 1);
|
|
node = gen_xmlNodePtr(n_node, 2);
|
|
node2 = gen_xmlNodePtr(n_node2, 3);
|
|
|
|
ret_val = xmlShellCat(ctxt, arg, node, node2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_char_ptr(n_arg, arg, 1);
|
|
des_xmlNodePtr(n_node, node, 2);
|
|
des_xmlNodePtr(n_node2, node2, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlShellCat",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_arg);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_node2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlShellDir(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlShellCtxtPtr ctxt; /* the shell context */
|
|
int n_ctxt;
|
|
char * arg; /* unused */
|
|
int n_arg;
|
|
xmlNodePtr node; /* a node */
|
|
int n_node;
|
|
xmlNodePtr node2; /* unused */
|
|
int n_node2;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
|
|
for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
|
|
arg = gen_char_ptr(n_arg, 1);
|
|
node = gen_xmlNodePtr(n_node, 2);
|
|
node2 = gen_xmlNodePtr(n_node2, 3);
|
|
|
|
ret_val = xmlShellDir(ctxt, arg, node, node2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_char_ptr(n_arg, arg, 1);
|
|
des_xmlNodePtr(n_node, node, 2);
|
|
des_xmlNodePtr(n_node2, node2, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlShellDir",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_arg);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_node2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlShellDu(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlShellCtxtPtr ctxt; /* the shell context */
|
|
int n_ctxt;
|
|
char * arg; /* unused */
|
|
int n_arg;
|
|
xmlNodePtr tree; /* a node defining a subtree */
|
|
int n_tree;
|
|
xmlNodePtr node2; /* unused */
|
|
int n_node2;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
|
|
for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
|
|
for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
|
|
for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
|
|
arg = gen_char_ptr(n_arg, 1);
|
|
tree = gen_xmlNodePtr(n_tree, 2);
|
|
node2 = gen_xmlNodePtr(n_node2, 3);
|
|
|
|
ret_val = xmlShellDu(ctxt, arg, tree, node2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_char_ptr(n_arg, arg, 1);
|
|
des_xmlNodePtr(n_tree, tree, 2);
|
|
des_xmlNodePtr(n_node2, node2, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlShellDu",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_arg);
|
|
printf(" %d", n_tree);
|
|
printf(" %d", n_node2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlShellList(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlShellCtxtPtr ctxt; /* the shell context */
|
|
int n_ctxt;
|
|
char * arg; /* unused */
|
|
int n_arg;
|
|
xmlNodePtr node; /* a node */
|
|
int n_node;
|
|
xmlNodePtr node2; /* unused */
|
|
int n_node2;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
|
|
for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
|
|
arg = gen_char_ptr(n_arg, 1);
|
|
node = gen_xmlNodePtr(n_node, 2);
|
|
node2 = gen_xmlNodePtr(n_node2, 3);
|
|
|
|
ret_val = xmlShellList(ctxt, arg, node, node2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_char_ptr(n_arg, arg, 1);
|
|
des_xmlNodePtr(n_node, node, 2);
|
|
des_xmlNodePtr(n_node2, node2, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlShellList",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_arg);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_node2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlShellLoad(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlShellCtxtPtr ctxt; /* the shell context */
|
|
int n_ctxt;
|
|
char * filename; /* the file name */
|
|
int n_filename;
|
|
xmlNodePtr node; /* unused */
|
|
int n_node;
|
|
xmlNodePtr node2; /* unused */
|
|
int n_node2;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
|
|
for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
|
|
filename = gen_char_ptr(n_filename, 1);
|
|
node = gen_xmlNodePtr(n_node, 2);
|
|
node2 = gen_xmlNodePtr(n_node2, 3);
|
|
|
|
ret_val = xmlShellLoad(ctxt, filename, node, node2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_char_ptr(n_filename, filename, 1);
|
|
des_xmlNodePtr(n_node, node, 2);
|
|
des_xmlNodePtr(n_node2, node2, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlShellLoad",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_node2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlShellPrintXPathResult(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr list; /* a valid result generated by an xpath evaluation */
|
|
int n_list;
|
|
|
|
for (n_list = 0;n_list < gen_nb_xmlXPathObjectPtr;n_list++) {
|
|
mem_base = xmlMemBlocks();
|
|
list = gen_xmlXPathObjectPtr(n_list, 0);
|
|
|
|
xmlShellPrintXPathResult(list);
|
|
call_tests++;
|
|
des_xmlXPathObjectPtr(n_list, list, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlShellPrintXPathResult",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_list);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlShellPwd(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlShellCtxtPtr ctxt; /* the shell context */
|
|
int n_ctxt;
|
|
char * buffer; /* the output buffer */
|
|
int n_buffer;
|
|
xmlNodePtr node; /* a node */
|
|
int n_node;
|
|
xmlNodePtr node2; /* unused */
|
|
int n_node2;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
|
|
for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
|
|
buffer = gen_char_ptr(n_buffer, 1);
|
|
node = gen_xmlNodePtr(n_node, 2);
|
|
node2 = gen_xmlNodePtr(n_node2, 3);
|
|
|
|
ret_val = xmlShellPwd(ctxt, buffer, node, node2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_char_ptr(n_buffer, buffer, 1);
|
|
des_xmlNodePtr(n_node, node, 2);
|
|
des_xmlNodePtr(n_node2, node2, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlShellPwd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_node2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlShellSave(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlShellCtxtPtr ctxt; /* the shell context */
|
|
int n_ctxt;
|
|
char * filename; /* the file name (optional) */
|
|
int n_filename;
|
|
xmlNodePtr node; /* unused */
|
|
int n_node;
|
|
xmlNodePtr node2; /* unused */
|
|
int n_node2;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
|
|
for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
|
|
filename = gen_char_ptr(n_filename, 1);
|
|
node = gen_xmlNodePtr(n_node, 2);
|
|
node2 = gen_xmlNodePtr(n_node2, 3);
|
|
|
|
ret_val = xmlShellSave(ctxt, filename, node, node2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_char_ptr(n_filename, filename, 1);
|
|
des_xmlNodePtr(n_node, node, 2);
|
|
des_xmlNodePtr(n_node2, node2, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlShellSave",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_node2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlShellValidate(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlShellCtxtPtr ctxt; /* the shell context */
|
|
int n_ctxt;
|
|
char * dtd; /* the DTD URI (optional) */
|
|
int n_dtd;
|
|
xmlNodePtr node; /* unused */
|
|
int n_node;
|
|
xmlNodePtr node2; /* unused */
|
|
int n_node2;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
|
|
for (n_dtd = 0;n_dtd < gen_nb_char_ptr;n_dtd++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
|
|
dtd = gen_char_ptr(n_dtd, 1);
|
|
node = gen_xmlNodePtr(n_node, 2);
|
|
node2 = gen_xmlNodePtr(n_node2, 3);
|
|
|
|
ret_val = xmlShellValidate(ctxt, dtd, node, node2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_char_ptr(n_dtd, dtd, 1);
|
|
des_xmlNodePtr(n_node, node, 2);
|
|
des_xmlNodePtr(n_node2, node2, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlShellValidate",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_dtd);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_node2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlShellWrite(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlShellCtxtPtr ctxt; /* the shell context */
|
|
int n_ctxt;
|
|
char * filename; /* the file name */
|
|
int n_filename;
|
|
xmlNodePtr node; /* a node in the tree */
|
|
int n_node;
|
|
xmlNodePtr node2; /* unused */
|
|
int n_node2;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
|
|
for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
|
|
filename = gen_char_ptr(n_filename, 1);
|
|
node = gen_xmlNodePtr(n_node, 2);
|
|
node2 = gen_xmlNodePtr(n_node2, 3);
|
|
|
|
ret_val = xmlShellWrite(ctxt, filename, node, node2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_char_ptr(n_filename, filename, 1);
|
|
des_xmlNodePtr(n_node, node, 2);
|
|
des_xmlNodePtr(n_node2, node2, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlShellWrite",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_node2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_debugXML(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing debugXML : 25 of 28 functions ...\n");
|
|
test_ret += test_xmlBoolToText();
|
|
test_ret += test_xmlDebugCheckDocument();
|
|
test_ret += test_xmlDebugDumpAttr();
|
|
test_ret += test_xmlDebugDumpAttrList();
|
|
test_ret += test_xmlDebugDumpDTD();
|
|
test_ret += test_xmlDebugDumpDocument();
|
|
test_ret += test_xmlDebugDumpDocumentHead();
|
|
test_ret += test_xmlDebugDumpEntities();
|
|
test_ret += test_xmlDebugDumpNode();
|
|
test_ret += test_xmlDebugDumpNodeList();
|
|
test_ret += test_xmlDebugDumpOneNode();
|
|
test_ret += test_xmlDebugDumpString();
|
|
test_ret += test_xmlLsCountNode();
|
|
test_ret += test_xmlLsOneNode();
|
|
test_ret += test_xmlShell();
|
|
test_ret += test_xmlShellBase();
|
|
test_ret += test_xmlShellCat();
|
|
test_ret += test_xmlShellDir();
|
|
test_ret += test_xmlShellDu();
|
|
test_ret += test_xmlShellList();
|
|
test_ret += test_xmlShellLoad();
|
|
test_ret += test_xmlShellPrintXPathResult();
|
|
test_ret += test_xmlShellPwd();
|
|
test_ret += test_xmlShellSave();
|
|
test_ret += test_xmlShellValidate();
|
|
test_ret += test_xmlShellWrite();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module debugXML: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlDictCleanup(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlDictCleanup();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDictCleanup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDictCreate(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDictPtr ret_val;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
ret_val = xmlDictCreate();
|
|
desret_xmlDictPtr(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDictCreate",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDictCreateSub(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDictPtr ret_val;
|
|
xmlDictPtr sub; /* an existing dictionary */
|
|
int n_sub;
|
|
|
|
for (n_sub = 0;n_sub < gen_nb_xmlDictPtr;n_sub++) {
|
|
mem_base = xmlMemBlocks();
|
|
sub = gen_xmlDictPtr(n_sub, 0);
|
|
|
|
ret_val = xmlDictCreateSub(sub);
|
|
desret_xmlDictPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDictPtr(n_sub, sub, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDictCreateSub",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sub);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDictExists(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlDictPtr dict; /* the dictionary */
|
|
int n_dict;
|
|
const xmlChar * name; /* the name of the userdata */
|
|
int n_name;
|
|
int len; /* the length of the name, if -1 it is recomputed */
|
|
int n_len;
|
|
|
|
for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
dict = gen_xmlDictPtr(n_dict, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((name != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST name)))
|
|
len = 0;
|
|
|
|
ret_val = xmlDictExists(dict, name, len);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlDictPtr(n_dict, dict, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDictExists",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_dict);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDictGetUsage(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDictLookup(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlDictPtr dict; /* dictionary */
|
|
int n_dict;
|
|
const xmlChar * name; /* string key */
|
|
int n_name;
|
|
int len; /* length of the key, if -1 it is recomputed */
|
|
int n_len;
|
|
|
|
for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
dict = gen_xmlDictPtr(n_dict, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((name != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST name)))
|
|
len = 0;
|
|
|
|
ret_val = xmlDictLookup(dict, name, len);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlDictPtr(n_dict, dict, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDictLookup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_dict);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDictOwns(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDictPtr dict; /* the dictionary */
|
|
int n_dict;
|
|
const xmlChar * str; /* the string */
|
|
int n_str;
|
|
|
|
for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
dict = gen_xmlDictPtr(n_dict, 0);
|
|
str = gen_const_xmlChar_ptr(n_str, 1);
|
|
|
|
ret_val = xmlDictOwns(dict, str);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDictPtr(n_dict, dict, 0);
|
|
des_const_xmlChar_ptr(n_str, str, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDictOwns",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_dict);
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDictQLookup(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlDictPtr dict; /* the dictionary */
|
|
int n_dict;
|
|
const xmlChar * prefix; /* the prefix */
|
|
int n_prefix;
|
|
const xmlChar * name; /* the name */
|
|
int n_name;
|
|
|
|
for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
dict = gen_xmlDictPtr(n_dict, 0);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
|
|
ret_val = xmlDictQLookup(dict, prefix, name);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlDictPtr(n_dict, dict, 0);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDictQLookup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_dict);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDictReference(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDictPtr dict; /* the dictionary */
|
|
int n_dict;
|
|
|
|
for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
|
|
mem_base = xmlMemBlocks();
|
|
dict = gen_xmlDictPtr(n_dict, 0);
|
|
|
|
ret_val = xmlDictReference(dict);
|
|
xmlDictFree(dict);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDictPtr(n_dict, dict, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDictReference",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_dict);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDictSetLimit(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDictSize(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDictPtr dict; /* the dictionary */
|
|
int n_dict;
|
|
|
|
for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
|
|
mem_base = xmlMemBlocks();
|
|
dict = gen_xmlDictPtr(n_dict, 0);
|
|
|
|
ret_val = xmlDictSize(dict);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDictPtr(n_dict, dict, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDictSize",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_dict);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlInitializeDict(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
ret_val = xmlInitializeDict();
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlInitializeDict",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_dict(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing dict : 10 of 13 functions ...\n");
|
|
test_ret += test_xmlDictCleanup();
|
|
test_ret += test_xmlDictCreate();
|
|
test_ret += test_xmlDictCreateSub();
|
|
test_ret += test_xmlDictExists();
|
|
test_ret += test_xmlDictGetUsage();
|
|
test_ret += test_xmlDictLookup();
|
|
test_ret += test_xmlDictOwns();
|
|
test_ret += test_xmlDictQLookup();
|
|
test_ret += test_xmlDictReference();
|
|
test_ret += test_xmlDictSetLimit();
|
|
test_ret += test_xmlDictSize();
|
|
test_ret += test_xmlInitializeDict();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module dict: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_UTF8Toisolat1(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
#ifdef LIBXML_OUTPUT_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned char * out; /* a pointer to an array of bytes to store the result */
|
|
int n_out;
|
|
int * outlen; /* the length of @out */
|
|
int n_outlen;
|
|
const unsigned char * in; /* a pointer to an array of UTF-8 chars */
|
|
int n_in;
|
|
int * inlen; /* the length of @in */
|
|
int n_inlen;
|
|
|
|
for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
|
|
for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
|
|
for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
|
|
for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_unsigned_char_ptr(n_out, 0);
|
|
outlen = gen_int_ptr(n_outlen, 1);
|
|
in = gen_const_unsigned_char_ptr(n_in, 2);
|
|
inlen = gen_int_ptr(n_inlen, 3);
|
|
|
|
ret_val = UTF8Toisolat1(out, outlen, in, inlen);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_char_ptr(n_out, out, 0);
|
|
des_int_ptr(n_outlen, outlen, 1);
|
|
des_const_unsigned_char_ptr(n_in, in, 2);
|
|
des_int_ptr(n_inlen, inlen, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in UTF8Toisolat1",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_outlen);
|
|
printf(" %d", n_in);
|
|
printf(" %d", n_inlen);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_isolat1ToUTF8(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
unsigned char * out; /* a pointer to an array of bytes to store the result */
|
|
int n_out;
|
|
int * outlen; /* the length of @out */
|
|
int n_outlen;
|
|
const unsigned char * in; /* a pointer to an array of ISO Latin 1 chars */
|
|
int n_in;
|
|
int * inlen; /* the length of @in */
|
|
int n_inlen;
|
|
|
|
for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
|
|
for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
|
|
for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
|
|
for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_unsigned_char_ptr(n_out, 0);
|
|
outlen = gen_int_ptr(n_outlen, 1);
|
|
in = gen_const_unsigned_char_ptr(n_in, 2);
|
|
inlen = gen_int_ptr(n_inlen, 3);
|
|
|
|
ret_val = isolat1ToUTF8(out, outlen, in, inlen);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_unsigned_char_ptr(n_out, out, 0);
|
|
des_int_ptr(n_outlen, outlen, 1);
|
|
des_const_unsigned_char_ptr(n_in, in, 2);
|
|
des_int_ptr(n_inlen, inlen, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in isolat1ToUTF8",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_outlen);
|
|
printf(" %d", n_in);
|
|
printf(" %d", n_inlen);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAddEncodingAlias(void) {
|
|
int test_ret = 0;
|
|
|
|
int ret_val;
|
|
const char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */
|
|
int n_name;
|
|
const char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
|
|
int n_alias;
|
|
|
|
for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
|
|
for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
|
|
name = gen_const_char_ptr(n_name, 0);
|
|
alias = gen_const_char_ptr(n_alias, 1);
|
|
|
|
ret_val = xmlAddEncodingAlias(name, alias);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_name, name, 0);
|
|
des_const_char_ptr(n_alias, alias, 1);
|
|
xmlResetLastError();
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlCharEncodingHandler_ptr 1
|
|
#define gen_xmlCharEncodingHandler_ptr(no, nr) NULL
|
|
#define des_xmlCharEncodingHandler_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlCharEncCloseFunc(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlCharEncodingHandler * handler; /* char encoding transformation data structure */
|
|
int n_handler;
|
|
|
|
for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
|
|
mem_base = xmlMemBlocks();
|
|
handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
|
|
|
|
ret_val = xmlCharEncCloseFunc(handler);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCharEncCloseFunc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_handler);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCharEncFirstLine(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlCharEncodingHandler * handler; /* char encoding transformation data structure */
|
|
int n_handler;
|
|
xmlBufferPtr out; /* an xmlBuffer for the output. */
|
|
int n_out;
|
|
xmlBufferPtr in; /* an xmlBuffer for the input */
|
|
int n_in;
|
|
|
|
for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
|
|
for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
|
|
for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
|
|
mem_base = xmlMemBlocks();
|
|
handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
|
|
out = gen_xmlBufferPtr(n_out, 1);
|
|
in = gen_xmlBufferPtr(n_in, 2);
|
|
|
|
ret_val = xmlCharEncFirstLine(handler, out, in);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
|
|
des_xmlBufferPtr(n_out, out, 1);
|
|
des_xmlBufferPtr(n_in, in, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCharEncFirstLine",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_handler);
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_in);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCharEncInFunc(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlCharEncodingHandler * handler; /* char encoding transformation data structure */
|
|
int n_handler;
|
|
xmlBufferPtr out; /* an xmlBuffer for the output. */
|
|
int n_out;
|
|
xmlBufferPtr in; /* an xmlBuffer for the input */
|
|
int n_in;
|
|
|
|
for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
|
|
for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
|
|
for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
|
|
mem_base = xmlMemBlocks();
|
|
handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
|
|
out = gen_xmlBufferPtr(n_out, 1);
|
|
in = gen_xmlBufferPtr(n_in, 2);
|
|
|
|
ret_val = xmlCharEncInFunc(handler, out, in);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
|
|
des_xmlBufferPtr(n_out, out, 1);
|
|
des_xmlBufferPtr(n_in, in, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCharEncInFunc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_handler);
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_in);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCharEncOutFunc(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlCharEncodingHandler * handler; /* char encoding transformation data structure */
|
|
int n_handler;
|
|
xmlBufferPtr out; /* an xmlBuffer for the output. */
|
|
int n_out;
|
|
xmlBufferPtr in; /* an xmlBuffer for the input */
|
|
int n_in;
|
|
|
|
for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
|
|
for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
|
|
for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
|
|
mem_base = xmlMemBlocks();
|
|
handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
|
|
out = gen_xmlBufferPtr(n_out, 1);
|
|
in = gen_xmlBufferPtr(n_in, 2);
|
|
|
|
ret_val = xmlCharEncOutFunc(handler, out, in);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
|
|
des_xmlBufferPtr(n_out, out, 1);
|
|
des_xmlBufferPtr(n_in, in, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCharEncOutFunc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_handler);
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_in);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCleanupCharEncodingHandlers(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
|
|
xmlCleanupCharEncodingHandlers();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCleanupEncodingAliases(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlCleanupEncodingAliases();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCleanupEncodingAliases",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDelEncodingAlias(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
|
|
int n_alias;
|
|
|
|
for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
|
|
mem_base = xmlMemBlocks();
|
|
alias = gen_const_char_ptr(n_alias, 0);
|
|
|
|
ret_val = xmlDelEncodingAlias(alias);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_alias, alias, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDelEncodingAlias",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_alias);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDetectCharEncoding(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlCharEncoding ret_val;
|
|
const unsigned char * in; /* a pointer to the first bytes of the XML entity, must be at least 2 bytes long (at least 4 if encoding is UTF4 variant). */
|
|
int n_in;
|
|
int len; /* pointer to the length of the buffer */
|
|
int n_len;
|
|
|
|
for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
in = gen_const_unsigned_char_ptr(n_in, 0);
|
|
len = gen_int(n_len, 1);
|
|
|
|
ret_val = xmlDetectCharEncoding(in, len);
|
|
desret_xmlCharEncoding(ret_val);
|
|
call_tests++;
|
|
des_const_unsigned_char_ptr(n_in, in, 0);
|
|
des_int(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDetectCharEncoding",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_in);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlFindCharEncodingHandler(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetCharEncodingHandler(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetCharEncodingName(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const char * ret_val;
|
|
xmlCharEncoding enc; /* the encoding */
|
|
int n_enc;
|
|
|
|
for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
|
|
mem_base = xmlMemBlocks();
|
|
enc = gen_xmlCharEncoding(n_enc, 0);
|
|
|
|
ret_val = xmlGetCharEncodingName(enc);
|
|
desret_const_char_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlCharEncoding(n_enc, enc, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetCharEncodingName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_enc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetEncodingAlias(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const char * ret_val;
|
|
const char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
|
|
int n_alias;
|
|
|
|
for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
|
|
mem_base = xmlMemBlocks();
|
|
alias = gen_const_char_ptr(n_alias, 0);
|
|
|
|
ret_val = xmlGetEncodingAlias(alias);
|
|
desret_const_char_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_alias, alias, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetEncodingAlias",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_alias);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlInitCharEncodingHandlers(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
|
|
xmlInitCharEncodingHandlers();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewCharEncodingHandler(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseCharEncoding(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlCharEncoding ret_val;
|
|
const char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */
|
|
int n_name;
|
|
|
|
for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
name = gen_const_char_ptr(n_name, 0);
|
|
|
|
ret_val = xmlParseCharEncoding(name);
|
|
desret_xmlCharEncoding(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_name, name, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseCharEncoding",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlCharEncodingHandlerPtr 1
|
|
#define gen_xmlCharEncodingHandlerPtr(no, nr) NULL
|
|
#define des_xmlCharEncodingHandlerPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlRegisterCharEncodingHandler(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlCharEncodingHandlerPtr handler; /* the xmlCharEncodingHandlerPtr handler block */
|
|
int n_handler;
|
|
|
|
for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
|
|
mem_base = xmlMemBlocks();
|
|
handler = gen_xmlCharEncodingHandlerPtr(n_handler, 0);
|
|
|
|
xmlRegisterCharEncodingHandler(handler);
|
|
call_tests++;
|
|
des_xmlCharEncodingHandlerPtr(n_handler, handler, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRegisterCharEncodingHandler",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_handler);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_encoding(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing encoding : 16 of 19 functions ...\n");
|
|
test_ret += test_UTF8Toisolat1();
|
|
test_ret += test_isolat1ToUTF8();
|
|
test_ret += test_xmlAddEncodingAlias();
|
|
test_ret += test_xmlCharEncCloseFunc();
|
|
test_ret += test_xmlCharEncFirstLine();
|
|
test_ret += test_xmlCharEncInFunc();
|
|
test_ret += test_xmlCharEncOutFunc();
|
|
test_ret += test_xmlCleanupCharEncodingHandlers();
|
|
test_ret += test_xmlCleanupEncodingAliases();
|
|
test_ret += test_xmlDelEncodingAlias();
|
|
test_ret += test_xmlDetectCharEncoding();
|
|
test_ret += test_xmlFindCharEncodingHandler();
|
|
test_ret += test_xmlGetCharEncodingHandler();
|
|
test_ret += test_xmlGetCharEncodingName();
|
|
test_ret += test_xmlGetEncodingAlias();
|
|
test_ret += test_xmlInitCharEncodingHandlers();
|
|
test_ret += test_xmlNewCharEncodingHandler();
|
|
test_ret += test_xmlParseCharEncoding();
|
|
test_ret += test_xmlRegisterCharEncodingHandler();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module encoding: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlAddDocEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlEntityPtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * name; /* the entity name */
|
|
int n_name;
|
|
int type; /* the entity type XML_xxx_yyy_ENTITY */
|
|
int n_type;
|
|
const xmlChar * ExternalID; /* the entity external ID if available */
|
|
int n_ExternalID;
|
|
const xmlChar * SystemID; /* the entity system ID if available */
|
|
int n_SystemID;
|
|
const xmlChar * content; /* the entity content */
|
|
int n_content;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_type = 0;n_type < gen_nb_int;n_type++) {
|
|
for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
|
|
for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
type = gen_int(n_type, 2);
|
|
ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
|
|
SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
|
|
content = gen_const_xmlChar_ptr(n_content, 5);
|
|
|
|
ret_val = xmlAddDocEntity(doc, name, type, ExternalID, SystemID, content);
|
|
desret_xmlEntityPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_int(n_type, type, 2);
|
|
des_const_xmlChar_ptr(n_ExternalID, ExternalID, 3);
|
|
des_const_xmlChar_ptr(n_SystemID, SystemID, 4);
|
|
des_const_xmlChar_ptr(n_content, content, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAddDocEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_ExternalID);
|
|
printf(" %d", n_SystemID);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAddDtdEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlEntityPtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * name; /* the entity name */
|
|
int n_name;
|
|
int type; /* the entity type XML_xxx_yyy_ENTITY */
|
|
int n_type;
|
|
const xmlChar * ExternalID; /* the entity external ID if available */
|
|
int n_ExternalID;
|
|
const xmlChar * SystemID; /* the entity system ID if available */
|
|
int n_SystemID;
|
|
const xmlChar * content; /* the entity content */
|
|
int n_content;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_type = 0;n_type < gen_nb_int;n_type++) {
|
|
for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
|
|
for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
type = gen_int(n_type, 2);
|
|
ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
|
|
SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
|
|
content = gen_const_xmlChar_ptr(n_content, 5);
|
|
|
|
ret_val = xmlAddDtdEntity(doc, name, type, ExternalID, SystemID, content);
|
|
desret_xmlEntityPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_int(n_type, type, 2);
|
|
des_const_xmlChar_ptr(n_ExternalID, ExternalID, 3);
|
|
des_const_xmlChar_ptr(n_SystemID, SystemID, 4);
|
|
des_const_xmlChar_ptr(n_content, content, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAddDtdEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_ExternalID);
|
|
printf(" %d", n_SystemID);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyEntitiesTable(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCreateEntitiesTable(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlEntitiesTablePtr 1
|
|
#define gen_xmlEntitiesTablePtr(no, nr) NULL
|
|
#define des_xmlEntitiesTablePtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlDumpEntitiesTable(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* An XML buffer. */
|
|
int n_buf;
|
|
xmlEntitiesTablePtr table; /* An entity table */
|
|
int n_table;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_table = 0;n_table < gen_nb_xmlEntitiesTablePtr;n_table++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
table = gen_xmlEntitiesTablePtr(n_table, 1);
|
|
|
|
xmlDumpEntitiesTable(buf, table);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlEntitiesTablePtr(n_table, table, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDumpEntitiesTable",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_table);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlEntityPtr 1
|
|
#define gen_xmlEntityPtr(no, nr) NULL
|
|
#define des_xmlEntityPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlDumpEntityDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* An XML buffer. */
|
|
int n_buf;
|
|
xmlEntityPtr ent; /* An entity table */
|
|
int n_ent;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_ent = 0;n_ent < gen_nb_xmlEntityPtr;n_ent++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
ent = gen_xmlEntityPtr(n_ent, 1);
|
|
|
|
xmlDumpEntityDecl(buf, ent);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlEntityPtr(n_ent, ent, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDumpEntityDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_ent);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlEncodeEntitiesReentrant(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlDocPtr doc; /* the document containing the string */
|
|
int n_doc;
|
|
const xmlChar * input; /* A string to convert to XML. */
|
|
int n_input;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
input = gen_const_xmlChar_ptr(n_input, 1);
|
|
|
|
ret_val = xmlEncodeEntitiesReentrant(doc, input);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_input, input, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlEncodeEntitiesReentrant",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_input);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_const_xmlDoc_ptr 1
|
|
#define gen_const_xmlDoc_ptr(no, nr) NULL
|
|
#define des_const_xmlDoc_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlEncodeSpecialChars(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlDoc * doc; /* the document containing the string */
|
|
int n_doc;
|
|
const xmlChar * input; /* A string to convert to XML. */
|
|
int n_input;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) {
|
|
for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_const_xmlDoc_ptr(n_doc, 0);
|
|
input = gen_const_xmlChar_ptr(n_input, 1);
|
|
|
|
ret_val = xmlEncodeSpecialChars(doc, input);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlDoc_ptr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_input, input, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlEncodeSpecialChars",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_input);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetDocEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlEntityPtr ret_val;
|
|
const xmlDoc * doc; /* the document referencing the entity */
|
|
int n_doc;
|
|
const xmlChar * name; /* the entity name */
|
|
int n_name;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_const_xmlDoc_ptr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlGetDocEntity(doc, name);
|
|
desret_xmlEntityPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlDoc_ptr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetDocEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetDtdEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlEntityPtr ret_val;
|
|
xmlDocPtr doc; /* the document referencing the entity */
|
|
int n_doc;
|
|
const xmlChar * name; /* the entity name */
|
|
int n_name;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlGetDtdEntity(doc, name);
|
|
desret_xmlEntityPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetDtdEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetParameterEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlEntityPtr ret_val;
|
|
xmlDocPtr doc; /* the document referencing the entity */
|
|
int n_doc;
|
|
const xmlChar * name; /* the entity name */
|
|
int n_name;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlGetParameterEntity(doc, name);
|
|
desret_xmlEntityPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetParameterEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetPredefinedEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlEntityPtr ret_val;
|
|
const xmlChar * name; /* the entity name */
|
|
int n_name;
|
|
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
name = gen_const_xmlChar_ptr(n_name, 0);
|
|
|
|
ret_val = xmlGetPredefinedEntity(name);
|
|
desret_xmlEntityPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_name, name, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetPredefinedEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlEntityPtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * name; /* the entity name */
|
|
int n_name;
|
|
int type; /* the entity type XML_xxx_yyy_ENTITY */
|
|
int n_type;
|
|
const xmlChar * ExternalID; /* the entity external ID if available */
|
|
int n_ExternalID;
|
|
const xmlChar * SystemID; /* the entity system ID if available */
|
|
int n_SystemID;
|
|
const xmlChar * content; /* the entity content */
|
|
int n_content;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_type = 0;n_type < gen_nb_int;n_type++) {
|
|
for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
|
|
for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
type = gen_int(n_type, 2);
|
|
ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
|
|
SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
|
|
content = gen_const_xmlChar_ptr(n_content, 5);
|
|
|
|
ret_val = xmlNewEntity(doc, name, type, ExternalID, SystemID, content);
|
|
desret_xmlEntityPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_int(n_type, type, 2);
|
|
des_const_xmlChar_ptr(n_ExternalID, ExternalID, 3);
|
|
des_const_xmlChar_ptr(n_SystemID, SystemID, 4);
|
|
des_const_xmlChar_ptr(n_content, content, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_ExternalID);
|
|
printf(" %d", n_SystemID);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_entities(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing entities : 11 of 18 functions ...\n");
|
|
test_ret += test_xmlAddDocEntity();
|
|
test_ret += test_xmlAddDtdEntity();
|
|
test_ret += test_xmlCopyEntitiesTable();
|
|
test_ret += test_xmlCreateEntitiesTable();
|
|
test_ret += test_xmlDumpEntitiesTable();
|
|
test_ret += test_xmlDumpEntityDecl();
|
|
test_ret += test_xmlEncodeEntitiesReentrant();
|
|
test_ret += test_xmlEncodeSpecialChars();
|
|
test_ret += test_xmlGetDocEntity();
|
|
test_ret += test_xmlGetDtdEntity();
|
|
test_ret += test_xmlGetParameterEntity();
|
|
test_ret += test_xmlGetPredefinedEntity();
|
|
test_ret += test_xmlNewEntity();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module entities: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlHashAddEntry(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * key; /* string key */
|
|
int n_key;
|
|
void * payload; /* pointer to the payload */
|
|
int n_payload;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
for (n_payload = 0;n_payload < gen_nb_void_ptr;n_payload++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
payload = gen_void_ptr(n_payload, 2);
|
|
|
|
ret_val = xmlHashAddEntry(hash, key, payload);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
des_void_ptr(n_payload, payload, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashAddEntry",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_key);
|
|
printf(" %d", n_payload);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashAddEntry2(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * key; /* first string key */
|
|
int n_key;
|
|
const xmlChar * key2; /* second string key */
|
|
int n_key2;
|
|
void * payload; /* pointer to the payload */
|
|
int n_payload;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
for (n_key2 = 0;n_key2 < gen_nb_const_xmlChar_ptr;n_key2++) {
|
|
for (n_payload = 0;n_payload < gen_nb_void_ptr;n_payload++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
key2 = gen_const_xmlChar_ptr(n_key2, 2);
|
|
payload = gen_void_ptr(n_payload, 3);
|
|
|
|
ret_val = xmlHashAddEntry2(hash, key, key2, payload);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
des_const_xmlChar_ptr(n_key2, key2, 2);
|
|
des_void_ptr(n_payload, payload, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashAddEntry2",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_key);
|
|
printf(" %d", n_key2);
|
|
printf(" %d", n_payload);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashAddEntry3(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * key; /* first string key */
|
|
int n_key;
|
|
const xmlChar * key2; /* second string key */
|
|
int n_key2;
|
|
const xmlChar * key3; /* third string key */
|
|
int n_key3;
|
|
void * payload; /* pointer to the payload */
|
|
int n_payload;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
for (n_key2 = 0;n_key2 < gen_nb_const_xmlChar_ptr;n_key2++) {
|
|
for (n_key3 = 0;n_key3 < gen_nb_const_xmlChar_ptr;n_key3++) {
|
|
for (n_payload = 0;n_payload < gen_nb_void_ptr;n_payload++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
key2 = gen_const_xmlChar_ptr(n_key2, 2);
|
|
key3 = gen_const_xmlChar_ptr(n_key3, 3);
|
|
payload = gen_void_ptr(n_payload, 4);
|
|
|
|
ret_val = xmlHashAddEntry3(hash, key, key2, key3, payload);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
des_const_xmlChar_ptr(n_key2, key2, 2);
|
|
des_const_xmlChar_ptr(n_key3, key3, 3);
|
|
des_void_ptr(n_payload, payload, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashAddEntry3",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_key);
|
|
printf(" %d", n_key2);
|
|
printf(" %d", n_key3);
|
|
printf(" %d", n_payload);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashCopy(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashCreate(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashCreateDict(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashDefaultDeallocator(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * entry; /* hash table entry */
|
|
int n_entry;
|
|
const xmlChar * key; /* the entry's string key */
|
|
int n_key;
|
|
|
|
for (n_entry = 0;n_entry < gen_nb_void_ptr;n_entry++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
mem_base = xmlMemBlocks();
|
|
entry = gen_void_ptr(n_entry, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
|
|
xmlHashDefaultDeallocator(entry, key);
|
|
call_tests++;
|
|
des_void_ptr(n_entry, entry, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashDefaultDeallocator",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_entry);
|
|
printf(" %d", n_key);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashLookup(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * key; /* string key */
|
|
int n_key;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
|
|
ret_val = xmlHashLookup(hash, key);
|
|
desret_void_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashLookup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_key);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashLookup2(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * key; /* first string key */
|
|
int n_key;
|
|
const xmlChar * key2; /* second string key */
|
|
int n_key2;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
for (n_key2 = 0;n_key2 < gen_nb_const_xmlChar_ptr;n_key2++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
key2 = gen_const_xmlChar_ptr(n_key2, 2);
|
|
|
|
ret_val = xmlHashLookup2(hash, key, key2);
|
|
desret_void_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
des_const_xmlChar_ptr(n_key2, key2, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashLookup2",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_key);
|
|
printf(" %d", n_key2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashLookup3(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * key; /* first string key */
|
|
int n_key;
|
|
const xmlChar * key2; /* second string key */
|
|
int n_key2;
|
|
const xmlChar * key3; /* third string key */
|
|
int n_key3;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
for (n_key2 = 0;n_key2 < gen_nb_const_xmlChar_ptr;n_key2++) {
|
|
for (n_key3 = 0;n_key3 < gen_nb_const_xmlChar_ptr;n_key3++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
key2 = gen_const_xmlChar_ptr(n_key2, 2);
|
|
key3 = gen_const_xmlChar_ptr(n_key3, 3);
|
|
|
|
ret_val = xmlHashLookup3(hash, key, key2, key3);
|
|
desret_void_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
des_const_xmlChar_ptr(n_key2, key2, 2);
|
|
des_const_xmlChar_ptr(n_key3, key3, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashLookup3",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_key);
|
|
printf(" %d", n_key2);
|
|
printf(" %d", n_key3);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashQLookup(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * prefix; /* prefix of the string key */
|
|
int n_prefix;
|
|
const xmlChar * name; /* local name of the string key */
|
|
int n_name;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
|
|
ret_val = xmlHashQLookup(hash, prefix, name);
|
|
desret_void_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashQLookup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashQLookup2(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * prefix; /* first prefix */
|
|
int n_prefix;
|
|
const xmlChar * name; /* first local name */
|
|
int n_name;
|
|
const xmlChar * prefix2; /* second prefix */
|
|
int n_prefix2;
|
|
const xmlChar * name2; /* second local name */
|
|
int n_name2;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) {
|
|
for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3);
|
|
name2 = gen_const_xmlChar_ptr(n_name2, 4);
|
|
|
|
ret_val = xmlHashQLookup2(hash, prefix, name, prefix2, name2);
|
|
desret_void_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_prefix2, prefix2, 3);
|
|
des_const_xmlChar_ptr(n_name2, name2, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashQLookup2",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_prefix2);
|
|
printf(" %d", n_name2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashQLookup3(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * prefix; /* first prefix */
|
|
int n_prefix;
|
|
const xmlChar * name; /* first local name */
|
|
int n_name;
|
|
const xmlChar * prefix2; /* second prefix */
|
|
int n_prefix2;
|
|
const xmlChar * name2; /* second local name */
|
|
int n_name2;
|
|
const xmlChar * prefix3; /* third prefix */
|
|
int n_prefix3;
|
|
const xmlChar * name3; /* third local name */
|
|
int n_name3;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) {
|
|
for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
|
|
for (n_prefix3 = 0;n_prefix3 < gen_nb_const_xmlChar_ptr;n_prefix3++) {
|
|
for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3);
|
|
name2 = gen_const_xmlChar_ptr(n_name2, 4);
|
|
prefix3 = gen_const_xmlChar_ptr(n_prefix3, 5);
|
|
name3 = gen_const_xmlChar_ptr(n_name3, 6);
|
|
|
|
ret_val = xmlHashQLookup3(hash, prefix, name, prefix2, name2, prefix3, name3);
|
|
desret_void_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_prefix2, prefix2, 3);
|
|
des_const_xmlChar_ptr(n_name2, name2, 4);
|
|
des_const_xmlChar_ptr(n_prefix3, prefix3, 5);
|
|
des_const_xmlChar_ptr(n_name3, name3, 6);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashQLookup3",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_prefix2);
|
|
printf(" %d", n_name2);
|
|
printf(" %d", n_prefix3);
|
|
printf(" %d", n_name3);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashRemoveEntry(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * key; /* string key */
|
|
int n_key;
|
|
xmlHashDeallocator dealloc; /* deallocator function for removed item or NULL */
|
|
int n_dealloc;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
for (n_dealloc = 0;n_dealloc < gen_nb_xmlHashDeallocator;n_dealloc++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
dealloc = gen_xmlHashDeallocator(n_dealloc, 2);
|
|
|
|
ret_val = xmlHashRemoveEntry(hash, key, dealloc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
des_xmlHashDeallocator(n_dealloc, dealloc, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashRemoveEntry",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_key);
|
|
printf(" %d", n_dealloc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashRemoveEntry2(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * key; /* first string key */
|
|
int n_key;
|
|
const xmlChar * key2; /* second string key */
|
|
int n_key2;
|
|
xmlHashDeallocator dealloc; /* deallocator function for removed item or NULL */
|
|
int n_dealloc;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
for (n_key2 = 0;n_key2 < gen_nb_const_xmlChar_ptr;n_key2++) {
|
|
for (n_dealloc = 0;n_dealloc < gen_nb_xmlHashDeallocator;n_dealloc++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
key2 = gen_const_xmlChar_ptr(n_key2, 2);
|
|
dealloc = gen_xmlHashDeallocator(n_dealloc, 3);
|
|
|
|
ret_val = xmlHashRemoveEntry2(hash, key, key2, dealloc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
des_const_xmlChar_ptr(n_key2, key2, 2);
|
|
des_xmlHashDeallocator(n_dealloc, dealloc, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashRemoveEntry2",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_key);
|
|
printf(" %d", n_key2);
|
|
printf(" %d", n_dealloc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashRemoveEntry3(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * key; /* first string key */
|
|
int n_key;
|
|
const xmlChar * key2; /* second string key */
|
|
int n_key2;
|
|
const xmlChar * key3; /* third string key */
|
|
int n_key3;
|
|
xmlHashDeallocator dealloc; /* deallocator function for removed item or NULL */
|
|
int n_dealloc;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
for (n_key2 = 0;n_key2 < gen_nb_const_xmlChar_ptr;n_key2++) {
|
|
for (n_key3 = 0;n_key3 < gen_nb_const_xmlChar_ptr;n_key3++) {
|
|
for (n_dealloc = 0;n_dealloc < gen_nb_xmlHashDeallocator;n_dealloc++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
key2 = gen_const_xmlChar_ptr(n_key2, 2);
|
|
key3 = gen_const_xmlChar_ptr(n_key3, 3);
|
|
dealloc = gen_xmlHashDeallocator(n_dealloc, 4);
|
|
|
|
ret_val = xmlHashRemoveEntry3(hash, key, key2, key3, dealloc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
des_const_xmlChar_ptr(n_key2, key2, 2);
|
|
des_const_xmlChar_ptr(n_key3, key3, 3);
|
|
des_xmlHashDeallocator(n_dealloc, dealloc, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashRemoveEntry3",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_key);
|
|
printf(" %d", n_key2);
|
|
printf(" %d", n_key3);
|
|
printf(" %d", n_dealloc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashScan(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashScan3(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashScanFull(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashScanFull3(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashSize(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
|
|
ret_val = xmlHashSize(hash);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashSize",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashUpdateEntry(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * key; /* string key */
|
|
int n_key;
|
|
void * payload; /* pointer to the payload */
|
|
int n_payload;
|
|
xmlHashDeallocator dealloc; /* deallocator function for replaced item or NULL */
|
|
int n_dealloc;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
for (n_payload = 0;n_payload < gen_nb_void_ptr;n_payload++) {
|
|
for (n_dealloc = 0;n_dealloc < gen_nb_xmlHashDeallocator;n_dealloc++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
payload = gen_void_ptr(n_payload, 2);
|
|
dealloc = gen_xmlHashDeallocator(n_dealloc, 3);
|
|
|
|
ret_val = xmlHashUpdateEntry(hash, key, payload, dealloc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
des_void_ptr(n_payload, payload, 2);
|
|
des_xmlHashDeallocator(n_dealloc, dealloc, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashUpdateEntry",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_key);
|
|
printf(" %d", n_payload);
|
|
printf(" %d", n_dealloc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashUpdateEntry2(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * key; /* first string key */
|
|
int n_key;
|
|
const xmlChar * key2; /* second string key */
|
|
int n_key2;
|
|
void * payload; /* pointer to the payload */
|
|
int n_payload;
|
|
xmlHashDeallocator dealloc; /* deallocator function for replaced item or NULL */
|
|
int n_dealloc;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
for (n_key2 = 0;n_key2 < gen_nb_const_xmlChar_ptr;n_key2++) {
|
|
for (n_payload = 0;n_payload < gen_nb_void_ptr;n_payload++) {
|
|
for (n_dealloc = 0;n_dealloc < gen_nb_xmlHashDeallocator;n_dealloc++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
key2 = gen_const_xmlChar_ptr(n_key2, 2);
|
|
payload = gen_void_ptr(n_payload, 3);
|
|
dealloc = gen_xmlHashDeallocator(n_dealloc, 4);
|
|
|
|
ret_val = xmlHashUpdateEntry2(hash, key, key2, payload, dealloc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
des_const_xmlChar_ptr(n_key2, key2, 2);
|
|
des_void_ptr(n_payload, payload, 3);
|
|
des_xmlHashDeallocator(n_dealloc, dealloc, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashUpdateEntry2",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_key);
|
|
printf(" %d", n_key2);
|
|
printf(" %d", n_payload);
|
|
printf(" %d", n_dealloc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHashUpdateEntry3(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlHashTablePtr hash; /* hash table */
|
|
int n_hash;
|
|
const xmlChar * key; /* first string key */
|
|
int n_key;
|
|
const xmlChar * key2; /* second string key */
|
|
int n_key2;
|
|
const xmlChar * key3; /* third string key */
|
|
int n_key3;
|
|
void * payload; /* pointer to the payload */
|
|
int n_payload;
|
|
xmlHashDeallocator dealloc; /* deallocator function for replaced item or NULL */
|
|
int n_dealloc;
|
|
|
|
for (n_hash = 0;n_hash < gen_nb_xmlHashTablePtr;n_hash++) {
|
|
for (n_key = 0;n_key < gen_nb_const_xmlChar_ptr;n_key++) {
|
|
for (n_key2 = 0;n_key2 < gen_nb_const_xmlChar_ptr;n_key2++) {
|
|
for (n_key3 = 0;n_key3 < gen_nb_const_xmlChar_ptr;n_key3++) {
|
|
for (n_payload = 0;n_payload < gen_nb_void_ptr;n_payload++) {
|
|
for (n_dealloc = 0;n_dealloc < gen_nb_xmlHashDeallocator;n_dealloc++) {
|
|
mem_base = xmlMemBlocks();
|
|
hash = gen_xmlHashTablePtr(n_hash, 0);
|
|
key = gen_const_xmlChar_ptr(n_key, 1);
|
|
key2 = gen_const_xmlChar_ptr(n_key2, 2);
|
|
key3 = gen_const_xmlChar_ptr(n_key3, 3);
|
|
payload = gen_void_ptr(n_payload, 4);
|
|
dealloc = gen_xmlHashDeallocator(n_dealloc, 5);
|
|
|
|
ret_val = xmlHashUpdateEntry3(hash, key, key2, key3, payload, dealloc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlHashTablePtr(n_hash, hash, 0);
|
|
des_const_xmlChar_ptr(n_key, key, 1);
|
|
des_const_xmlChar_ptr(n_key2, key2, 2);
|
|
des_const_xmlChar_ptr(n_key3, key3, 3);
|
|
des_void_ptr(n_payload, payload, 4);
|
|
des_xmlHashDeallocator(n_dealloc, dealloc, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHashUpdateEntry3",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_hash);
|
|
printf(" %d", n_key);
|
|
printf(" %d", n_key2);
|
|
printf(" %d", n_key3);
|
|
printf(" %d", n_payload);
|
|
printf(" %d", n_dealloc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_hash(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing hash : 17 of 25 functions ...\n");
|
|
test_ret += test_xmlHashAddEntry();
|
|
test_ret += test_xmlHashAddEntry2();
|
|
test_ret += test_xmlHashAddEntry3();
|
|
test_ret += test_xmlHashCopy();
|
|
test_ret += test_xmlHashCreate();
|
|
test_ret += test_xmlHashCreateDict();
|
|
test_ret += test_xmlHashDefaultDeallocator();
|
|
test_ret += test_xmlHashLookup();
|
|
test_ret += test_xmlHashLookup2();
|
|
test_ret += test_xmlHashLookup3();
|
|
test_ret += test_xmlHashQLookup();
|
|
test_ret += test_xmlHashQLookup2();
|
|
test_ret += test_xmlHashQLookup3();
|
|
test_ret += test_xmlHashRemoveEntry();
|
|
test_ret += test_xmlHashRemoveEntry2();
|
|
test_ret += test_xmlHashRemoveEntry3();
|
|
test_ret += test_xmlHashScan();
|
|
test_ret += test_xmlHashScan3();
|
|
test_ret += test_xmlHashScanFull();
|
|
test_ret += test_xmlHashScanFull3();
|
|
test_ret += test_xmlHashSize();
|
|
test_ret += test_xmlHashUpdateEntry();
|
|
test_ret += test_xmlHashUpdateEntry2();
|
|
test_ret += test_xmlHashUpdateEntry3();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module hash: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
#define gen_nb_xmlLinkPtr 1
|
|
#define gen_xmlLinkPtr(no, nr) NULL
|
|
#define des_xmlLinkPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlLinkGetData(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ret_val;
|
|
xmlLinkPtr lk; /* a link */
|
|
int n_lk;
|
|
|
|
for (n_lk = 0;n_lk < gen_nb_xmlLinkPtr;n_lk++) {
|
|
mem_base = xmlMemBlocks();
|
|
lk = gen_xmlLinkPtr(n_lk, 0);
|
|
|
|
ret_val = xmlLinkGetData(lk);
|
|
desret_void_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlLinkPtr(n_lk, lk, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlLinkGetData",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_lk);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListAppend(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
void * data; /* the data */
|
|
int n_data;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
data = gen_userdata(n_data, 1);
|
|
|
|
ret_val = xmlListAppend(l, data);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
des_userdata(n_data, data, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListAppend",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListClear(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
|
|
xmlListClear(l);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListClear",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListCopy(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlListPtr cur; /* the new list */
|
|
int n_cur;
|
|
xmlListPtr old; /* the old list */
|
|
int n_old;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlListPtr;n_cur++) {
|
|
for (n_old = 0;n_old < gen_nb_xmlListPtr;n_old++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlListPtr(n_cur, 0);
|
|
old = gen_xmlListPtr(n_old, 1);
|
|
|
|
ret_val = xmlListCopy(cur, old);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlListPtr(n_cur, cur, 0);
|
|
des_xmlListPtr(n_old, old, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListCopy",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_old);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListCreate(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListDup(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListEmpty(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
|
|
ret_val = xmlListEmpty(l);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListEmpty",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListEnd(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListFront(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListInsert(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
void * data; /* the data */
|
|
int n_data;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
data = gen_userdata(n_data, 1);
|
|
|
|
ret_val = xmlListInsert(l, data);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
des_userdata(n_data, data, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListInsert",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListMerge(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlListPtr l1; /* the original list */
|
|
int n_l1;
|
|
xmlListPtr l2; /* the new list */
|
|
int n_l2;
|
|
|
|
for (n_l1 = 0;n_l1 < gen_nb_xmlListPtr;n_l1++) {
|
|
for (n_l2 = 0;n_l2 < gen_nb_xmlListPtr;n_l2++) {
|
|
mem_base = xmlMemBlocks();
|
|
l1 = gen_xmlListPtr(n_l1, 0);
|
|
l2 = gen_xmlListPtr(n_l2, 1);
|
|
|
|
xmlListMerge(l1, l2);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l1, l1, 0);
|
|
des_xmlListPtr(n_l2, l2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListMerge",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l1);
|
|
printf(" %d", n_l2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListPopBack(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
|
|
xmlListPopBack(l);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListPopBack",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListPopFront(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
|
|
xmlListPopFront(l);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListPopFront",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListPushBack(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
void * data; /* new data */
|
|
int n_data;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
data = gen_userdata(n_data, 1);
|
|
|
|
ret_val = xmlListPushBack(l, data);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
des_userdata(n_data, data, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListPushBack",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListPushFront(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
void * data; /* new data */
|
|
int n_data;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
data = gen_userdata(n_data, 1);
|
|
|
|
ret_val = xmlListPushFront(l, data);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
des_userdata(n_data, data, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListPushFront",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListRemoveAll(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
void * data; /* list data */
|
|
int n_data;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
data = gen_userdata(n_data, 1);
|
|
|
|
ret_val = xmlListRemoveAll(l, data);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
des_userdata(n_data, data, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListRemoveAll",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListRemoveFirst(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
void * data; /* list data */
|
|
int n_data;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
data = gen_userdata(n_data, 1);
|
|
|
|
ret_val = xmlListRemoveFirst(l, data);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
des_userdata(n_data, data, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListRemoveFirst",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListRemoveLast(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
void * data; /* list data */
|
|
int n_data;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
data = gen_userdata(n_data, 1);
|
|
|
|
ret_val = xmlListRemoveLast(l, data);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
des_userdata(n_data, data, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListRemoveLast",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListReverse(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
|
|
xmlListReverse(l);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListReverse",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListReverseSearch(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ret_val;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
void * data; /* a search value */
|
|
int n_data;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
data = gen_userdata(n_data, 1);
|
|
|
|
ret_val = xmlListReverseSearch(l, data);
|
|
desret_void_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
des_userdata(n_data, data, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListReverseSearch",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListReverseWalk(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListSearch(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ret_val;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
void * data; /* a search value */
|
|
int n_data;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
data = gen_userdata(n_data, 1);
|
|
|
|
ret_val = xmlListSearch(l, data);
|
|
desret_void_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
des_userdata(n_data, data, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListSearch",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListSize(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
|
|
ret_val = xmlListSize(l);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListSize",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListSort(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlListPtr l; /* a list */
|
|
int n_l;
|
|
|
|
for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
|
|
mem_base = xmlMemBlocks();
|
|
l = gen_xmlListPtr(n_l, 0);
|
|
|
|
xmlListSort(l);
|
|
call_tests++;
|
|
des_xmlListPtr(n_l, l, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlListSort",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_l);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlListWalk(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_list(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing list : 19 of 26 functions ...\n");
|
|
test_ret += test_xmlLinkGetData();
|
|
test_ret += test_xmlListAppend();
|
|
test_ret += test_xmlListClear();
|
|
test_ret += test_xmlListCopy();
|
|
test_ret += test_xmlListCreate();
|
|
test_ret += test_xmlListDup();
|
|
test_ret += test_xmlListEmpty();
|
|
test_ret += test_xmlListEnd();
|
|
test_ret += test_xmlListFront();
|
|
test_ret += test_xmlListInsert();
|
|
test_ret += test_xmlListMerge();
|
|
test_ret += test_xmlListPopBack();
|
|
test_ret += test_xmlListPopFront();
|
|
test_ret += test_xmlListPushBack();
|
|
test_ret += test_xmlListPushFront();
|
|
test_ret += test_xmlListRemoveAll();
|
|
test_ret += test_xmlListRemoveFirst();
|
|
test_ret += test_xmlListRemoveLast();
|
|
test_ret += test_xmlListReverse();
|
|
test_ret += test_xmlListReverseSearch();
|
|
test_ret += test_xmlListReverseWalk();
|
|
test_ret += test_xmlListSearch();
|
|
test_ret += test_xmlListSize();
|
|
test_ret += test_xmlListSort();
|
|
test_ret += test_xmlListWalk();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module list: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlNanoHTTPAuthHeader(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
const char * ret_val;
|
|
void * ctx; /* the HTTP context */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
|
|
|
|
ret_val = xmlNanoHTTPAuthHeader(ctx);
|
|
desret_const_char_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNanoHTTPAuthHeader",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNanoHTTPCleanup(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlNanoHTTPCleanup();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNanoHTTPCleanup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNanoHTTPContentLength(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
void * ctx; /* the HTTP context */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
|
|
|
|
ret_val = xmlNanoHTTPContentLength(ctx);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNanoHTTPContentLength",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNanoHTTPEncoding(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
const char * ret_val;
|
|
void * ctx; /* the HTTP context */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
|
|
|
|
ret_val = xmlNanoHTTPEncoding(ctx);
|
|
desret_const_char_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNanoHTTPEncoding",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_char_ptr_ptr 1
|
|
#define gen_char_ptr_ptr(no, nr) NULL
|
|
#define des_char_ptr_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlNanoHTTPFetch(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * URL; /* The URL to load */
|
|
int n_URL;
|
|
const char * filename; /* the filename where the content should be saved */
|
|
int n_filename;
|
|
char ** contentType; /* if available the Content-Type information will be returned at that location */
|
|
int n_contentType;
|
|
|
|
for (n_URL = 0;n_URL < gen_nb_fileoutput;n_URL++) {
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
|
|
mem_base = xmlMemBlocks();
|
|
URL = gen_fileoutput(n_URL, 0);
|
|
filename = gen_fileoutput(n_filename, 1);
|
|
contentType = gen_char_ptr_ptr(n_contentType, 2);
|
|
|
|
ret_val = xmlNanoHTTPFetch(URL, filename, contentType);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_URL, URL, 0);
|
|
des_fileoutput(n_filename, filename, 1);
|
|
des_char_ptr_ptr(n_contentType, contentType, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNanoHTTPFetch",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_contentType);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNanoHTTPInit(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlNanoHTTPInit();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNanoHTTPInit",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNanoHTTPMimeType(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
const char * ret_val;
|
|
void * ctx; /* the HTTP context */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
|
|
|
|
ret_val = xmlNanoHTTPMimeType(ctx);
|
|
desret_const_char_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNanoHTTPMimeType",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNanoHTTPOpen(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
void * ret_val;
|
|
const char * URL; /* The URL to load */
|
|
int n_URL;
|
|
char ** contentType; /* if available the Content-Type information will be returned at that location */
|
|
int n_contentType;
|
|
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
|
|
mem_base = xmlMemBlocks();
|
|
URL = gen_filepath(n_URL, 0);
|
|
contentType = gen_char_ptr_ptr(n_contentType, 1);
|
|
|
|
ret_val = xmlNanoHTTPOpen(URL, contentType);
|
|
desret_xmlNanoHTTPCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_URL, URL, 0);
|
|
des_char_ptr_ptr(n_contentType, contentType, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNanoHTTPOpen",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_contentType);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNanoHTTPOpenRedir(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
void * ret_val;
|
|
const char * URL; /* The URL to load */
|
|
int n_URL;
|
|
char ** contentType; /* if available the Content-Type information will be returned at that location */
|
|
int n_contentType;
|
|
char ** redir; /* if available the redirected URL will be returned */
|
|
int n_redir;
|
|
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
|
|
for (n_redir = 0;n_redir < gen_nb_char_ptr_ptr;n_redir++) {
|
|
mem_base = xmlMemBlocks();
|
|
URL = gen_filepath(n_URL, 0);
|
|
contentType = gen_char_ptr_ptr(n_contentType, 1);
|
|
redir = gen_char_ptr_ptr(n_redir, 2);
|
|
|
|
ret_val = xmlNanoHTTPOpenRedir(URL, contentType, redir);
|
|
desret_xmlNanoHTTPCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_URL, URL, 0);
|
|
des_char_ptr_ptr(n_contentType, contentType, 1);
|
|
des_char_ptr_ptr(n_redir, redir, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNanoHTTPOpenRedir",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_contentType);
|
|
printf(" %d", n_redir);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNanoHTTPRead(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
void * ctx; /* the HTTP context */
|
|
int n_ctx;
|
|
void * dest; /* a buffer */
|
|
int n_dest;
|
|
int len; /* the buffer length */
|
|
int n_len;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
|
|
for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
|
|
dest = gen_void_ptr(n_dest, 1);
|
|
len = gen_int(n_len, 2);
|
|
|
|
ret_val = xmlNanoHTTPRead(ctx, dest, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
|
|
des_void_ptr(n_dest, dest, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNanoHTTPRead",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_dest);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNanoHTTPRedir(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNanoHTTPReturnCode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
void * ctx; /* the HTTP context */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
|
|
|
|
ret_val = xmlNanoHTTPReturnCode(ctx);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNanoHTTPReturnCode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNanoHTTPSave(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
void * ctxt; /* the HTTP context */
|
|
int n_ctxt;
|
|
const char * filename; /* the filename where the content should be saved */
|
|
int n_filename;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_void_ptr;n_ctxt++) {
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_void_ptr(n_ctxt, 0);
|
|
filename = gen_fileoutput(n_filename, 1);
|
|
|
|
ret_val = xmlNanoHTTPSave(ctxt, filename);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_ctxt, ctxt, 0);
|
|
des_fileoutput(n_filename, filename, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNanoHTTPSave",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNanoHTTPScanProxy(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
const char * URL; /* The proxy URL used to initialize the proxy context */
|
|
int n_URL;
|
|
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
URL = gen_filepath(n_URL, 0);
|
|
|
|
xmlNanoHTTPScanProxy(URL);
|
|
call_tests++;
|
|
des_filepath(n_URL, URL, 0);
|
|
xmlResetLastError();
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_nanohttp(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing nanohttp : 13 of 17 functions ...\n");
|
|
test_ret += test_xmlNanoHTTPAuthHeader();
|
|
test_ret += test_xmlNanoHTTPCleanup();
|
|
test_ret += test_xmlNanoHTTPContentLength();
|
|
test_ret += test_xmlNanoHTTPEncoding();
|
|
test_ret += test_xmlNanoHTTPFetch();
|
|
test_ret += test_xmlNanoHTTPInit();
|
|
test_ret += test_xmlNanoHTTPMimeType();
|
|
test_ret += test_xmlNanoHTTPOpen();
|
|
test_ret += test_xmlNanoHTTPOpenRedir();
|
|
test_ret += test_xmlNanoHTTPRead();
|
|
test_ret += test_xmlNanoHTTPRedir();
|
|
test_ret += test_xmlNanoHTTPReturnCode();
|
|
test_ret += test_xmlNanoHTTPSave();
|
|
test_ret += test_xmlNanoHTTPScanProxy();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module nanohttp: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlByteConsumed(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
long ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlByteConsumed(ctxt);
|
|
desret_long(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlByteConsumed",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlClearNodeInfoSeq(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
|
|
int n_seq;
|
|
|
|
for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
|
|
mem_base = xmlMemBlocks();
|
|
seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
|
|
|
|
xmlClearNodeInfoSeq(seq);
|
|
call_tests++;
|
|
des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlClearNodeInfoSeq",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_seq);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlClearParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
xmlClearParserCtxt(ctxt);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlClearParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCreateDocParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserCtxtPtr ret_val;
|
|
const xmlChar * str; /* a pointer to an array of xmlChar */
|
|
int n_str;
|
|
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
str = gen_const_xmlChar_ptr(n_str, 0);
|
|
|
|
ret_val = xmlCreateDocParserCtxt(str);
|
|
desret_xmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str, str, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCreateDocParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCreatePushParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_PUSH_ENABLED)
|
|
int mem_base;
|
|
xmlParserCtxtPtr ret_val;
|
|
xmlSAXHandlerPtr sax; /* a SAX handler */
|
|
int n_sax;
|
|
void * user_data; /* The user data returned on SAX callbacks */
|
|
int n_user_data;
|
|
const char * chunk; /* a pointer to an array of chars */
|
|
int n_chunk;
|
|
int size; /* number of chars in the array */
|
|
int n_size;
|
|
const char * filename; /* an optional file name or URI */
|
|
int n_filename;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
|
|
for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 0);
|
|
user_data = gen_userdata(n_user_data, 1);
|
|
chunk = gen_const_char_ptr(n_chunk, 2);
|
|
size = gen_int(n_size, 3);
|
|
filename = gen_fileoutput(n_filename, 4);
|
|
if ((chunk != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST chunk)))
|
|
size = 0;
|
|
|
|
ret_val = xmlCreatePushParserCtxt(sax, user_data, chunk, size, filename);
|
|
desret_xmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 0);
|
|
des_userdata(n_user_data, user_data, 1);
|
|
des_const_char_ptr(n_chunk, chunk, 2);
|
|
des_int(n_size, size, 3);
|
|
des_fileoutput(n_filename, filename, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCreatePushParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_user_data);
|
|
printf(" %d", n_chunk);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCtxtReadDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
const xmlChar * str; /* a pointer to a zero terminated string */
|
|
int n_str;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
str = gen_const_xmlChar_ptr(n_str, 1);
|
|
URL = gen_filepath(n_URL, 2);
|
|
encoding = gen_const_char_ptr(n_encoding, 3);
|
|
options = gen_parseroptions(n_options, 4);
|
|
|
|
ret_val = xmlCtxtReadDoc(ctxt, str, URL, encoding, options);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_str, str, 1);
|
|
des_filepath(n_URL, URL, 2);
|
|
des_const_char_ptr(n_encoding, encoding, 3);
|
|
des_parseroptions(n_options, options, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCtxtReadDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCtxtReadFile(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
const char * filename; /* a file or URL */
|
|
int n_filename;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
filename = gen_filepath(n_filename, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
options = gen_parseroptions(n_options, 3);
|
|
|
|
ret_val = xmlCtxtReadFile(ctxt, filename, encoding, options);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_filepath(n_filename, filename, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
des_parseroptions(n_options, options, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCtxtReadFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCtxtReadMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
const char * buffer; /* a pointer to a char array */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
buffer = gen_const_char_ptr(n_buffer, 1);
|
|
size = gen_int(n_size, 2);
|
|
URL = gen_filepath(n_URL, 3);
|
|
encoding = gen_const_char_ptr(n_encoding, 4);
|
|
options = gen_parseroptions(n_options, 5);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = xmlCtxtReadMemory(ctxt, buffer, size, URL, encoding, options);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_char_ptr(n_buffer, buffer, 1);
|
|
des_int(n_size, size, 2);
|
|
des_filepath(n_URL, URL, 3);
|
|
des_const_char_ptr(n_encoding, encoding, 4);
|
|
des_parseroptions(n_options, options, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCtxtReadMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCtxtReset(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
xmlCtxtReset(ctxt);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCtxtReset",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCtxtResetPush(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
const char * chunk; /* a pointer to an array of chars */
|
|
int n_chunk;
|
|
int size; /* number of chars in the array */
|
|
int n_size;
|
|
const char * filename; /* an optional file name or URI */
|
|
int n_filename;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
chunk = gen_const_char_ptr(n_chunk, 1);
|
|
size = gen_int(n_size, 2);
|
|
filename = gen_filepath(n_filename, 3);
|
|
encoding = gen_const_char_ptr(n_encoding, 4);
|
|
if ((chunk != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST chunk)))
|
|
size = 0;
|
|
|
|
ret_val = xmlCtxtResetPush(ctxt, chunk, size, filename, encoding);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_char_ptr(n_chunk, chunk, 1);
|
|
des_int(n_size, size, 2);
|
|
des_filepath(n_filename, filename, 3);
|
|
des_const_char_ptr(n_encoding, encoding, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCtxtResetPush",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_chunk);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_encoding);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCtxtSetMaxAmplification(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCtxtUseOptions(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
options = gen_parseroptions(n_options, 1);
|
|
|
|
ret_val = xmlCtxtUseOptions(ctxt, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_parseroptions(n_options, options, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCtxtUseOptions",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetExternalEntityLoader(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHasFeature(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlFeature feature; /* the feature to be examined */
|
|
int n_feature;
|
|
|
|
for (n_feature = 0;n_feature < gen_nb_xmlFeature;n_feature++) {
|
|
mem_base = xmlMemBlocks();
|
|
feature = gen_xmlFeature(n_feature, 0);
|
|
|
|
ret_val = xmlHasFeature(feature);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlFeature(n_feature, feature, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHasFeature",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_feature);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIOParseDTD(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
#ifdef LIBXML_VALID_ENABLED
|
|
xmlDtdPtr ret_val;
|
|
xmlSAXHandlerPtr sax; /* the SAX handler block or NULL */
|
|
int n_sax;
|
|
xmlParserInputBufferPtr input; /* an Input Buffer */
|
|
int n_input;
|
|
xmlCharEncoding enc; /* the charset encoding if known */
|
|
int n_enc;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
|
|
for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 0);
|
|
input = gen_xmlParserInputBufferPtr(n_input, 1);
|
|
enc = gen_xmlCharEncoding(n_enc, 2);
|
|
|
|
ret_val = xmlIOParseDTD(sax, input, enc);
|
|
input = NULL;
|
|
desret_xmlDtdPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 0);
|
|
des_xmlParserInputBufferPtr(n_input, input, 1);
|
|
des_xmlCharEncoding(n_enc, enc, 2);
|
|
xmlResetLastError();
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlInitNodeInfoSeq(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
|
|
int n_seq;
|
|
|
|
for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
|
|
mem_base = xmlMemBlocks();
|
|
seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
|
|
|
|
xmlInitNodeInfoSeq(seq);
|
|
call_tests++;
|
|
des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlInitNodeInfoSeq",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_seq);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlInitParser(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlInitParser();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlInitParser",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlInitParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlInitParserCtxt(ctxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlInitParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlKeepBlanksDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int val; /* int 0 or 1 */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_int;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_int(n_val, 0);
|
|
|
|
ret_val = xmlKeepBlanksDefault(val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlKeepBlanksDefault",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlLineNumbersDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int val; /* int 0 or 1 */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_int;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_int(n_val, 0);
|
|
|
|
ret_val = xmlLineNumbersDefault(val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlLineNumbersDefault",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlLoadExternalEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr ret_val;
|
|
const char * URL; /* the URL for the entity to load */
|
|
int n_URL;
|
|
const char * ID; /* the Public ID for the entity to load */
|
|
int n_ID;
|
|
xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */
|
|
int n_ctxt;
|
|
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) {
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
URL = gen_filepath(n_URL, 0);
|
|
ID = gen_const_char_ptr(n_ID, 1);
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2);
|
|
|
|
ret_val = xmlLoadExternalEntity(URL, ID, ctxt);
|
|
desret_xmlParserInputPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_URL, URL, 0);
|
|
des_const_char_ptr(n_ID, ID, 1);
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlLoadExternalEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_ID);
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewIOInputStream(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
xmlParserInputBufferPtr input; /* an I/O Input */
|
|
int n_input;
|
|
xmlCharEncoding enc; /* the charset encoding if known */
|
|
int n_enc;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
|
|
for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
input = gen_xmlParserInputBufferPtr(n_input, 1);
|
|
enc = gen_xmlCharEncoding(n_enc, 2);
|
|
|
|
ret_val = xmlNewIOInputStream(ctxt, input, enc);
|
|
if (ret_val != NULL) input = NULL;
|
|
desret_xmlParserInputPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlParserInputBufferPtr(n_input, input, 1);
|
|
des_xmlCharEncoding(n_enc, enc, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewIOInputStream",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_input);
|
|
printf(" %d", n_enc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserCtxtPtr ret_val;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
ret_val = xmlNewParserCtxt();
|
|
desret_xmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_const_xmlSAXHandler_ptr 1
|
|
#define gen_const_xmlSAXHandler_ptr(no, nr) NULL
|
|
#define des_const_xmlSAXHandler_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlNewSAXParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserCtxtPtr ret_val;
|
|
const xmlSAXHandler * sax; /* SAX handler */
|
|
int n_sax;
|
|
void * userData; /* user data */
|
|
int n_userData;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_const_xmlSAXHandler_ptr;n_sax++) {
|
|
for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_const_xmlSAXHandler_ptr(n_sax, 0);
|
|
userData = gen_userdata(n_userData, 1);
|
|
|
|
ret_val = xmlNewSAXParserCtxt(sax, userData);
|
|
desret_xmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlSAXHandler_ptr(n_sax, sax, 0);
|
|
des_userdata(n_userData, userData, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewSAXParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_userData);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlNodePtr_ptr 1
|
|
#define gen_xmlNodePtr_ptr(no, nr) NULL
|
|
#define des_xmlNodePtr_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlParseBalancedChunkMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* the document the chunk pertains to (must not be NULL) */
|
|
int n_doc;
|
|
xmlSAXHandlerPtr sax; /* the SAX handler block (possibly NULL) */
|
|
int n_sax;
|
|
void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
|
|
int n_user_data;
|
|
int depth; /* Used for loop detection, use 0 */
|
|
int n_depth;
|
|
const xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */
|
|
int n_string;
|
|
xmlNodePtr * lst; /* the return value for the set of parsed nodes */
|
|
int n_lst;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
|
|
for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
|
|
for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
|
|
for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 1);
|
|
user_data = gen_userdata(n_user_data, 2);
|
|
depth = gen_int(n_depth, 3);
|
|
string = gen_const_xmlChar_ptr(n_string, 4);
|
|
lst = gen_xmlNodePtr_ptr(n_lst, 5);
|
|
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
|
|
#endif
|
|
|
|
|
|
ret_val = xmlParseBalancedChunkMemory(doc, sax, user_data, depth, string, lst);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 1);
|
|
des_userdata(n_user_data, user_data, 2);
|
|
des_int(n_depth, depth, 3);
|
|
des_const_xmlChar_ptr(n_string, string, 4);
|
|
des_xmlNodePtr_ptr(n_lst, lst, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseBalancedChunkMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_user_data);
|
|
printf(" %d", n_depth);
|
|
printf(" %d", n_string);
|
|
printf(" %d", n_lst);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseBalancedChunkMemoryRecover(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* the document the chunk pertains to (must not be NULL) */
|
|
int n_doc;
|
|
xmlSAXHandlerPtr sax; /* the SAX handler block (possibly NULL) */
|
|
int n_sax;
|
|
void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
|
|
int n_user_data;
|
|
int depth; /* Used for loop detection, use 0 */
|
|
int n_depth;
|
|
const xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */
|
|
int n_string;
|
|
xmlNodePtr * lst; /* the return value for the set of parsed nodes */
|
|
int n_lst;
|
|
int recover; /* return nodes even if the data is broken (use 0) */
|
|
int n_recover;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
|
|
for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
|
|
for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
|
|
for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
|
|
for (n_recover = 0;n_recover < gen_nb_int;n_recover++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 1);
|
|
user_data = gen_userdata(n_user_data, 2);
|
|
depth = gen_int(n_depth, 3);
|
|
string = gen_const_xmlChar_ptr(n_string, 4);
|
|
lst = gen_xmlNodePtr_ptr(n_lst, 5);
|
|
recover = gen_int(n_recover, 6);
|
|
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
|
|
#endif
|
|
|
|
|
|
ret_val = xmlParseBalancedChunkMemoryRecover(doc, sax, user_data, depth, string, lst, recover);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 1);
|
|
des_userdata(n_user_data, user_data, 2);
|
|
des_int(n_depth, depth, 3);
|
|
des_const_xmlChar_ptr(n_string, string, 4);
|
|
des_xmlNodePtr_ptr(n_lst, lst, 5);
|
|
des_int(n_recover, recover, 6);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseBalancedChunkMemoryRecover",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_user_data);
|
|
printf(" %d", n_depth);
|
|
printf(" %d", n_string);
|
|
printf(" %d", n_lst);
|
|
printf(" %d", n_recover);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseChunk(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_PUSH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
const char * chunk; /* an char array */
|
|
int n_chunk;
|
|
int size; /* the size in byte of the chunk */
|
|
int n_size;
|
|
int terminate; /* last chunk indicator */
|
|
int n_terminate;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
chunk = gen_const_char_ptr(n_chunk, 1);
|
|
size = gen_int(n_size, 2);
|
|
terminate = gen_int(n_terminate, 3);
|
|
if ((chunk != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST chunk)))
|
|
size = 0;
|
|
|
|
ret_val = xmlParseChunk(ctxt, chunk, size, terminate);
|
|
if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_char_ptr(n_chunk, chunk, 1);
|
|
des_int(n_size, size, 2);
|
|
des_int(n_terminate, terminate, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseChunk",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_chunk);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_terminate);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseCtxtExternalEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctx; /* the existing parsing context */
|
|
int n_ctx;
|
|
const xmlChar * URL; /* the URL for the entity to load */
|
|
int n_URL;
|
|
const xmlChar * ID; /* the System ID for the entity to load */
|
|
int n_ID;
|
|
xmlNodePtr * lst; /* the return value for the set of parsed nodes */
|
|
int n_lst;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlParserCtxtPtr;n_ctx++) {
|
|
for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
|
|
for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
|
|
for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_xmlParserCtxtPtr(n_ctx, 0);
|
|
URL = gen_const_xmlChar_ptr(n_URL, 1);
|
|
ID = gen_const_xmlChar_ptr(n_ID, 2);
|
|
lst = gen_xmlNodePtr_ptr(n_lst, 3);
|
|
|
|
ret_val = xmlParseCtxtExternalEntity(ctx, URL, ID, lst);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctx, ctx, 0);
|
|
des_const_xmlChar_ptr(n_URL, URL, 1);
|
|
des_const_xmlChar_ptr(n_ID, ID, 2);
|
|
des_xmlNodePtr_ptr(n_lst, lst, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseCtxtExternalEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_ID);
|
|
printf(" %d", n_lst);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseDTD(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
#ifdef LIBXML_VALID_ENABLED
|
|
int mem_base;
|
|
xmlDtdPtr ret_val;
|
|
const xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */
|
|
int n_ExternalID;
|
|
const xmlChar * SystemID; /* a NAME* containing the URL to the DTD */
|
|
int n_SystemID;
|
|
|
|
for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
|
|
for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
|
|
mem_base = xmlMemBlocks();
|
|
ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 0);
|
|
SystemID = gen_const_xmlChar_ptr(n_SystemID, 1);
|
|
|
|
ret_val = xmlParseDTD(ExternalID, SystemID);
|
|
desret_xmlDtdPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_ExternalID, ExternalID, 0);
|
|
des_const_xmlChar_ptr(n_SystemID, SystemID, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseDTD",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ExternalID);
|
|
printf(" %d", n_SystemID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
const xmlChar * cur; /* a pointer to an array of xmlChar */
|
|
int n_cur;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_xmlChar_ptr(n_cur, 0);
|
|
|
|
ret_val = xmlParseDoc(cur);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_cur, cur, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseDocument(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlParseDocument(ctxt);
|
|
if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseDocument",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
|
|
ret_val = xmlParseEntity(filename);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseExtParsedEnt(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlParseExtParsedEnt(ctxt);
|
|
if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseExtParsedEnt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseExternalEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* the document the chunk pertains to */
|
|
int n_doc;
|
|
xmlSAXHandlerPtr sax; /* the SAX handler block (possibly NULL) */
|
|
int n_sax;
|
|
void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
|
|
int n_user_data;
|
|
int depth; /* Used for loop detection, use 0 */
|
|
int n_depth;
|
|
const xmlChar * URL; /* the URL for the entity to load */
|
|
int n_URL;
|
|
const xmlChar * ID; /* the System ID for the entity to load */
|
|
int n_ID;
|
|
xmlNodePtr * lst; /* the return value for the set of parsed nodes */
|
|
int n_lst;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
|
|
for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
|
|
for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
|
|
for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
|
|
for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 1);
|
|
user_data = gen_userdata(n_user_data, 2);
|
|
depth = gen_int(n_depth, 3);
|
|
URL = gen_const_xmlChar_ptr(n_URL, 4);
|
|
ID = gen_const_xmlChar_ptr(n_ID, 5);
|
|
lst = gen_xmlNodePtr_ptr(n_lst, 6);
|
|
|
|
ret_val = xmlParseExternalEntity(doc, sax, user_data, depth, URL, ID, lst);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 1);
|
|
des_userdata(n_user_data, user_data, 2);
|
|
des_int(n_depth, depth, 3);
|
|
des_const_xmlChar_ptr(n_URL, URL, 4);
|
|
des_const_xmlChar_ptr(n_ID, ID, 5);
|
|
des_xmlNodePtr_ptr(n_lst, lst, 6);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseExternalEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_user_data);
|
|
printf(" %d", n_depth);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_ID);
|
|
printf(" %d", n_lst);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
|
|
ret_val = xmlParseFile(filename);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseInNodeContext(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserErrors ret_val;
|
|
xmlNodePtr node; /* the context node */
|
|
int n_node;
|
|
const char * data; /* the input string */
|
|
int n_data;
|
|
int datalen; /* the input string length in bytes */
|
|
int n_datalen;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
xmlNodePtr * lst; /* the return value for the set of parsed nodes */
|
|
int n_lst;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
|
|
for (n_datalen = 0;n_datalen < gen_nb_int;n_datalen++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
data = gen_const_char_ptr(n_data, 1);
|
|
datalen = gen_int(n_datalen, 2);
|
|
options = gen_parseroptions(n_options, 3);
|
|
lst = gen_xmlNodePtr_ptr(n_lst, 4);
|
|
|
|
ret_val = xmlParseInNodeContext(node, data, datalen, options, lst);
|
|
desret_xmlParserErrors(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_const_char_ptr(n_data, data, 1);
|
|
des_int(n_datalen, datalen, 2);
|
|
des_parseroptions(n_options, options, 3);
|
|
des_xmlNodePtr_ptr(n_lst, lst, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseInNodeContext",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_data);
|
|
printf(" %d", n_datalen);
|
|
printf(" %d", n_options);
|
|
printf(" %d", n_lst);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
const char * buffer; /* an pointer to a char array */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
mem_base = xmlMemBlocks();
|
|
buffer = gen_const_char_ptr(n_buffer, 0);
|
|
size = gen_int(n_size, 1);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = xmlParseMemory(buffer, size);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_buffer, buffer, 0);
|
|
des_int(n_size, size, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlParserNodeInfoPtr 1
|
|
#define gen_xmlParserNodeInfoPtr(no, nr) NULL
|
|
#define des_xmlParserNodeInfoPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlParserAddNodeInfo(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
xmlParserNodeInfoPtr info; /* a node info sequence pointer */
|
|
int n_info;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_info = 0;n_info < gen_nb_xmlParserNodeInfoPtr;n_info++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
info = gen_xmlParserNodeInfoPtr(n_info, 1);
|
|
|
|
xmlParserAddNodeInfo(ctxt, info);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlParserNodeInfoPtr(n_info, info, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserAddNodeInfo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_info);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserFindNodeInfo(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlParserNodeInfo * ret_val;
|
|
xmlParserCtxtPtr ctx; /* an XML parser context */
|
|
int n_ctx;
|
|
xmlNodePtr node; /* an XML node within the tree */
|
|
int n_node;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlParserCtxtPtr;n_ctx++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_xmlParserCtxtPtr(n_ctx, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
|
|
ret_val = xmlParserFindNodeInfo(ctx, node);
|
|
desret_const_xmlParserNodeInfo_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctx, ctx, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserFindNodeInfo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserFindNodeInfoIndex(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
unsigned long ret_val;
|
|
xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
|
|
int n_seq;
|
|
xmlNodePtr node; /* an XML node pointer */
|
|
int n_node;
|
|
|
|
for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
|
|
ret_val = xmlParserFindNodeInfoIndex(seq, node);
|
|
desret_unsigned_long(ret_val);
|
|
call_tests++;
|
|
des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserFindNodeInfoIndex",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_seq);
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlParserInputPtr 1
|
|
#define gen_xmlParserInputPtr(no, nr) NULL
|
|
#define des_xmlParserInputPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlParserInputGrow(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserInputPtr in; /* an XML parser input */
|
|
int n_in;
|
|
int len; /* an indicative size for the lookahead */
|
|
int n_len;
|
|
|
|
for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
in = gen_xmlParserInputPtr(n_in, 0);
|
|
len = gen_int(n_len, 1);
|
|
|
|
ret_val = xmlParserInputGrow(in, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserInputPtr(n_in, in, 0);
|
|
des_int(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserInputGrow",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_in);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserInputRead(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserInputPtr in; /* an XML parser input */
|
|
int n_in;
|
|
int len; /* an indicative size for the lookahead */
|
|
int n_len;
|
|
|
|
for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
in = gen_xmlParserInputPtr(n_in, 0);
|
|
len = gen_int(n_len, 1);
|
|
|
|
ret_val = xmlParserInputRead(in, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserInputPtr(n_in, in, 0);
|
|
des_int(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserInputRead",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_in);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPedanticParserDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int val; /* int 0 or 1 */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_int;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_int(n_val, 0);
|
|
|
|
ret_val = xmlPedanticParserDefault(val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPedanticParserDefault",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReadDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
const xmlChar * cur; /* a pointer to a zero terminated string */
|
|
int n_cur;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_xmlChar_ptr(n_cur, 0);
|
|
URL = gen_filepath(n_URL, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
options = gen_parseroptions(n_options, 3);
|
|
|
|
ret_val = xmlReadDoc(cur, URL, encoding, options);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_cur, cur, 0);
|
|
des_filepath(n_URL, URL, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
des_parseroptions(n_options, options, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReadDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReadFile(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
const char * filename; /* a file or URL */
|
|
int n_filename;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
encoding = gen_const_char_ptr(n_encoding, 1);
|
|
options = gen_parseroptions(n_options, 2);
|
|
|
|
ret_val = xmlReadFile(filename, encoding, options);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
des_const_char_ptr(n_encoding, encoding, 1);
|
|
des_parseroptions(n_options, options, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReadFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReadMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
const char * buffer; /* a pointer to a char array */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
buffer = gen_const_char_ptr(n_buffer, 0);
|
|
size = gen_int(n_size, 1);
|
|
URL = gen_filepath(n_URL, 2);
|
|
encoding = gen_const_char_ptr(n_encoding, 3);
|
|
options = gen_parseroptions(n_options, 4);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = xmlReadMemory(buffer, size, URL, encoding, options);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_buffer, buffer, 0);
|
|
des_int(n_size, size, 1);
|
|
des_filepath(n_URL, URL, 2);
|
|
des_const_char_ptr(n_encoding, encoding, 3);
|
|
des_parseroptions(n_options, options, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReadMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRecoverDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
const xmlChar * cur; /* a pointer to an array of xmlChar */
|
|
int n_cur;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_xmlChar_ptr(n_cur, 0);
|
|
|
|
ret_val = xmlRecoverDoc(cur);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_cur, cur, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRecoverDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRecoverFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
|
|
ret_val = xmlRecoverFile(filename);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRecoverFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRecoverMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
const char * buffer; /* an pointer to a char array */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
mem_base = xmlMemBlocks();
|
|
buffer = gen_const_char_ptr(n_buffer, 0);
|
|
size = gen_int(n_size, 1);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = xmlRecoverMemory(buffer, size);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_buffer, buffer, 0);
|
|
des_int(n_size, size, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRecoverMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAXParseDTD(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDtdPtr ret_val;
|
|
xmlSAXHandlerPtr sax; /* the SAX handler block */
|
|
int n_sax;
|
|
const xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */
|
|
int n_ExternalID;
|
|
const xmlChar * SystemID; /* a NAME* containing the URL to the DTD */
|
|
int n_SystemID;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
|
|
for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 0);
|
|
ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
|
|
SystemID = gen_const_xmlChar_ptr(n_SystemID, 2);
|
|
|
|
ret_val = xmlSAXParseDTD(sax, ExternalID, SystemID);
|
|
desret_xmlDtdPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 0);
|
|
des_const_xmlChar_ptr(n_ExternalID, ExternalID, 1);
|
|
des_const_xmlChar_ptr(n_SystemID, SystemID, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAXParseDTD",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_ExternalID);
|
|
printf(" %d", n_SystemID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAXParseDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
xmlSAXHandlerPtr sax; /* the SAX handler block */
|
|
int n_sax;
|
|
const xmlChar * cur; /* a pointer to an array of xmlChar */
|
|
int n_cur;
|
|
int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
|
|
int n_recovery;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
|
|
for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 0);
|
|
cur = gen_const_xmlChar_ptr(n_cur, 1);
|
|
recovery = gen_int(n_recovery, 2);
|
|
|
|
ret_val = xmlSAXParseDoc(sax, cur, recovery);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 0);
|
|
des_const_xmlChar_ptr(n_cur, cur, 1);
|
|
des_int(n_recovery, recovery, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAXParseDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_recovery);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAXParseEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
xmlSAXHandlerPtr sax; /* the SAX handler block */
|
|
int n_sax;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 0);
|
|
filename = gen_filepath(n_filename, 1);
|
|
|
|
ret_val = xmlSAXParseEntity(sax, filename);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 0);
|
|
des_filepath(n_filename, filename, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAXParseEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAXParseFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
xmlSAXHandlerPtr sax; /* the SAX handler block */
|
|
int n_sax;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
|
|
int n_recovery;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 0);
|
|
filename = gen_filepath(n_filename, 1);
|
|
recovery = gen_int(n_recovery, 2);
|
|
|
|
ret_val = xmlSAXParseFile(sax, filename, recovery);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 0);
|
|
des_filepath(n_filename, filename, 1);
|
|
des_int(n_recovery, recovery, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAXParseFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_recovery);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAXParseFileWithData(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
xmlSAXHandlerPtr sax; /* the SAX handler block */
|
|
int n_sax;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
|
|
int n_recovery;
|
|
void * data; /* the userdata */
|
|
int n_data;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 0);
|
|
filename = gen_filepath(n_filename, 1);
|
|
recovery = gen_int(n_recovery, 2);
|
|
data = gen_userdata(n_data, 3);
|
|
|
|
ret_val = xmlSAXParseFileWithData(sax, filename, recovery, data);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 0);
|
|
des_filepath(n_filename, filename, 1);
|
|
des_int(n_recovery, recovery, 2);
|
|
des_userdata(n_data, data, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAXParseFileWithData",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_recovery);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAXParseMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
xmlSAXHandlerPtr sax; /* the SAX handler block */
|
|
int n_sax;
|
|
const char * buffer; /* an pointer to a char array */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
int recovery; /* work in recovery mode, i.e. tries to read not Well Formed documents */
|
|
int n_recovery;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 0);
|
|
buffer = gen_const_char_ptr(n_buffer, 1);
|
|
size = gen_int(n_size, 2);
|
|
recovery = gen_int(n_recovery, 3);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = xmlSAXParseMemory(sax, buffer, size, recovery);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 0);
|
|
des_const_char_ptr(n_buffer, buffer, 1);
|
|
des_int(n_size, size, 2);
|
|
des_int(n_recovery, recovery, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAXParseMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_recovery);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAXParseMemoryWithData(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
xmlSAXHandlerPtr sax; /* the SAX handler block */
|
|
int n_sax;
|
|
const char * buffer; /* an pointer to a char array */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
|
|
int n_recovery;
|
|
void * data; /* the userdata */
|
|
int n_data;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 0);
|
|
buffer = gen_const_char_ptr(n_buffer, 1);
|
|
size = gen_int(n_size, 2);
|
|
recovery = gen_int(n_recovery, 3);
|
|
data = gen_userdata(n_data, 4);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = xmlSAXParseMemoryWithData(sax, buffer, size, recovery, data);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 0);
|
|
des_const_char_ptr(n_buffer, buffer, 1);
|
|
des_int(n_size, size, 2);
|
|
des_int(n_recovery, recovery, 3);
|
|
des_userdata(n_data, data, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAXParseMemoryWithData",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_recovery);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAXUserParseFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSAXHandlerPtr sax; /* a SAX handler */
|
|
int n_sax;
|
|
void * user_data; /* The user data returned on SAX callbacks */
|
|
int n_user_data;
|
|
const char * filename; /* a file name */
|
|
int n_filename;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 0);
|
|
user_data = gen_userdata(n_user_data, 1);
|
|
filename = gen_filepath(n_filename, 2);
|
|
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
|
|
#endif
|
|
|
|
|
|
ret_val = xmlSAXUserParseFile(sax, user_data, filename);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 0);
|
|
des_userdata(n_user_data, user_data, 1);
|
|
des_filepath(n_filename, filename, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAXUserParseFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_user_data);
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSAXUserParseMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSAXHandlerPtr sax; /* a SAX handler */
|
|
int n_sax;
|
|
void * user_data; /* The user data returned on SAX callbacks */
|
|
int n_user_data;
|
|
const char * buffer; /* an in-memory XML document input */
|
|
int n_buffer;
|
|
int size; /* the length of the XML document in bytes */
|
|
int n_size;
|
|
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
mem_base = xmlMemBlocks();
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 0);
|
|
user_data = gen_userdata(n_user_data, 1);
|
|
buffer = gen_const_char_ptr(n_buffer, 2);
|
|
size = gen_int(n_size, 3);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
|
|
#endif
|
|
|
|
|
|
ret_val = xmlSAXUserParseMemory(sax, user_data, buffer, size);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 0);
|
|
des_userdata(n_user_data, user_data, 1);
|
|
des_const_char_ptr(n_buffer, buffer, 2);
|
|
des_int(n_size, size, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSAXUserParseMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_user_data);
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSetExternalEntityLoader(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSetupParserForBuffer(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SAX1_ENABLED)
|
|
#ifdef LIBXML_SAX1_ENABLED
|
|
int mem_base;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
const xmlChar * buffer; /* a xmlChar * buffer */
|
|
int n_buffer;
|
|
const char * filename; /* a file name */
|
|
int n_filename;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) {
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
buffer = gen_const_xmlChar_ptr(n_buffer, 1);
|
|
filename = gen_filepath(n_filename, 2);
|
|
|
|
xmlSetupParserForBuffer(ctxt, buffer, filename);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_buffer, buffer, 1);
|
|
des_filepath(n_filename, filename, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSetupParserForBuffer",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStopParser(void) {
|
|
int test_ret = 0;
|
|
|
|
#ifdef LIBXML_PUSH_ENABLED
|
|
int mem_base;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
xmlStopParser(ctxt);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStopParser",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSubstituteEntitiesDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int val; /* int 0 or 1 */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_int;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_int(n_val, 0);
|
|
|
|
ret_val = xmlSubstituteEntitiesDefault(val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSubstituteEntitiesDefault",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefDoValidityCheckingDefaultValue(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_int;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_int(n_v, 0);
|
|
|
|
ret_val = xmlThrDefDoValidityCheckingDefaultValue(v);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefDoValidityCheckingDefaultValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefGetWarningsDefaultValue(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_int;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_int(n_v, 0);
|
|
|
|
ret_val = xmlThrDefGetWarningsDefaultValue(v);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefGetWarningsDefaultValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefKeepBlanksDefaultValue(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_int;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_int(n_v, 0);
|
|
|
|
ret_val = xmlThrDefKeepBlanksDefaultValue(v);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefKeepBlanksDefaultValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefLineNumbersDefaultValue(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_int;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_int(n_v, 0);
|
|
|
|
ret_val = xmlThrDefLineNumbersDefaultValue(v);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefLineNumbersDefaultValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefLoadExtDtdDefaultValue(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_int;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_int(n_v, 0);
|
|
|
|
ret_val = xmlThrDefLoadExtDtdDefaultValue(v);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefLoadExtDtdDefaultValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefParserDebugEntities(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_int;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_int(n_v, 0);
|
|
|
|
ret_val = xmlThrDefParserDebugEntities(v);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefParserDebugEntities",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefPedanticParserDefaultValue(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_int;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_int(n_v, 0);
|
|
|
|
ret_val = xmlThrDefPedanticParserDefaultValue(v);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefPedanticParserDefaultValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefSubstituteEntitiesDefaultValue(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_int;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_int(n_v, 0);
|
|
|
|
ret_val = xmlThrDefSubstituteEntitiesDefaultValue(v);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefSubstituteEntitiesDefaultValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_parser(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing parser : 67 of 80 functions ...\n");
|
|
test_ret += test_xmlByteConsumed();
|
|
test_ret += test_xmlClearNodeInfoSeq();
|
|
test_ret += test_xmlClearParserCtxt();
|
|
test_ret += test_xmlCreateDocParserCtxt();
|
|
test_ret += test_xmlCreatePushParserCtxt();
|
|
test_ret += test_xmlCtxtReadDoc();
|
|
test_ret += test_xmlCtxtReadFile();
|
|
test_ret += test_xmlCtxtReadMemory();
|
|
test_ret += test_xmlCtxtReset();
|
|
test_ret += test_xmlCtxtResetPush();
|
|
test_ret += test_xmlCtxtSetMaxAmplification();
|
|
test_ret += test_xmlCtxtUseOptions();
|
|
test_ret += test_xmlGetExternalEntityLoader();
|
|
test_ret += test_xmlHasFeature();
|
|
test_ret += test_xmlIOParseDTD();
|
|
test_ret += test_xmlInitNodeInfoSeq();
|
|
test_ret += test_xmlInitParser();
|
|
test_ret += test_xmlInitParserCtxt();
|
|
test_ret += test_xmlKeepBlanksDefault();
|
|
test_ret += test_xmlLineNumbersDefault();
|
|
test_ret += test_xmlLoadExternalEntity();
|
|
test_ret += test_xmlNewIOInputStream();
|
|
test_ret += test_xmlNewParserCtxt();
|
|
test_ret += test_xmlNewSAXParserCtxt();
|
|
test_ret += test_xmlParseBalancedChunkMemory();
|
|
test_ret += test_xmlParseBalancedChunkMemoryRecover();
|
|
test_ret += test_xmlParseChunk();
|
|
test_ret += test_xmlParseCtxtExternalEntity();
|
|
test_ret += test_xmlParseDTD();
|
|
test_ret += test_xmlParseDoc();
|
|
test_ret += test_xmlParseDocument();
|
|
test_ret += test_xmlParseEntity();
|
|
test_ret += test_xmlParseExtParsedEnt();
|
|
test_ret += test_xmlParseExternalEntity();
|
|
test_ret += test_xmlParseFile();
|
|
test_ret += test_xmlParseInNodeContext();
|
|
test_ret += test_xmlParseMemory();
|
|
test_ret += test_xmlParserAddNodeInfo();
|
|
test_ret += test_xmlParserFindNodeInfo();
|
|
test_ret += test_xmlParserFindNodeInfoIndex();
|
|
test_ret += test_xmlParserInputGrow();
|
|
test_ret += test_xmlParserInputRead();
|
|
test_ret += test_xmlPedanticParserDefault();
|
|
test_ret += test_xmlReadDoc();
|
|
test_ret += test_xmlReadFile();
|
|
test_ret += test_xmlReadMemory();
|
|
test_ret += test_xmlRecoverDoc();
|
|
test_ret += test_xmlRecoverFile();
|
|
test_ret += test_xmlRecoverMemory();
|
|
test_ret += test_xmlSAXParseDTD();
|
|
test_ret += test_xmlSAXParseDoc();
|
|
test_ret += test_xmlSAXParseEntity();
|
|
test_ret += test_xmlSAXParseFile();
|
|
test_ret += test_xmlSAXParseFileWithData();
|
|
test_ret += test_xmlSAXParseMemory();
|
|
test_ret += test_xmlSAXParseMemoryWithData();
|
|
test_ret += test_xmlSAXUserParseFile();
|
|
test_ret += test_xmlSAXUserParseMemory();
|
|
test_ret += test_xmlSetExternalEntityLoader();
|
|
test_ret += test_xmlSetupParserForBuffer();
|
|
test_ret += test_xmlStopParser();
|
|
test_ret += test_xmlSubstituteEntitiesDefault();
|
|
test_ret += test_xmlThrDefDoValidityCheckingDefaultValue();
|
|
test_ret += test_xmlThrDefGetWarningsDefaultValue();
|
|
test_ret += test_xmlThrDefKeepBlanksDefaultValue();
|
|
test_ret += test_xmlThrDefLineNumbersDefaultValue();
|
|
test_ret += test_xmlThrDefLoadExtDtdDefaultValue();
|
|
test_ret += test_xmlThrDefParserDebugEntities();
|
|
test_ret += test_xmlThrDefPedanticParserDefaultValue();
|
|
test_ret += test_xmlThrDefSubstituteEntitiesDefaultValue();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module parser: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_inputPop(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = inputPop(ctxt);
|
|
desret_xmlParserInputPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in inputPop",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_inputPush(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
xmlParserInputPtr value; /* the parser input */
|
|
int n_value;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_value = 0;n_value < gen_nb_xmlParserInputPtr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
value = gen_xmlParserInputPtr(n_value, 1);
|
|
|
|
ret_val = inputPush(ctxt, value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlParserInputPtr(n_value, value, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in inputPush",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_namePop(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = namePop(ctxt);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in namePop",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_namePush(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
const xmlChar * value; /* the element name */
|
|
int n_value;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
|
|
ret_val = namePush(ctxt, value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in namePush",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_nodePop(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = nodePop(ctxt);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in nodePop",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_nodePush(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr value; /* the element node */
|
|
int n_value;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_value = 0;n_value < gen_nb_xmlNodePtr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
value = gen_xmlNodePtr(n_value, 1);
|
|
|
|
ret_val = nodePush(ctxt, value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_value, value, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in nodePush",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCheckLanguageID(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * lang; /* pointer to the string value */
|
|
int n_lang;
|
|
|
|
for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) {
|
|
mem_base = xmlMemBlocks();
|
|
lang = gen_const_xmlChar_ptr(n_lang, 0);
|
|
|
|
ret_val = xmlCheckLanguageID(lang);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_lang, lang, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCheckLanguageID",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_lang);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyChar(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int len; /* Ignored, compatibility */
|
|
int n_len;
|
|
xmlChar * out; /* pointer to an array of xmlChar */
|
|
int n_out;
|
|
int val; /* the char value */
|
|
int n_val;
|
|
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) {
|
|
for (n_val = 0;n_val < gen_nb_int;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
len = gen_int(n_len, 0);
|
|
out = gen_xmlChar_ptr(n_out, 1);
|
|
val = gen_int(n_val, 2);
|
|
|
|
ret_val = xmlCopyChar(len, out, val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_len, len, 0);
|
|
des_xmlChar_ptr(n_out, out, 1);
|
|
des_int(n_val, val, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyChar",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_len);
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyCharMultiByte(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlChar * out; /* pointer to an array of xmlChar */
|
|
int n_out;
|
|
int val; /* the char value */
|
|
int n_val;
|
|
|
|
for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) {
|
|
for (n_val = 0;n_val < gen_nb_int;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_xmlChar_ptr(n_out, 0);
|
|
val = gen_int(n_val, 1);
|
|
|
|
ret_val = xmlCopyCharMultiByte(out, val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlChar_ptr(n_out, out, 0);
|
|
des_int(n_val, val, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyCharMultiByte",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCreateEntityParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserCtxtPtr ret_val;
|
|
const xmlChar * URL; /* the entity URL */
|
|
int n_URL;
|
|
const xmlChar * ID; /* the entity PUBLIC ID */
|
|
int n_ID;
|
|
const xmlChar * base; /* a possible base for the target URI */
|
|
int n_base;
|
|
|
|
for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
|
|
for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
|
|
for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
|
|
mem_base = xmlMemBlocks();
|
|
URL = gen_const_xmlChar_ptr(n_URL, 0);
|
|
ID = gen_const_xmlChar_ptr(n_ID, 1);
|
|
base = gen_const_xmlChar_ptr(n_base, 2);
|
|
|
|
ret_val = xmlCreateEntityParserCtxt(URL, ID, base);
|
|
desret_xmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_URL, URL, 0);
|
|
des_const_xmlChar_ptr(n_ID, ID, 1);
|
|
des_const_xmlChar_ptr(n_base, base, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCreateEntityParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_ID);
|
|
printf(" %d", n_base);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCreateFileParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserCtxtPtr ret_val;
|
|
const char * filename; /* the filename */
|
|
int n_filename;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_fileoutput(n_filename, 0);
|
|
|
|
ret_val = xmlCreateFileParserCtxt(filename);
|
|
desret_xmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_filename, filename, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCreateFileParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCreateMemoryParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserCtxtPtr ret_val;
|
|
const char * buffer; /* a pointer to a char array */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
mem_base = xmlMemBlocks();
|
|
buffer = gen_const_char_ptr(n_buffer, 0);
|
|
size = gen_int(n_size, 1);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = xmlCreateMemoryParserCtxt(buffer, size);
|
|
desret_xmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_buffer, buffer, 0);
|
|
des_int(n_size, size, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCreateMemoryParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCreateURLParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserCtxtPtr ret_val;
|
|
const char * filename; /* the filename or URL */
|
|
int n_filename;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_fileoutput(n_filename, 0);
|
|
options = gen_int(n_options, 1);
|
|
|
|
ret_val = xmlCreateURLParserCtxt(filename, options);
|
|
desret_xmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_filename, filename, 0);
|
|
des_int(n_options, options, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCreateURLParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCurrentChar(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* the XML parser context */
|
|
int n_ctxt;
|
|
int * len; /* pointer to the length of the char read */
|
|
int n_len;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
len = gen_int_ptr(n_len, 1);
|
|
|
|
ret_val = xmlCurrentChar(ctxt, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_int_ptr(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCurrentChar",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsLetter(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int c; /* an unicode character (int) */
|
|
int n_c;
|
|
|
|
for (n_c = 0;n_c < gen_nb_int;n_c++) {
|
|
mem_base = xmlMemBlocks();
|
|
c = gen_int(n_c, 0);
|
|
|
|
ret_val = xmlIsLetter(c);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_c, c, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsLetter",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_c);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewEntityInputStream(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
xmlEntityPtr entity; /* an Entity pointer */
|
|
int n_entity;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_entity = 0;n_entity < gen_nb_xmlEntityPtr;n_entity++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
entity = gen_xmlEntityPtr(n_entity, 1);
|
|
|
|
ret_val = xmlNewEntityInputStream(ctxt, entity);
|
|
desret_xmlParserInputPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlEntityPtr(n_entity, entity, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewEntityInputStream",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_entity);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewInputFromFile(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
const char * filename; /* the filename to use as entity */
|
|
int n_filename;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
filename = gen_filepath(n_filename, 1);
|
|
|
|
ret_val = xmlNewInputFromFile(ctxt, filename);
|
|
desret_xmlParserInputPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_filepath(n_filename, filename, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewInputFromFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewInputStream(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlNewInputStream(ctxt);
|
|
desret_xmlParserInputPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewInputStream",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewStringInputStream(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
const xmlChar * buffer; /* an memory buffer */
|
|
int n_buffer;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
buffer = gen_const_xmlChar_ptr(n_buffer, 1);
|
|
|
|
ret_val = xmlNewStringInputStream(ctxt, buffer);
|
|
desret_xmlParserInputPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_buffer, buffer, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewStringInputStream",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_buffer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNextChar(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserCtxtPtr ctxt; /* the XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
xmlNextChar(ctxt);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNextChar",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserInputShrink(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr in; /* an XML parser input */
|
|
int n_in;
|
|
|
|
for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
|
|
mem_base = xmlMemBlocks();
|
|
in = gen_xmlParserInputPtr(n_in, 0);
|
|
|
|
xmlParserInputShrink(in);
|
|
call_tests++;
|
|
des_xmlParserInputPtr(n_in, in, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserInputShrink",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_in);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPopInput(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlPopInput(ctxt);
|
|
desret_xmlChar(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPopInput",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPushInput(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
xmlParserInputPtr input; /* an XML parser input fragment (entity, XML fragment ...). */
|
|
int n_input;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
input = gen_xmlParserInputPtr(n_input, 1);
|
|
|
|
ret_val = xmlPushInput(ctxt, input);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlParserInputPtr(n_input, input, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPushInput",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_input);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSetEntityReferenceFunc(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSplitQName(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
const xmlChar * name; /* an XML parser context */
|
|
int n_name;
|
|
xmlChar ** prefix; /* a xmlChar ** */
|
|
int n_prefix;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
prefix = gen_xmlChar_ptr_ptr(n_prefix, 2);
|
|
|
|
ret_val = xmlSplitQName(ctxt, name, prefix);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_xmlChar_ptr_ptr(n_prefix, prefix, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSplitQName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_prefix);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStringCurrentChar(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* the XML parser context */
|
|
int n_ctxt;
|
|
const xmlChar * cur; /* pointer to the beginning of the char */
|
|
int n_cur;
|
|
int * len; /* pointer to the length of the char read */
|
|
int n_len;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
|
|
for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
cur = gen_const_xmlChar_ptr(n_cur, 1);
|
|
len = gen_int_ptr(n_len, 2);
|
|
|
|
ret_val = xmlStringCurrentChar(ctxt, cur, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_cur, cur, 1);
|
|
des_int_ptr(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStringCurrentChar",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStringDecodeEntities(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlParserCtxtPtr ctxt; /* the parser context */
|
|
int n_ctxt;
|
|
const xmlChar * str; /* the input string */
|
|
int n_str;
|
|
int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */
|
|
int n_what;
|
|
xmlChar end; /* an end marker xmlChar, 0 if none */
|
|
int n_end;
|
|
xmlChar end2; /* an end marker xmlChar, 0 if none */
|
|
int n_end2;
|
|
xmlChar end3; /* an end marker xmlChar, 0 if none */
|
|
int n_end3;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_what = 0;n_what < gen_nb_int;n_what++) {
|
|
for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) {
|
|
for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) {
|
|
for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
str = gen_const_xmlChar_ptr(n_str, 1);
|
|
what = gen_int(n_what, 2);
|
|
end = gen_xmlChar(n_end, 3);
|
|
end2 = gen_xmlChar(n_end2, 4);
|
|
end3 = gen_xmlChar(n_end3, 5);
|
|
|
|
ret_val = xmlStringDecodeEntities(ctxt, str, what, end, end2, end3);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_str, str, 1);
|
|
des_int(n_what, what, 2);
|
|
des_xmlChar(n_end, end, 3);
|
|
des_xmlChar(n_end2, end2, 4);
|
|
des_xmlChar(n_end3, end3, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStringDecodeEntities",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_what);
|
|
printf(" %d", n_end);
|
|
printf(" %d", n_end2);
|
|
printf(" %d", n_end3);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStringLenDecodeEntities(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlParserCtxtPtr ctxt; /* the parser context */
|
|
int n_ctxt;
|
|
const xmlChar * str; /* the input string */
|
|
int n_str;
|
|
int len; /* the string length */
|
|
int n_len;
|
|
int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */
|
|
int n_what;
|
|
xmlChar end; /* an end marker xmlChar, 0 if none */
|
|
int n_end;
|
|
xmlChar end2; /* an end marker xmlChar, 0 if none */
|
|
int n_end2;
|
|
xmlChar end3; /* an end marker xmlChar, 0 if none */
|
|
int n_end3;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
for (n_what = 0;n_what < gen_nb_int;n_what++) {
|
|
for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) {
|
|
for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) {
|
|
for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
str = gen_const_xmlChar_ptr(n_str, 1);
|
|
len = gen_int(n_len, 2);
|
|
what = gen_int(n_what, 3);
|
|
end = gen_xmlChar(n_end, 4);
|
|
end2 = gen_xmlChar(n_end2, 5);
|
|
end3 = gen_xmlChar(n_end3, 6);
|
|
if ((str != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST str)))
|
|
len = 0;
|
|
|
|
ret_val = xmlStringLenDecodeEntities(ctxt, str, len, what, end, end2, end3);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_str, str, 1);
|
|
des_int(n_len, len, 2);
|
|
des_int(n_what, what, 3);
|
|
des_xmlChar(n_end, end, 4);
|
|
des_xmlChar(n_end2, end2, 5);
|
|
des_xmlChar(n_end3, end3, 6);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStringLenDecodeEntities",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_len);
|
|
printf(" %d", n_what);
|
|
printf(" %d", n_end);
|
|
printf(" %d", n_end2);
|
|
printf(" %d", n_end3);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSwitchEncoding(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* the parser context */
|
|
int n_ctxt;
|
|
xmlCharEncoding enc; /* the encoding value (number) */
|
|
int n_enc;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
enc = gen_xmlCharEncoding(n_enc, 1);
|
|
|
|
ret_val = xmlSwitchEncoding(ctxt, enc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlCharEncoding(n_enc, enc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSwitchEncoding",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_enc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSwitchInputEncoding(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* the parser context */
|
|
int n_ctxt;
|
|
xmlParserInputPtr input; /* the input stream */
|
|
int n_input;
|
|
xmlCharEncodingHandlerPtr handler; /* the encoding handler */
|
|
int n_handler;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
|
|
for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
input = gen_xmlParserInputPtr(n_input, 1);
|
|
handler = gen_xmlCharEncodingHandlerPtr(n_handler, 2);
|
|
|
|
ret_val = xmlSwitchInputEncoding(ctxt, input, handler);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlParserInputPtr(n_input, input, 1);
|
|
des_xmlCharEncodingHandlerPtr(n_handler, handler, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSwitchInputEncoding",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_input);
|
|
printf(" %d", n_handler);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSwitchToEncoding(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserCtxtPtr ctxt; /* the parser context */
|
|
int n_ctxt;
|
|
xmlCharEncodingHandlerPtr handler; /* the encoding handler */
|
|
int n_handler;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
handler = gen_xmlCharEncodingHandlerPtr(n_handler, 1);
|
|
|
|
ret_val = xmlSwitchToEncoding(ctxt, handler);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlCharEncodingHandlerPtr(n_handler, handler, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSwitchToEncoding",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_handler);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_parserInternals(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing parserInternals : 30 of 87 functions ...\n");
|
|
test_ret += test_inputPop();
|
|
test_ret += test_inputPush();
|
|
test_ret += test_namePop();
|
|
test_ret += test_namePush();
|
|
test_ret += test_nodePop();
|
|
test_ret += test_nodePush();
|
|
test_ret += test_xmlCheckLanguageID();
|
|
test_ret += test_xmlCopyChar();
|
|
test_ret += test_xmlCopyCharMultiByte();
|
|
test_ret += test_xmlCreateEntityParserCtxt();
|
|
test_ret += test_xmlCreateFileParserCtxt();
|
|
test_ret += test_xmlCreateMemoryParserCtxt();
|
|
test_ret += test_xmlCreateURLParserCtxt();
|
|
test_ret += test_xmlCurrentChar();
|
|
test_ret += test_xmlIsLetter();
|
|
test_ret += test_xmlNewEntityInputStream();
|
|
test_ret += test_xmlNewInputFromFile();
|
|
test_ret += test_xmlNewInputStream();
|
|
test_ret += test_xmlNewStringInputStream();
|
|
test_ret += test_xmlNextChar();
|
|
test_ret += test_xmlParserInputShrink();
|
|
test_ret += test_xmlPopInput();
|
|
test_ret += test_xmlPushInput();
|
|
test_ret += test_xmlSetEntityReferenceFunc();
|
|
test_ret += test_xmlSplitQName();
|
|
test_ret += test_xmlStringCurrentChar();
|
|
test_ret += test_xmlStringDecodeEntities();
|
|
test_ret += test_xmlStringLenDecodeEntities();
|
|
test_ret += test_xmlSwitchEncoding();
|
|
test_ret += test_xmlSwitchInputEncoding();
|
|
test_ret += test_xmlSwitchToEncoding();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module parserInternals: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlPatternFromRoot(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_PATTERN_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlPatternPtr comp; /* the precompiled pattern */
|
|
int n_comp;
|
|
|
|
for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
|
|
mem_base = xmlMemBlocks();
|
|
comp = gen_xmlPatternPtr(n_comp, 0);
|
|
|
|
ret_val = xmlPatternFromRoot(comp);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlPatternPtr(n_comp, comp, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPatternFromRoot",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_comp);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPatternGetStreamCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPatternMatch(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_PATTERN_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlPatternPtr comp; /* the precompiled pattern */
|
|
int n_comp;
|
|
xmlNodePtr node; /* a node */
|
|
int n_node;
|
|
|
|
for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
comp = gen_xmlPatternPtr(n_comp, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
|
|
ret_val = xmlPatternMatch(comp, node);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlPatternPtr(n_comp, comp, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPatternMatch",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_comp);
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPatternMaxDepth(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_PATTERN_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlPatternPtr comp; /* the precompiled pattern */
|
|
int n_comp;
|
|
|
|
for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
|
|
mem_base = xmlMemBlocks();
|
|
comp = gen_xmlPatternPtr(n_comp, 0);
|
|
|
|
ret_val = xmlPatternMaxDepth(comp);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlPatternPtr(n_comp, comp, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPatternMaxDepth",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_comp);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPatternMinDepth(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_PATTERN_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlPatternPtr comp; /* the precompiled pattern */
|
|
int n_comp;
|
|
|
|
for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
|
|
mem_base = xmlMemBlocks();
|
|
comp = gen_xmlPatternPtr(n_comp, 0);
|
|
|
|
ret_val = xmlPatternMinDepth(comp);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlPatternPtr(n_comp, comp, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPatternMinDepth",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_comp);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPatternStreamable(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_PATTERN_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlPatternPtr comp; /* the precompiled pattern */
|
|
int n_comp;
|
|
|
|
for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
|
|
mem_base = xmlMemBlocks();
|
|
comp = gen_xmlPatternPtr(n_comp, 0);
|
|
|
|
ret_val = xmlPatternStreamable(comp);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlPatternPtr(n_comp, comp, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPatternStreamable",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_comp);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPatterncompile(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_PATTERN_ENABLED
|
|
|
|
#define gen_nb_xmlStreamCtxtPtr 1
|
|
#define gen_xmlStreamCtxtPtr(no, nr) NULL
|
|
#define des_xmlStreamCtxtPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlStreamPop(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_PATTERN_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlStreamCtxtPtr stream; /* the stream context */
|
|
int n_stream;
|
|
|
|
for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
|
|
mem_base = xmlMemBlocks();
|
|
stream = gen_xmlStreamCtxtPtr(n_stream, 0);
|
|
|
|
ret_val = xmlStreamPop(stream);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlStreamCtxtPtr(n_stream, stream, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStreamPop",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_stream);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStreamPush(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_PATTERN_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlStreamCtxtPtr stream; /* the stream context */
|
|
int n_stream;
|
|
const xmlChar * name; /* the current name */
|
|
int n_name;
|
|
const xmlChar * ns; /* the namespace name */
|
|
int n_ns;
|
|
|
|
for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
|
|
mem_base = xmlMemBlocks();
|
|
stream = gen_xmlStreamCtxtPtr(n_stream, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
ns = gen_const_xmlChar_ptr(n_ns, 2);
|
|
|
|
ret_val = xmlStreamPush(stream, name, ns);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlStreamCtxtPtr(n_stream, stream, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_ns, ns, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStreamPush",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_stream);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_ns);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStreamPushAttr(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_PATTERN_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlStreamCtxtPtr stream; /* the stream context */
|
|
int n_stream;
|
|
const xmlChar * name; /* the current name */
|
|
int n_name;
|
|
const xmlChar * ns; /* the namespace name */
|
|
int n_ns;
|
|
|
|
for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
|
|
mem_base = xmlMemBlocks();
|
|
stream = gen_xmlStreamCtxtPtr(n_stream, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
ns = gen_const_xmlChar_ptr(n_ns, 2);
|
|
|
|
ret_val = xmlStreamPushAttr(stream, name, ns);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlStreamCtxtPtr(n_stream, stream, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_ns, ns, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStreamPushAttr",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_stream);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_ns);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStreamPushNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_PATTERN_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlStreamCtxtPtr stream; /* the stream context */
|
|
int n_stream;
|
|
const xmlChar * name; /* the current name */
|
|
int n_name;
|
|
const xmlChar * ns; /* the namespace name */
|
|
int n_ns;
|
|
int nodeType; /* the type of the node being pushed */
|
|
int n_nodeType;
|
|
|
|
for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
|
|
for (n_nodeType = 0;n_nodeType < gen_nb_int;n_nodeType++) {
|
|
mem_base = xmlMemBlocks();
|
|
stream = gen_xmlStreamCtxtPtr(n_stream, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
ns = gen_const_xmlChar_ptr(n_ns, 2);
|
|
nodeType = gen_int(n_nodeType, 3);
|
|
|
|
ret_val = xmlStreamPushNode(stream, name, ns, nodeType);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlStreamCtxtPtr(n_stream, stream, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_ns, ns, 2);
|
|
des_int(n_nodeType, nodeType, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStreamPushNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_stream);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_nodeType);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStreamWantsAnyNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_PATTERN_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlStreamCtxtPtr streamCtxt; /* the stream context */
|
|
int n_streamCtxt;
|
|
|
|
for (n_streamCtxt = 0;n_streamCtxt < gen_nb_xmlStreamCtxtPtr;n_streamCtxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
streamCtxt = gen_xmlStreamCtxtPtr(n_streamCtxt, 0);
|
|
|
|
ret_val = xmlStreamWantsAnyNode(streamCtxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlStreamCtxtPtr(n_streamCtxt, streamCtxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStreamWantsAnyNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_streamCtxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_pattern(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing pattern : 10 of 15 functions ...\n");
|
|
test_ret += test_xmlPatternFromRoot();
|
|
test_ret += test_xmlPatternGetStreamCtxt();
|
|
test_ret += test_xmlPatternMatch();
|
|
test_ret += test_xmlPatternMaxDepth();
|
|
test_ret += test_xmlPatternMinDepth();
|
|
test_ret += test_xmlPatternStreamable();
|
|
test_ret += test_xmlPatterncompile();
|
|
test_ret += test_xmlStreamPop();
|
|
test_ret += test_xmlStreamPush();
|
|
test_ret += test_xmlStreamPushAttr();
|
|
test_ret += test_xmlStreamPushNode();
|
|
test_ret += test_xmlStreamWantsAnyNode();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module pattern: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlRelaxNGPtr 1
|
|
#define gen_xmlRelaxNGPtr(no, nr) NULL
|
|
#define des_xmlRelaxNGPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGDump(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the file output */
|
|
int n_output;
|
|
xmlRelaxNGPtr schema; /* a schema structure */
|
|
int n_schema;
|
|
|
|
for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
|
|
for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_FILE_ptr(n_output, 0);
|
|
schema = gen_xmlRelaxNGPtr(n_schema, 1);
|
|
|
|
xmlRelaxNGDump(output, schema);
|
|
call_tests++;
|
|
des_FILE_ptr(n_output, output, 0);
|
|
des_xmlRelaxNGPtr(n_schema, schema, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGDump",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_schema);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGDumpTree(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the file output */
|
|
int n_output;
|
|
xmlRelaxNGPtr schema; /* a schema structure */
|
|
int n_schema;
|
|
|
|
for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
|
|
for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_FILE_ptr(n_output, 0);
|
|
schema = gen_xmlRelaxNGPtr(n_schema, 1);
|
|
|
|
xmlRelaxNGDumpTree(output, schema);
|
|
call_tests++;
|
|
des_FILE_ptr(n_output, output, 0);
|
|
des_xmlRelaxNGPtr(n_schema, schema, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGDumpTree",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_schema);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlRelaxNGParserCtxtPtr 1
|
|
#define gen_xmlRelaxNGParserCtxtPtr(no, nr) NULL
|
|
#define des_xmlRelaxNGParserCtxtPtr(no, val, nr)
|
|
#endif
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlRelaxNGValidityErrorFunc_ptr 1
|
|
#define gen_xmlRelaxNGValidityErrorFunc_ptr(no, nr) NULL
|
|
#define des_xmlRelaxNGValidityErrorFunc_ptr(no, val, nr)
|
|
#endif
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlRelaxNGValidityWarningFunc_ptr 1
|
|
#define gen_xmlRelaxNGValidityWarningFunc_ptr(no, nr) NULL
|
|
#define des_xmlRelaxNGValidityWarningFunc_ptr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGGetParserErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRelaxNGParserCtxtPtr ctxt; /* a Relax-NG validation context */
|
|
int n_ctxt;
|
|
xmlRelaxNGValidityErrorFunc * err; /* the error callback result */
|
|
int n_err;
|
|
xmlRelaxNGValidityWarningFunc * warn; /* the warning callback result */
|
|
int n_warn;
|
|
void ** ctx; /* contextual data for the callbacks result */
|
|
int n_ctx;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) {
|
|
for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) {
|
|
for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) {
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0);
|
|
err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1);
|
|
warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2);
|
|
ctx = gen_void_ptr_ptr(n_ctx, 3);
|
|
|
|
ret_val = xmlRelaxNGGetParserErrors(ctxt, err, warn, ctx);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1);
|
|
des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2);
|
|
des_void_ptr_ptr(n_ctx, ctx, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGGetParserErrors",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_err);
|
|
printf(" %d", n_warn);
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlRelaxNGValidCtxtPtr 1
|
|
#define gen_xmlRelaxNGValidCtxtPtr(no, nr) NULL
|
|
#define des_xmlRelaxNGValidCtxtPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGGetValidErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */
|
|
int n_ctxt;
|
|
xmlRelaxNGValidityErrorFunc * err; /* the error function result */
|
|
int n_err;
|
|
xmlRelaxNGValidityWarningFunc * warn; /* the warning function result */
|
|
int n_warn;
|
|
void ** ctx; /* the functions context result */
|
|
int n_ctx;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
|
|
for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) {
|
|
for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) {
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
|
|
err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1);
|
|
warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2);
|
|
ctx = gen_void_ptr_ptr(n_ctx, 3);
|
|
|
|
ret_val = xmlRelaxNGGetValidErrors(ctxt, err, warn, ctx);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1);
|
|
des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2);
|
|
des_void_ptr_ptr(n_ctx, ctx, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGGetValidErrors",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_err);
|
|
printf(" %d", n_warn);
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGInitTypes(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
ret_val = xmlRelaxNGInitTypes();
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGInitTypes",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGNewDocParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlRelaxNGParserCtxtPtr ret_val;
|
|
xmlDocPtr doc; /* a preparsed document tree */
|
|
int n_doc;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
|
|
ret_val = xmlRelaxNGNewDocParserCtxt(doc);
|
|
desret_xmlRelaxNGParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGNewDocParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGNewMemParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlRelaxNGParserCtxtPtr ret_val;
|
|
const char * buffer; /* a pointer to a char array containing the schemas */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
mem_base = xmlMemBlocks();
|
|
buffer = gen_const_char_ptr(n_buffer, 0);
|
|
size = gen_int(n_size, 1);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = xmlRelaxNGNewMemParserCtxt(buffer, size);
|
|
desret_xmlRelaxNGParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_buffer, buffer, 0);
|
|
des_int(n_size, size, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGNewMemParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGNewParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlRelaxNGParserCtxtPtr ret_val;
|
|
const char * URL; /* the location of the schema */
|
|
int n_URL;
|
|
|
|
for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) {
|
|
mem_base = xmlMemBlocks();
|
|
URL = gen_const_char_ptr(n_URL, 0);
|
|
|
|
ret_val = xmlRelaxNGNewParserCtxt(URL);
|
|
desret_xmlRelaxNGParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_URL, URL, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGNewParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URL);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGNewValidCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGParse(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGSetParserErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGSetParserStructuredErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGSetValidErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGSetValidStructuredErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGValidateDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a parsed document tree */
|
|
int n_doc;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
|
|
ret_val = xmlRelaxNGValidateDoc(ctxt, doc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGValidateDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGValidateFullElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlNodePtr elem; /* an element instance */
|
|
int n_elem;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
elem = gen_xmlNodePtr(n_elem, 2);
|
|
|
|
ret_val = xmlRelaxNGValidateFullElement(ctxt, doc, elem);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_elem, elem, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGValidateFullElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGValidatePopElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlNodePtr elem; /* an element instance */
|
|
int n_elem;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
elem = gen_xmlNodePtr(n_elem, 2);
|
|
|
|
ret_val = xmlRelaxNGValidatePopElement(ctxt, doc, elem);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_elem, elem, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGValidatePopElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGValidatePushCData(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */
|
|
int n_ctxt;
|
|
const xmlChar * data; /* some character data read */
|
|
int n_data;
|
|
int len; /* the length of the data */
|
|
int n_len;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
|
|
for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
|
|
data = gen_const_xmlChar_ptr(n_data, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((data != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST data)))
|
|
len = 0;
|
|
|
|
ret_val = xmlRelaxNGValidatePushCData(ctxt, data, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_data, data, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGValidatePushCData",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_data);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxNGValidatePushElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlNodePtr elem; /* an element instance */
|
|
int n_elem;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
elem = gen_xmlNodePtr(n_elem, 2);
|
|
|
|
ret_val = xmlRelaxNGValidatePushElement(ctxt, doc, elem);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_elem, elem, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxNGValidatePushElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRelaxParserSetFlag(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRelaxNGParserCtxtPtr ctxt; /* a RelaxNG parser context */
|
|
int n_ctxt;
|
|
int flags; /* a set of flags values */
|
|
int n_flags;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) {
|
|
for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0);
|
|
flags = gen_int(n_flags, 1);
|
|
|
|
ret_val = xmlRelaxParserSetFlag(ctxt, flags);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_flags, flags, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRelaxParserSetFlag",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_flags);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_relaxng(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing relaxng : 14 of 24 functions ...\n");
|
|
test_ret += test_xmlRelaxNGDump();
|
|
test_ret += test_xmlRelaxNGDumpTree();
|
|
test_ret += test_xmlRelaxNGGetParserErrors();
|
|
test_ret += test_xmlRelaxNGGetValidErrors();
|
|
test_ret += test_xmlRelaxNGInitTypes();
|
|
test_ret += test_xmlRelaxNGNewDocParserCtxt();
|
|
test_ret += test_xmlRelaxNGNewMemParserCtxt();
|
|
test_ret += test_xmlRelaxNGNewParserCtxt();
|
|
test_ret += test_xmlRelaxNGNewValidCtxt();
|
|
test_ret += test_xmlRelaxNGParse();
|
|
test_ret += test_xmlRelaxNGSetParserErrors();
|
|
test_ret += test_xmlRelaxNGSetParserStructuredErrors();
|
|
test_ret += test_xmlRelaxNGSetValidErrors();
|
|
test_ret += test_xmlRelaxNGSetValidStructuredErrors();
|
|
test_ret += test_xmlRelaxNGValidateDoc();
|
|
test_ret += test_xmlRelaxNGValidateFullElement();
|
|
test_ret += test_xmlRelaxNGValidatePopElement();
|
|
test_ret += test_xmlRelaxNGValidatePushCData();
|
|
test_ret += test_xmlRelaxNGValidatePushElement();
|
|
test_ret += test_xmlRelaxParserSetFlag();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module relaxng: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
static int
|
|
test_schemasInternals(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing schemasInternals : 0 of 2 functions ...\n");
|
|
|
|
if (test_ret != 0)
|
|
printf("Module schemasInternals: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlSchematronNewDocParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchematronNewMemParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchematronNewParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchematronNewValidCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchematronParse(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchematronSetValidStructuredErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_SCHEMATRON_ENABLED
|
|
|
|
#define gen_nb_xmlSchematronValidCtxtPtr 1
|
|
#define gen_xmlSchematronValidCtxtPtr(no, nr) NULL
|
|
#define des_xmlSchematronValidCtxtPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlSchematronValidateDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMATRON_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchematronValidCtxtPtr ctxt; /* the schema validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr instance; /* the document instance tree */
|
|
int n_instance;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchematronValidCtxtPtr;n_ctxt++) {
|
|
for (n_instance = 0;n_instance < gen_nb_xmlDocPtr;n_instance++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSchematronValidCtxtPtr(n_ctxt, 0);
|
|
instance = gen_xmlDocPtr(n_instance, 1);
|
|
|
|
ret_val = xmlSchematronValidateDoc(ctxt, instance);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchematronValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_instance, instance, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchematronValidateDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_instance);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_schematron(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing schematron : 1 of 10 functions ...\n");
|
|
test_ret += test_xmlSchematronNewDocParserCtxt();
|
|
test_ret += test_xmlSchematronNewMemParserCtxt();
|
|
test_ret += test_xmlSchematronNewParserCtxt();
|
|
test_ret += test_xmlSchematronNewValidCtxt();
|
|
test_ret += test_xmlSchematronParse();
|
|
test_ret += test_xmlSchematronSetValidStructuredErrors();
|
|
test_ret += test_xmlSchematronValidateDoc();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module schematron: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlAddChild(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr parent; /* the parent node */
|
|
int n_parent;
|
|
xmlNodePtr cur; /* the child node */
|
|
int n_cur;
|
|
|
|
for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
parent = gen_xmlNodePtr(n_parent, 0);
|
|
cur = gen_xmlNodePtr_in(n_cur, 1);
|
|
|
|
ret_val = xmlAddChild(parent, cur);
|
|
if (ret_val == NULL) { xmlFreeNode(cur) ; cur = NULL ; }
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_parent, parent, 0);
|
|
des_xmlNodePtr_in(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAddChild",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_parent);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAddChildList(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr parent; /* the parent node */
|
|
int n_parent;
|
|
xmlNodePtr cur; /* the first node in the list */
|
|
int n_cur;
|
|
|
|
for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
parent = gen_xmlNodePtr(n_parent, 0);
|
|
cur = gen_xmlNodePtr_in(n_cur, 1);
|
|
|
|
ret_val = xmlAddChildList(parent, cur);
|
|
if (ret_val == NULL) { xmlFreeNodeList(cur) ; cur = NULL ; }
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_parent, parent, 0);
|
|
des_xmlNodePtr_in(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAddChildList",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_parent);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAddNextSibling(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr cur; /* the child node */
|
|
int n_cur;
|
|
xmlNodePtr elem; /* the new node */
|
|
int n_elem;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodePtr(n_cur, 0);
|
|
elem = gen_xmlNodePtr_in(n_elem, 1);
|
|
|
|
ret_val = xmlAddNextSibling(cur, elem);
|
|
if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_cur, cur, 0);
|
|
des_xmlNodePtr_in(n_elem, elem, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAddNextSibling",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAddPrevSibling(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr cur; /* the child node */
|
|
int n_cur;
|
|
xmlNodePtr elem; /* the new node */
|
|
int n_elem;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodePtr(n_cur, 0);
|
|
elem = gen_xmlNodePtr_in(n_elem, 1);
|
|
|
|
ret_val = xmlAddPrevSibling(cur, elem);
|
|
if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_cur, cur, 0);
|
|
des_xmlNodePtr_in(n_elem, elem, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAddPrevSibling",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAddSibling(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr cur; /* the child node */
|
|
int n_cur;
|
|
xmlNodePtr elem; /* the new node */
|
|
int n_elem;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodePtr(n_cur, 0);
|
|
elem = gen_xmlNodePtr_in(n_elem, 1);
|
|
|
|
ret_val = xmlAddSibling(cur, elem);
|
|
if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_cur, cur, 0);
|
|
des_xmlNodePtr_in(n_elem, elem, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAddSibling",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAttrSerializeTxtContent(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
#ifdef LIBXML_OUTPUT_ENABLED
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* the XML buffer output */
|
|
int n_buf;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlAttrPtr attr; /* the attribute node */
|
|
int n_attr;
|
|
const xmlChar * string; /* the text content */
|
|
int n_string;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
|
|
for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
attr = gen_xmlAttrPtr(n_attr, 2);
|
|
string = gen_const_xmlChar_ptr(n_string, 3);
|
|
|
|
xmlAttrSerializeTxtContent(buf, doc, attr, string);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlAttrPtr(n_attr, attr, 2);
|
|
des_const_xmlChar_ptr(n_string, string, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAttrSerializeTxtContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_attr);
|
|
printf(" %d", n_string);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_const_xmlBuf_ptr 1
|
|
#define gen_const_xmlBuf_ptr(no, nr) NULL
|
|
#define des_const_xmlBuf_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlBufContent(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlBuf * buf; /* the buffer */
|
|
int n_buf;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_const_xmlBuf_ptr;n_buf++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_const_xmlBuf_ptr(n_buf, 0);
|
|
|
|
ret_val = xmlBufContent(buf);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlBuf_ptr(n_buf, buf, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlBufPtr 1
|
|
#define gen_xmlBufPtr(no, nr) NULL
|
|
#define des_xmlBufPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlBufEnd(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlBufPtr buf; /* the buffer */
|
|
int n_buf;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufPtr;n_buf++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufPtr(n_buf, 0);
|
|
|
|
ret_val = xmlBufEnd(buf);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlBufPtr(n_buf, buf, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufEnd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_const_xmlNode_ptr 1
|
|
#define gen_const_xmlNode_ptr(no, nr) NULL
|
|
#define des_const_xmlNode_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlBufGetNodeContent(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlBufPtr buf; /* a buffer xmlBufPtr */
|
|
int n_buf;
|
|
const xmlNode * cur; /* the node being read */
|
|
int n_cur;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufPtr;n_buf++) {
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlNode_ptr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufPtr(n_buf, 0);
|
|
cur = gen_const_xmlNode_ptr(n_cur, 1);
|
|
|
|
ret_val = xmlBufGetNodeContent(buf, cur);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlBufPtr(n_buf, buf, 0);
|
|
des_const_xmlNode_ptr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufGetNodeContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufNodeDump(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufShrink(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufUse(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferAdd(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlBufferPtr buf; /* the buffer to dump */
|
|
int n_buf;
|
|
const xmlChar * str; /* the #xmlChar string */
|
|
int n_str;
|
|
int len; /* the number of #xmlChar to add */
|
|
int n_len;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
str = gen_const_xmlChar_ptr(n_str, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((str != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST str)))
|
|
len = 0;
|
|
|
|
ret_val = xmlBufferAdd(buf, str, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_const_xmlChar_ptr(n_str, str, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferAdd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferAddHead(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlBufferPtr buf; /* the buffer */
|
|
int n_buf;
|
|
const xmlChar * str; /* the #xmlChar string */
|
|
int n_str;
|
|
int len; /* the number of #xmlChar to add */
|
|
int n_len;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
str = gen_const_xmlChar_ptr(n_str, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((str != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST str)))
|
|
len = 0;
|
|
|
|
ret_val = xmlBufferAddHead(buf, str, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_const_xmlChar_ptr(n_str, str, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferAddHead",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferCCat(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlBufferPtr buf; /* the buffer to dump */
|
|
int n_buf;
|
|
const char * str; /* the C char string */
|
|
int n_str;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
str = gen_const_char_ptr(n_str, 1);
|
|
|
|
ret_val = xmlBufferCCat(buf, str);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_const_char_ptr(n_str, str, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferCCat",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferCat(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlBufferPtr buf; /* the buffer to add to */
|
|
int n_buf;
|
|
const xmlChar * str; /* the #xmlChar string */
|
|
int n_str;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
str = gen_const_xmlChar_ptr(n_str, 1);
|
|
|
|
ret_val = xmlBufferCat(buf, str);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_const_xmlChar_ptr(n_str, str, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferCat",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_const_xmlBuffer_ptr 1
|
|
#define gen_const_xmlBuffer_ptr(no, nr) NULL
|
|
#define des_const_xmlBuffer_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlBufferContent(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
const xmlBuffer * buf; /* the buffer */
|
|
int n_buf;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_const_xmlBuffer_ptr;n_buf++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_const_xmlBuffer_ptr(n_buf, 0);
|
|
|
|
ret_val = xmlBufferContent(buf);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlBuffer_ptr(n_buf, buf, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferCreate(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlBufferPtr ret_val;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
ret_val = xmlBufferCreate();
|
|
desret_xmlBufferPtr(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferCreate",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferCreateSize(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferCreateStatic(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferDetach(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlBufferPtr buf; /* the buffer */
|
|
int n_buf;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
|
|
ret_val = xmlBufferDetach(buf);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferDetach",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferEmpty(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* the buffer */
|
|
int n_buf;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
|
|
xmlBufferEmpty(buf);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferEmpty",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferGrow(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlBufferPtr buf; /* the buffer */
|
|
int n_buf;
|
|
unsigned int len; /* the minimum free size to allocate */
|
|
int n_len;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
len = gen_unsigned_int(n_len, 1);
|
|
|
|
ret_val = xmlBufferGrow(buf, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_unsigned_int(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferGrow",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferLength(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlBuffer * buf; /* the buffer */
|
|
int n_buf;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_const_xmlBuffer_ptr;n_buf++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_const_xmlBuffer_ptr(n_buf, 0);
|
|
|
|
ret_val = xmlBufferLength(buf);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlBuffer_ptr(n_buf, buf, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferLength",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferResize(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlBufferPtr buf; /* the buffer to resize */
|
|
int n_buf;
|
|
unsigned int size; /* the desired size */
|
|
int n_size;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_size = 0;n_size < gen_nb_unsigned_int;n_size++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
size = gen_unsigned_int(n_size, 1);
|
|
|
|
ret_val = xmlBufferResize(buf, size);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_unsigned_int(n_size, size, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferResize",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_size);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferSetAllocationScheme(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* the buffer to tune */
|
|
int n_buf;
|
|
xmlBufferAllocationScheme scheme; /* allocation scheme to use */
|
|
int n_scheme;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
scheme = gen_xmlBufferAllocationScheme(n_scheme, 1);
|
|
|
|
xmlBufferSetAllocationScheme(buf, scheme);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlBufferAllocationScheme(n_scheme, scheme, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferSetAllocationScheme",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_scheme);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferShrink(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlBufferPtr buf; /* the buffer to dump */
|
|
int n_buf;
|
|
unsigned int len; /* the number of xmlChar to remove */
|
|
int n_len;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
len = gen_unsigned_int(n_len, 1);
|
|
|
|
ret_val = xmlBufferShrink(buf, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_unsigned_int(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferShrink",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferWriteCHAR(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* the XML buffer */
|
|
int n_buf;
|
|
const xmlChar * string; /* the string to add */
|
|
int n_string;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
string = gen_const_xmlChar_ptr(n_string, 1);
|
|
|
|
xmlBufferWriteCHAR(buf, string);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_const_xmlChar_ptr(n_string, string, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferWriteCHAR",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_string);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferWriteChar(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* the XML buffer output */
|
|
int n_buf;
|
|
const char * string; /* the string to add */
|
|
int n_string;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_string = 0;n_string < gen_nb_const_char_ptr;n_string++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
string = gen_const_char_ptr(n_string, 1);
|
|
|
|
xmlBufferWriteChar(buf, string);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_const_char_ptr(n_string, string, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferWriteChar",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_string);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBufferWriteQuotedString(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* the XML buffer output */
|
|
int n_buf;
|
|
const xmlChar * string; /* the string to add */
|
|
int n_string;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
string = gen_const_xmlChar_ptr(n_string, 1);
|
|
|
|
xmlBufferWriteQuotedString(buf, string);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_const_xmlChar_ptr(n_string, string, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBufferWriteQuotedString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_string);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBuildQName(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * ncname; /* the Name */
|
|
int n_ncname;
|
|
const xmlChar * prefix; /* the prefix */
|
|
int n_prefix;
|
|
xmlChar * memory; /* preallocated memory */
|
|
int n_memory;
|
|
int len; /* preallocated memory length */
|
|
int n_len;
|
|
|
|
for (n_ncname = 0;n_ncname < gen_nb_const_xmlChar_ptr;n_ncname++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_memory = 0;n_memory < gen_nb_xmlChar_ptr;n_memory++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
ncname = gen_const_xmlChar_ptr(n_ncname, 0);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 1);
|
|
memory = gen_xmlChar_ptr(n_memory, 2);
|
|
len = gen_int(n_len, 3);
|
|
if ((prefix != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST prefix)))
|
|
len = 0;
|
|
|
|
ret_val = xmlBuildQName(ncname, prefix, memory, len);
|
|
if ((ret_val != NULL) && (ret_val != ncname) &&
|
|
(ret_val != prefix) && (ret_val != memory))
|
|
xmlFree(ret_val);
|
|
ret_val = NULL;
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_ncname, ncname, 0);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 1);
|
|
des_xmlChar_ptr(n_memory, memory, 2);
|
|
des_int(n_len, len, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBuildQName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ncname);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_memory);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlChildElementCount(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
int mem_base;
|
|
unsigned long ret_val;
|
|
xmlNodePtr parent; /* the parent node */
|
|
int n_parent;
|
|
|
|
for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
|
|
mem_base = xmlMemBlocks();
|
|
parent = gen_xmlNodePtr(n_parent, 0);
|
|
|
|
ret_val = xmlChildElementCount(parent);
|
|
desret_unsigned_long(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_parent, parent, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlChildElementCount",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_parent);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
int recursive; /* if not zero do a recursive copy. */
|
|
int n_recursive;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_recursive = 0;n_recursive < gen_nb_int;n_recursive++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
recursive = gen_int(n_recursive, 1);
|
|
|
|
ret_val = xmlCopyDoc(doc, recursive);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_int(n_recursive, recursive, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_recursive);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyDtd(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
int mem_base;
|
|
xmlDtdPtr ret_val;
|
|
xmlDtdPtr dtd; /* the dtd */
|
|
int n_dtd;
|
|
|
|
for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
|
|
mem_base = xmlMemBlocks();
|
|
dtd = gen_xmlDtdPtr(n_dtd, 0);
|
|
|
|
ret_val = xmlCopyDtd(dtd);
|
|
desret_xmlDtdPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDtdPtr(n_dtd, dtd, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyDtd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_dtd);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyNamespace(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNsPtr ret_val;
|
|
xmlNsPtr cur; /* the namespace */
|
|
int n_cur;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNsPtr(n_cur, 0);
|
|
|
|
ret_val = xmlCopyNamespace(cur);
|
|
if (ret_val != NULL) xmlFreeNs(ret_val);
|
|
desret_xmlNsPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNsPtr(n_cur, cur, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyNamespace",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyNamespaceList(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNsPtr ret_val;
|
|
xmlNsPtr cur; /* the first namespace */
|
|
int n_cur;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNsPtr(n_cur, 0);
|
|
|
|
ret_val = xmlCopyNamespaceList(cur);
|
|
if (ret_val != NULL) xmlFreeNsList(ret_val);
|
|
desret_xmlNsPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNsPtr(n_cur, cur, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyNamespaceList",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyNode(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr node; /* the node */
|
|
int n_node;
|
|
int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */
|
|
int n_extended;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_extended = 0;n_extended < gen_nb_int;n_extended++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
extended = gen_int(n_extended, 1);
|
|
|
|
ret_val = xmlCopyNode(node, extended);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_int(n_extended, extended, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_extended);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyNodeList(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr node; /* the first node in the list. */
|
|
int n_node;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
|
|
ret_val = xmlCopyNodeList(node);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyNodeList",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyProp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlAttrPtr ret_val;
|
|
xmlNodePtr target; /* the element where the attribute will be grafted */
|
|
int n_target;
|
|
xmlAttrPtr cur; /* the attribute */
|
|
int n_cur;
|
|
|
|
for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
target = gen_xmlNodePtr(n_target, 0);
|
|
cur = gen_xmlAttrPtr(n_cur, 1);
|
|
|
|
ret_val = xmlCopyProp(target, cur);
|
|
desret_xmlAttrPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_target, target, 0);
|
|
des_xmlAttrPtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_target);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyPropList(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlAttrPtr ret_val;
|
|
xmlNodePtr target; /* the element where the attributes will be grafted */
|
|
int n_target;
|
|
xmlAttrPtr cur; /* the first attribute */
|
|
int n_cur;
|
|
|
|
for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
target = gen_xmlNodePtr(n_target, 0);
|
|
cur = gen_xmlAttrPtr(n_cur, 1);
|
|
|
|
ret_val = xmlCopyPropList(target, cur);
|
|
desret_xmlAttrPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_target, target, 0);
|
|
des_xmlAttrPtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyPropList",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_target);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCreateIntSubset(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDtdPtr ret_val;
|
|
xmlDocPtr doc; /* the document pointer */
|
|
int n_doc;
|
|
const xmlChar * name; /* the DTD name */
|
|
int n_name;
|
|
const xmlChar * ExternalID; /* the external (PUBLIC) ID */
|
|
int n_ExternalID;
|
|
const xmlChar * SystemID; /* the system ID */
|
|
int n_SystemID;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
|
|
for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
|
|
SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
|
|
|
|
ret_val = xmlCreateIntSubset(doc, name, ExternalID, SystemID);
|
|
desret_xmlDtdPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_ExternalID, ExternalID, 2);
|
|
des_const_xmlChar_ptr(n_SystemID, SystemID, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCreateIntSubset",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_ExternalID);
|
|
printf(" %d", n_SystemID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlDOMWrapCtxtPtr 1
|
|
#define gen_xmlDOMWrapCtxtPtr(no, nr) NULL
|
|
#define des_xmlDOMWrapCtxtPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlDOMWrapAdoptNode(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */
|
|
int n_ctxt;
|
|
xmlDocPtr sourceDoc; /* the optional sourceDoc */
|
|
int n_sourceDoc;
|
|
xmlNodePtr node; /* the node to start with */
|
|
int n_node;
|
|
xmlDocPtr destDoc; /* the destination doc */
|
|
int n_destDoc;
|
|
xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */
|
|
int n_destParent;
|
|
int options; /* option flags */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
|
|
for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) {
|
|
for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
|
|
sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1);
|
|
node = gen_xmlNodePtr(n_node, 2);
|
|
destDoc = gen_xmlDocPtr(n_destDoc, 3);
|
|
destParent = gen_xmlNodePtr(n_destParent, 4);
|
|
options = gen_int(n_options, 5);
|
|
|
|
ret_val = xmlDOMWrapAdoptNode(ctxt, sourceDoc, node, destDoc, destParent, options);
|
|
if ((node != NULL) && (node->parent == NULL)) {xmlUnlinkNode(node);xmlFreeNode(node);node = NULL;}
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_sourceDoc, sourceDoc, 1);
|
|
des_xmlNodePtr(n_node, node, 2);
|
|
des_xmlDocPtr(n_destDoc, destDoc, 3);
|
|
des_xmlNodePtr(n_destParent, destParent, 4);
|
|
des_int(n_options, options, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDOMWrapAdoptNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_sourceDoc);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_destDoc);
|
|
printf(" %d", n_destParent);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDOMWrapCloneNode(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */
|
|
int n_ctxt;
|
|
xmlDocPtr sourceDoc; /* the optional sourceDoc */
|
|
int n_sourceDoc;
|
|
xmlNodePtr node; /* the node to start with */
|
|
int n_node;
|
|
xmlNodePtr * resNode; /* the clone of the given @node */
|
|
int n_resNode;
|
|
xmlDocPtr destDoc; /* the destination doc */
|
|
int n_destDoc;
|
|
xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */
|
|
int n_destParent;
|
|
int deep; /* descend into child if set */
|
|
int n_deep;
|
|
int options; /* option flags */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
|
|
for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_resNode = 0;n_resNode < gen_nb_xmlNodePtr_ptr;n_resNode++) {
|
|
for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) {
|
|
for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) {
|
|
for (n_deep = 0;n_deep < gen_nb_int;n_deep++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
|
|
sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1);
|
|
node = gen_xmlNodePtr(n_node, 2);
|
|
resNode = gen_xmlNodePtr_ptr(n_resNode, 3);
|
|
destDoc = gen_xmlDocPtr(n_destDoc, 4);
|
|
destParent = gen_xmlNodePtr(n_destParent, 5);
|
|
deep = gen_int(n_deep, 6);
|
|
options = gen_int(n_options, 7);
|
|
|
|
ret_val = xmlDOMWrapCloneNode(ctxt, sourceDoc, node, resNode, destDoc, destParent, deep, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_sourceDoc, sourceDoc, 1);
|
|
des_xmlNodePtr(n_node, node, 2);
|
|
des_xmlNodePtr_ptr(n_resNode, resNode, 3);
|
|
des_xmlDocPtr(n_destDoc, destDoc, 4);
|
|
des_xmlNodePtr(n_destParent, destParent, 5);
|
|
des_int(n_deep, deep, 6);
|
|
des_int(n_options, options, 7);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDOMWrapCloneNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_sourceDoc);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_resNode);
|
|
printf(" %d", n_destDoc);
|
|
printf(" %d", n_destParent);
|
|
printf(" %d", n_deep);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDOMWrapNewCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDOMWrapReconcileNamespaces(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDOMWrapCtxtPtr ctxt; /* DOM wrapper context, unused at the moment */
|
|
int n_ctxt;
|
|
xmlNodePtr elem; /* the element-node */
|
|
int n_elem;
|
|
int options; /* option flags */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
|
|
elem = gen_xmlNodePtr(n_elem, 1);
|
|
options = gen_int(n_options, 2);
|
|
|
|
ret_val = xmlDOMWrapReconcileNamespaces(ctxt, elem, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_elem, elem, 1);
|
|
des_int(n_options, options, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDOMWrapReconcileNamespaces",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDOMWrapRemoveNode(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDOMWrapCtxtPtr ctxt; /* a DOM wrapper context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* the doc */
|
|
int n_doc;
|
|
xmlNodePtr node; /* the node to be removed. */
|
|
int n_node;
|
|
int options; /* set of options, unused at the moment */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
node = gen_xmlNodePtr(n_node, 2);
|
|
options = gen_int(n_options, 3);
|
|
|
|
ret_val = xmlDOMWrapRemoveNode(ctxt, doc, node, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_node, node, 2);
|
|
des_int(n_options, options, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDOMWrapRemoveNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDeregisterNodeDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDocCopyNode(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr node; /* the node */
|
|
int n_node;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */
|
|
int n_extended;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_extended = 0;n_extended < gen_nb_int;n_extended++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
extended = gen_int(n_extended, 2);
|
|
|
|
ret_val = xmlDocCopyNode(node, doc, extended);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_int(n_extended, extended, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDocCopyNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_extended);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDocCopyNodeList(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlDocPtr doc; /* the target document */
|
|
int n_doc;
|
|
xmlNodePtr node; /* the first node in the list. */
|
|
int n_node;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
|
|
ret_val = xmlDocCopyNodeList(doc, node);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDocCopyNodeList",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDocDump(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
FILE * f; /* the FILE* */
|
|
int n_f;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
|
|
for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
f = gen_FILE_ptr(n_f, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
|
|
ret_val = xmlDocDump(f, cur);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_FILE_ptr(n_f, f, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDocDump",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_f);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDocDumpFormatMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
xmlChar ** mem; /* OUT: the memory pointer */
|
|
int n_mem;
|
|
int * size; /* OUT: the memory length */
|
|
int n_size;
|
|
int format; /* should formatting spaces been added */
|
|
int n_format;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
|
|
for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlDocPtr(n_cur, 0);
|
|
mem = gen_xmlChar_ptr_ptr(n_mem, 1);
|
|
size = gen_int_ptr(n_size, 2);
|
|
format = gen_int(n_format, 3);
|
|
|
|
xmlDocDumpFormatMemory(cur, mem, size, format);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_cur, cur, 0);
|
|
des_xmlChar_ptr_ptr(n_mem, mem, 1);
|
|
des_int_ptr(n_size, size, 2);
|
|
des_int(n_format, format, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDocDumpFormatMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_mem);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_format);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDocDumpFormatMemoryEnc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlDocPtr out_doc; /* Document to generate XML text from */
|
|
int n_out_doc;
|
|
xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */
|
|
int n_doc_txt_ptr;
|
|
int * doc_txt_len; /* Length of the generated XML text */
|
|
int n_doc_txt_len;
|
|
const char * txt_encoding; /* Character encoding to use when generating XML text */
|
|
int n_txt_encoding;
|
|
int format; /* should formatting spaces been added */
|
|
int n_format;
|
|
|
|
for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) {
|
|
for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
|
|
for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) {
|
|
for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
mem_base = xmlMemBlocks();
|
|
out_doc = gen_xmlDocPtr(n_out_doc, 0);
|
|
doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1);
|
|
doc_txt_len = gen_int_ptr(n_doc_txt_len, 2);
|
|
txt_encoding = gen_const_char_ptr(n_txt_encoding, 3);
|
|
format = gen_int(n_format, 4);
|
|
|
|
xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, txt_encoding, format);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_out_doc, out_doc, 0);
|
|
des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1);
|
|
des_int_ptr(n_doc_txt_len, doc_txt_len, 2);
|
|
des_const_char_ptr(n_txt_encoding, txt_encoding, 3);
|
|
des_int(n_format, format, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDocDumpFormatMemoryEnc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out_doc);
|
|
printf(" %d", n_doc_txt_ptr);
|
|
printf(" %d", n_doc_txt_len);
|
|
printf(" %d", n_txt_encoding);
|
|
printf(" %d", n_format);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDocDumpMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
xmlChar ** mem; /* OUT: the memory pointer */
|
|
int n_mem;
|
|
int * size; /* OUT: the memory length */
|
|
int n_size;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
|
|
for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlDocPtr(n_cur, 0);
|
|
mem = gen_xmlChar_ptr_ptr(n_mem, 1);
|
|
size = gen_int_ptr(n_size, 2);
|
|
|
|
xmlDocDumpMemory(cur, mem, size);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_cur, cur, 0);
|
|
des_xmlChar_ptr_ptr(n_mem, mem, 1);
|
|
des_int_ptr(n_size, size, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDocDumpMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_mem);
|
|
printf(" %d", n_size);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDocDumpMemoryEnc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlDocPtr out_doc; /* Document to generate XML text from */
|
|
int n_out_doc;
|
|
xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */
|
|
int n_doc_txt_ptr;
|
|
int * doc_txt_len; /* Length of the generated XML text */
|
|
int n_doc_txt_len;
|
|
const char * txt_encoding; /* Character encoding to use when generating XML text */
|
|
int n_txt_encoding;
|
|
|
|
for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) {
|
|
for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
|
|
for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) {
|
|
for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) {
|
|
mem_base = xmlMemBlocks();
|
|
out_doc = gen_xmlDocPtr(n_out_doc, 0);
|
|
doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1);
|
|
doc_txt_len = gen_int_ptr(n_doc_txt_len, 2);
|
|
txt_encoding = gen_const_char_ptr(n_txt_encoding, 3);
|
|
|
|
xmlDocDumpMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, txt_encoding);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_out_doc, out_doc, 0);
|
|
des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1);
|
|
des_int_ptr(n_doc_txt_len, doc_txt_len, 2);
|
|
des_const_char_ptr(n_txt_encoding, txt_encoding, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDocDumpMemoryEnc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out_doc);
|
|
printf(" %d", n_doc_txt_ptr);
|
|
printf(" %d", n_doc_txt_len);
|
|
printf(" %d", n_txt_encoding);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDocFormatDump(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
FILE * f; /* the FILE* */
|
|
int n_f;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
int format; /* should formatting spaces been added */
|
|
int n_format;
|
|
|
|
for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
mem_base = xmlMemBlocks();
|
|
f = gen_FILE_ptr(n_f, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
format = gen_int(n_format, 2);
|
|
|
|
ret_val = xmlDocFormatDump(f, cur, format);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_FILE_ptr(n_f, f, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
des_int(n_format, format, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDocFormatDump",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_f);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_format);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDocGetRootElement(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
const xmlDoc * doc; /* the document */
|
|
int n_doc;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_const_xmlDoc_ptr(n_doc, 0);
|
|
|
|
ret_val = xmlDocGetRootElement(doc);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlDoc_ptr(n_doc, doc, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDocGetRootElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlDocSetRootElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr root; /* the new document root element, if root is NULL no action is taken, to remove a node from a document use xmlUnlinkNode(root) instead. */
|
|
int n_root;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_root = 0;n_root < gen_nb_xmlNodePtr_in;n_root++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
root = gen_xmlNodePtr_in(n_root, 1);
|
|
|
|
ret_val = xmlDocSetRootElement(doc, root);
|
|
if (doc == NULL) { xmlFreeNode(root) ; root = NULL ; }
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNodePtr_in(n_root, root, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDocSetRootElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_root);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlElemDump(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
FILE * f; /* the FILE * for the output */
|
|
int n_f;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr cur; /* the current node */
|
|
int n_cur;
|
|
|
|
for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
f = gen_FILE_ptr(n_f, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
cur = gen_xmlNodePtr(n_cur, 2);
|
|
|
|
xmlElemDump(f, doc, cur);
|
|
call_tests++;
|
|
des_FILE_ptr(n_f, f, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_cur, cur, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlElemDump",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_f);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlFirstElementChild(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr parent; /* the parent node */
|
|
int n_parent;
|
|
|
|
for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
|
|
mem_base = xmlMemBlocks();
|
|
parent = gen_xmlNodePtr(n_parent, 0);
|
|
|
|
ret_val = xmlFirstElementChild(parent);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_parent, parent, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlFirstElementChild",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_parent);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetBufferAllocationScheme(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlBufferAllocationScheme ret_val;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
ret_val = xmlGetBufferAllocationScheme();
|
|
desret_xmlBufferAllocationScheme(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetBufferAllocationScheme",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetCompressMode(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
ret_val = xmlGetCompressMode();
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetCompressMode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetDocCompressMode(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlDoc * doc; /* the document */
|
|
int n_doc;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_const_xmlDoc_ptr(n_doc, 0);
|
|
|
|
ret_val = xmlGetDocCompressMode(doc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlDoc_ptr(n_doc, doc, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetDocCompressMode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetIntSubset(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDtdPtr ret_val;
|
|
const xmlDoc * doc; /* the document pointer */
|
|
int n_doc;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_const_xmlDoc_ptr(n_doc, 0);
|
|
|
|
ret_val = xmlGetIntSubset(doc);
|
|
desret_xmlDtdPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlDoc_ptr(n_doc, doc, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetIntSubset",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetLastChild(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
const xmlNode * parent; /* the parent node */
|
|
int n_parent;
|
|
|
|
for (n_parent = 0;n_parent < gen_nb_const_xmlNode_ptr;n_parent++) {
|
|
mem_base = xmlMemBlocks();
|
|
parent = gen_const_xmlNode_ptr(n_parent, 0);
|
|
|
|
ret_val = xmlGetLastChild(parent);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_parent, parent, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetLastChild",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_parent);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetLineNo(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
long ret_val;
|
|
const xmlNode * node; /* valid node */
|
|
int n_node;
|
|
|
|
for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_const_xmlNode_ptr(n_node, 0);
|
|
|
|
ret_val = xmlGetLineNo(node);
|
|
desret_long(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_node, node, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetLineNo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetNoNsProp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlNode * node; /* the node */
|
|
int n_node;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
|
|
for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_const_xmlNode_ptr(n_node, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlGetNoNsProp(node, name);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_node, node, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetNoNsProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetNodePath(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlNode * node; /* a node */
|
|
int n_node;
|
|
|
|
for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_const_xmlNode_ptr(n_node, 0);
|
|
|
|
ret_val = xmlGetNodePath(node);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_node, node, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetNodePath",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetNsList(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetNsProp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlNode * node; /* the node */
|
|
int n_node;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
const xmlChar * nameSpace; /* the URI of the namespace */
|
|
int n_nameSpace;
|
|
|
|
for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_const_xmlNode_ptr(n_node, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
|
|
|
|
ret_val = xmlGetNsProp(node, name, nameSpace);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_node, node, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_nameSpace, nameSpace, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetNsProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_nameSpace);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetProp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlNode * node; /* the node */
|
|
int n_node;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
|
|
for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_const_xmlNode_ptr(n_node, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlGetProp(node, name);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_node, node, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHasNsProp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlAttrPtr ret_val;
|
|
const xmlNode * node; /* the node */
|
|
int n_node;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
const xmlChar * nameSpace; /* the URI of the namespace */
|
|
int n_nameSpace;
|
|
|
|
for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_const_xmlNode_ptr(n_node, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
|
|
|
|
ret_val = xmlHasNsProp(node, name, nameSpace);
|
|
desret_xmlAttrPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_node, node, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_nameSpace, nameSpace, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHasNsProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_nameSpace);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlHasProp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlAttrPtr ret_val;
|
|
const xmlNode * node; /* the node */
|
|
int n_node;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
|
|
for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_const_xmlNode_ptr(n_node, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlHasProp(node, name);
|
|
desret_xmlAttrPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_node, node, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlHasProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsBlankNode(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlNode * node; /* the node */
|
|
int n_node;
|
|
|
|
for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_const_xmlNode_ptr(n_node, 0);
|
|
|
|
ret_val = xmlIsBlankNode(node);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_node, node, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsBlankNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsXHTML(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * systemID; /* the system identifier */
|
|
int n_systemID;
|
|
const xmlChar * publicID; /* the public identifier */
|
|
int n_publicID;
|
|
|
|
for (n_systemID = 0;n_systemID < gen_nb_const_xmlChar_ptr;n_systemID++) {
|
|
for (n_publicID = 0;n_publicID < gen_nb_const_xmlChar_ptr;n_publicID++) {
|
|
mem_base = xmlMemBlocks();
|
|
systemID = gen_const_xmlChar_ptr(n_systemID, 0);
|
|
publicID = gen_const_xmlChar_ptr(n_publicID, 1);
|
|
|
|
ret_val = xmlIsXHTML(systemID, publicID);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_systemID, systemID, 0);
|
|
des_const_xmlChar_ptr(n_publicID, publicID, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsXHTML",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_systemID);
|
|
printf(" %d", n_publicID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlLastElementChild(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr parent; /* the parent node */
|
|
int n_parent;
|
|
|
|
for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
|
|
mem_base = xmlMemBlocks();
|
|
parent = gen_xmlNodePtr(n_parent, 0);
|
|
|
|
ret_val = xmlLastElementChild(parent);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_parent, parent, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlLastElementChild",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_parent);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewCDataBlock(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * content; /* the CDATA block content content */
|
|
int n_content;
|
|
int len; /* the length of the block */
|
|
int n_len;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((content != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST content)))
|
|
len = 0;
|
|
|
|
ret_val = xmlNewCDataBlock(doc, content, len);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewCDataBlock",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_content);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewCharRef(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * name; /* the char ref string, starting with # or "&# ... ;" */
|
|
int n_name;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlNewCharRef(doc, name);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewCharRef",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewChild(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
#ifdef LIBXML_TREE_ENABLED
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr parent; /* the parent node */
|
|
int n_parent;
|
|
xmlNsPtr ns; /* a namespace if any */
|
|
int n_ns;
|
|
const xmlChar * name; /* the name of the child */
|
|
int n_name;
|
|
const xmlChar * content; /* the XML content of the child if any. */
|
|
int n_content;
|
|
|
|
for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
parent = gen_xmlNodePtr(n_parent, 0);
|
|
ns = gen_xmlNsPtr(n_ns, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
content = gen_const_xmlChar_ptr(n_content, 3);
|
|
|
|
ret_val = xmlNewChild(parent, ns, name, content);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_parent, parent, 0);
|
|
des_xmlNsPtr(n_ns, ns, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_content, content, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewChild",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_parent);
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewComment(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
const xmlChar * content; /* the comment content */
|
|
int n_content;
|
|
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
content = gen_const_xmlChar_ptr(n_content, 0);
|
|
|
|
ret_val = xmlNewComment(content);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_content, content, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewComment",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
const xmlChar * version; /* xmlChar string giving the version of XML "1.0" */
|
|
int n_version;
|
|
|
|
for (n_version = 0;n_version < gen_nb_const_xmlChar_ptr;n_version++) {
|
|
mem_base = xmlMemBlocks();
|
|
version = gen_const_xmlChar_ptr(n_version, 0);
|
|
|
|
ret_val = xmlNewDoc(version);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_version, version, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_version);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewDocComment(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * content; /* the comment content */
|
|
int n_content;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
|
|
ret_val = xmlNewDocComment(doc, content);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewDocComment",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewDocFragment(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlDocPtr doc; /* the document owning the fragment */
|
|
int n_doc;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
|
|
ret_val = xmlNewDocFragment(doc);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewDocFragment",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewDocNode(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNsPtr ns; /* namespace if any */
|
|
int n_ns;
|
|
const xmlChar * name; /* the node name */
|
|
int n_name;
|
|
const xmlChar * content; /* the XML text content if any */
|
|
int n_content;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
ns = gen_xmlNsPtr(n_ns, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
content = gen_const_xmlChar_ptr(n_content, 3);
|
|
|
|
ret_val = xmlNewDocNode(doc, ns, name, content);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNsPtr(n_ns, ns, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_content, content, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewDocNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewDocNodeEatName(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNsPtr ns; /* namespace if any */
|
|
int n_ns;
|
|
xmlChar * name; /* the node name */
|
|
int n_name;
|
|
const xmlChar * content; /* the XML text content if any */
|
|
int n_content;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
ns = gen_xmlNsPtr(n_ns, 1);
|
|
name = gen_eaten_name(n_name, 2);
|
|
content = gen_const_xmlChar_ptr(n_content, 3);
|
|
|
|
ret_val = xmlNewDocNodeEatName(doc, ns, name, content);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNsPtr(n_ns, ns, 1);
|
|
des_eaten_name(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_content, content, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewDocNodeEatName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewDocPI(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlDocPtr doc; /* the target document */
|
|
int n_doc;
|
|
const xmlChar * name; /* the processing instruction name */
|
|
int n_name;
|
|
const xmlChar * content; /* the PI content */
|
|
int n_content;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
content = gen_const_xmlChar_ptr(n_content, 2);
|
|
|
|
ret_val = xmlNewDocPI(doc, name, content);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_content, content, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewDocPI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewDocProp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlAttrPtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * name; /* the name of the attribute */
|
|
int n_name;
|
|
const xmlChar * value; /* the value of the attribute */
|
|
int n_value;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
value = gen_const_xmlChar_ptr(n_value, 2);
|
|
|
|
ret_val = xmlNewDocProp(doc, name, value);
|
|
desret_xmlAttrPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_value, value, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewDocProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewDocRawNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
#ifdef LIBXML_TREE_ENABLED
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNsPtr ns; /* namespace if any */
|
|
int n_ns;
|
|
const xmlChar * name; /* the node name */
|
|
int n_name;
|
|
const xmlChar * content; /* the text content if any */
|
|
int n_content;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
ns = gen_xmlNsPtr(n_ns, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
content = gen_const_xmlChar_ptr(n_content, 3);
|
|
|
|
ret_val = xmlNewDocRawNode(doc, ns, name, content);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNsPtr(n_ns, ns, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_content, content, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewDocRawNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewDocText(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
const xmlDoc * doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * content; /* the text content */
|
|
int n_content;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_const_xmlDoc_ptr(n_doc, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
|
|
ret_val = xmlNewDocText(doc, content);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlDoc_ptr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewDocText",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewDocTextLen(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * content; /* the text content */
|
|
int n_content;
|
|
int len; /* the text len. */
|
|
int n_len;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((content != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST content)))
|
|
len = 0;
|
|
|
|
ret_val = xmlNewDocTextLen(doc, content, len);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewDocTextLen",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_content);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewDtd(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDtdPtr ret_val;
|
|
xmlDocPtr doc; /* the document pointer */
|
|
int n_doc;
|
|
const xmlChar * name; /* the DTD name */
|
|
int n_name;
|
|
const xmlChar * ExternalID; /* the external ID */
|
|
int n_ExternalID;
|
|
const xmlChar * SystemID; /* the system ID */
|
|
int n_SystemID;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
|
|
for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
|
|
SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
|
|
|
|
ret_val = xmlNewDtd(doc, name, ExternalID, SystemID);
|
|
desret_xmlDtdPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_ExternalID, ExternalID, 2);
|
|
des_const_xmlChar_ptr(n_SystemID, SystemID, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewDtd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_ExternalID);
|
|
printf(" %d", n_SystemID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewNode(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNsPtr ns; /* namespace if any */
|
|
int n_ns;
|
|
const xmlChar * name; /* the node name */
|
|
int n_name;
|
|
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
ns = gen_xmlNsPtr(n_ns, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlNewNode(ns, name);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNsPtr(n_ns, ns, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewNodeEatName(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNsPtr ns; /* namespace if any */
|
|
int n_ns;
|
|
xmlChar * name; /* the node name */
|
|
int n_name;
|
|
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
ns = gen_xmlNsPtr(n_ns, 0);
|
|
name = gen_eaten_name(n_name, 1);
|
|
|
|
ret_val = xmlNewNodeEatName(ns, name);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNsPtr(n_ns, ns, 0);
|
|
des_eaten_name(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewNodeEatName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewNs(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNsPtr ret_val;
|
|
xmlNodePtr node; /* the element carrying the namespace */
|
|
int n_node;
|
|
const xmlChar * href; /* the URI associated */
|
|
int n_href;
|
|
const xmlChar * prefix; /* the prefix for the namespace */
|
|
int n_prefix;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
href = gen_const_xmlChar_ptr(n_href, 1);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 2);
|
|
|
|
ret_val = xmlNewNs(node, href, prefix);
|
|
if ((node == NULL) && (ret_val != NULL)) xmlFreeNs(ret_val);
|
|
desret_xmlNsPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_const_xmlChar_ptr(n_href, href, 1);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewNs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_href);
|
|
printf(" %d", n_prefix);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewNsProp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlAttrPtr ret_val;
|
|
xmlNodePtr node; /* the holding node */
|
|
int n_node;
|
|
xmlNsPtr ns; /* the namespace */
|
|
int n_ns;
|
|
const xmlChar * name; /* the name of the attribute */
|
|
int n_name;
|
|
const xmlChar * value; /* the value of the attribute */
|
|
int n_value;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
ns = gen_xmlNsPtr(n_ns, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
value = gen_const_xmlChar_ptr(n_value, 3);
|
|
|
|
ret_val = xmlNewNsProp(node, ns, name, value);
|
|
desret_xmlAttrPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_xmlNsPtr(n_ns, ns, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_value, value, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewNsProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewNsPropEatName(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlAttrPtr ret_val;
|
|
xmlNodePtr node; /* the holding node */
|
|
int n_node;
|
|
xmlNsPtr ns; /* the namespace */
|
|
int n_ns;
|
|
xmlChar * name; /* the name of the attribute */
|
|
int n_name;
|
|
const xmlChar * value; /* the value of the attribute */
|
|
int n_value;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
ns = gen_xmlNsPtr(n_ns, 1);
|
|
name = gen_eaten_name(n_name, 2);
|
|
value = gen_const_xmlChar_ptr(n_value, 3);
|
|
|
|
ret_val = xmlNewNsPropEatName(node, ns, name, value);
|
|
desret_xmlAttrPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_xmlNsPtr(n_ns, ns, 1);
|
|
des_eaten_name(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_value, value, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewNsPropEatName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewPI(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
const xmlChar * name; /* the processing instruction name */
|
|
int n_name;
|
|
const xmlChar * content; /* the PI content */
|
|
int n_content;
|
|
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
name = gen_const_xmlChar_ptr(n_name, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
|
|
ret_val = xmlNewPI(name, content);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_name, name, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewPI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewProp(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
#ifdef LIBXML_TREE_ENABLED
|
|
int mem_base;
|
|
xmlAttrPtr ret_val;
|
|
xmlNodePtr node; /* the holding node */
|
|
int n_node;
|
|
const xmlChar * name; /* the name of the attribute */
|
|
int n_name;
|
|
const xmlChar * value; /* the value of the attribute */
|
|
int n_value;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
value = gen_const_xmlChar_ptr(n_value, 2);
|
|
|
|
ret_val = xmlNewProp(node, name, value);
|
|
desret_xmlAttrPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_value, value, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewReference(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
const xmlDoc * doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * name; /* the reference name, or the reference string with & and ; */
|
|
int n_name;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_const_xmlDoc_ptr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlNewReference(doc, name);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlDoc_ptr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewReference",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewText(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
const xmlChar * content; /* the text content */
|
|
int n_content;
|
|
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
content = gen_const_xmlChar_ptr(n_content, 0);
|
|
|
|
ret_val = xmlNewText(content);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_content, content, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewText",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewTextChild(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
#ifdef LIBXML_TREE_ENABLED
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr parent; /* the parent node */
|
|
int n_parent;
|
|
xmlNsPtr ns; /* a namespace if any */
|
|
int n_ns;
|
|
const xmlChar * name; /* the name of the child */
|
|
int n_name;
|
|
const xmlChar * content; /* the text content of the child if any. */
|
|
int n_content;
|
|
|
|
for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
parent = gen_xmlNodePtr(n_parent, 0);
|
|
ns = gen_xmlNsPtr(n_ns, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
content = gen_const_xmlChar_ptr(n_content, 3);
|
|
|
|
ret_val = xmlNewTextChild(parent, ns, name, content);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_parent, parent, 0);
|
|
des_xmlNsPtr(n_ns, ns, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_content, content, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewTextChild",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_parent);
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewTextLen(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
const xmlChar * content; /* the text content */
|
|
int n_content;
|
|
int len; /* the text len. */
|
|
int n_len;
|
|
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
content = gen_const_xmlChar_ptr(n_content, 0);
|
|
len = gen_int(n_len, 1);
|
|
if ((content != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST content)))
|
|
len = 0;
|
|
|
|
ret_val = xmlNewTextLen(content, len);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_content, content, 0);
|
|
des_int(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewTextLen",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_content);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNextElementSibling(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr node; /* the current node */
|
|
int n_node;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
|
|
ret_val = xmlNextElementSibling(node);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNextElementSibling",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeAddContent(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr cur; /* the node being modified */
|
|
int n_cur;
|
|
const xmlChar * content; /* extra content */
|
|
int n_content;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodePtr(n_cur, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
|
|
xmlNodeAddContent(cur, content);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_cur, cur, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeAddContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeAddContentLen(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr cur; /* the node being modified */
|
|
int n_cur;
|
|
const xmlChar * content; /* extra content */
|
|
int n_content;
|
|
int len; /* the size of @content */
|
|
int n_len;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodePtr(n_cur, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((content != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST content)))
|
|
len = 0;
|
|
|
|
xmlNodeAddContentLen(cur, content, len);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_cur, cur, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeAddContentLen",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_content);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeBufGetContent(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlBufferPtr buffer; /* a buffer */
|
|
int n_buffer;
|
|
const xmlNode * cur; /* the node being read */
|
|
int n_cur;
|
|
|
|
for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) {
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlNode_ptr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
buffer = gen_xmlBufferPtr(n_buffer, 0);
|
|
cur = gen_const_xmlNode_ptr(n_cur, 1);
|
|
|
|
ret_val = xmlNodeBufGetContent(buffer, cur);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buffer, buffer, 0);
|
|
des_const_xmlNode_ptr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeBufGetContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeDump(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlBufferPtr buf; /* the XML buffer output */
|
|
int n_buf;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr cur; /* the current node */
|
|
int n_cur;
|
|
int level; /* the imbrication level for indenting */
|
|
int n_level;
|
|
int format; /* is formatting allowed */
|
|
int n_format;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_level = 0;n_level < gen_nb_int;n_level++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
cur = gen_xmlNodePtr(n_cur, 2);
|
|
level = gen_int(n_level, 3);
|
|
format = gen_int(n_format, 4);
|
|
|
|
ret_val = xmlNodeDump(buf, doc, cur, level, format);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_cur, cur, 2);
|
|
des_int(n_level, level, 3);
|
|
des_int(n_format, format, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeDump",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_level);
|
|
printf(" %d", n_format);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeDumpOutput(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlOutputBufferPtr buf; /* the XML buffer output */
|
|
int n_buf;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr cur; /* the current node */
|
|
int n_cur;
|
|
int level; /* the imbrication level for indenting */
|
|
int n_level;
|
|
int format; /* is formatting allowed */
|
|
int n_format;
|
|
const char * encoding; /* an optional encoding string */
|
|
int n_encoding;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_level = 0;n_level < gen_nb_int;n_level++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlOutputBufferPtr(n_buf, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
cur = gen_xmlNodePtr(n_cur, 2);
|
|
level = gen_int(n_level, 3);
|
|
format = gen_int(n_format, 4);
|
|
encoding = gen_const_char_ptr(n_encoding, 5);
|
|
|
|
xmlNodeDumpOutput(buf, doc, cur, level, format, encoding);
|
|
call_tests++;
|
|
des_xmlOutputBufferPtr(n_buf, buf, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_cur, cur, 2);
|
|
des_int(n_level, level, 3);
|
|
des_int(n_format, format, 4);
|
|
des_const_char_ptr(n_encoding, encoding, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeDumpOutput",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_level);
|
|
printf(" %d", n_format);
|
|
printf(" %d", n_encoding);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeGetBase(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlDoc * doc; /* the document the node pertains to */
|
|
int n_doc;
|
|
const xmlNode * cur; /* the node being checked */
|
|
int n_cur;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) {
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlNode_ptr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_const_xmlDoc_ptr(n_doc, 0);
|
|
cur = gen_const_xmlNode_ptr(n_cur, 1);
|
|
|
|
ret_val = xmlNodeGetBase(doc, cur);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlDoc_ptr(n_doc, doc, 0);
|
|
des_const_xmlNode_ptr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeGetBase",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeGetContent(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlNode * cur; /* the node being read */
|
|
int n_cur;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlNode_ptr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_xmlNode_ptr(n_cur, 0);
|
|
|
|
ret_val = xmlNodeGetContent(cur);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_cur, cur, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeGetContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeGetLang(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlNode * cur; /* the node being checked */
|
|
int n_cur;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlNode_ptr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_xmlNode_ptr(n_cur, 0);
|
|
|
|
ret_val = xmlNodeGetLang(cur);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_cur, cur, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeGetLang",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeGetSpacePreserve(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlNode * cur; /* the node being checked */
|
|
int n_cur;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlNode_ptr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_xmlNode_ptr(n_cur, 0);
|
|
|
|
ret_val = xmlNodeGetSpacePreserve(cur);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_cur, cur, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeGetSpacePreserve",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeIsText(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlNode * node; /* the node */
|
|
int n_node;
|
|
|
|
for (n_node = 0;n_node < gen_nb_const_xmlNode_ptr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_const_xmlNode_ptr(n_node, 0);
|
|
|
|
ret_val = xmlNodeIsText(node);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlNode_ptr(n_node, node, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeIsText",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeListGetRawString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlDoc * doc; /* the document */
|
|
int n_doc;
|
|
const xmlNode * list; /* a Node list */
|
|
int n_list;
|
|
int inLine; /* should we replace entity contents or show their external form */
|
|
int n_inLine;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) {
|
|
for (n_list = 0;n_list < gen_nb_const_xmlNode_ptr;n_list++) {
|
|
for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_const_xmlDoc_ptr(n_doc, 0);
|
|
list = gen_const_xmlNode_ptr(n_list, 1);
|
|
inLine = gen_int(n_inLine, 2);
|
|
|
|
ret_val = xmlNodeListGetRawString(doc, list, inLine);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlDoc_ptr(n_doc, doc, 0);
|
|
des_const_xmlNode_ptr(n_list, list, 1);
|
|
des_int(n_inLine, inLine, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeListGetRawString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_list);
|
|
printf(" %d", n_inLine);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeListGetString(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlNode * list; /* a Node list */
|
|
int n_list;
|
|
int inLine; /* should we replace entity contents or show their external form */
|
|
int n_inLine;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_list = 0;n_list < gen_nb_const_xmlNode_ptr;n_list++) {
|
|
for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
list = gen_const_xmlNode_ptr(n_list, 1);
|
|
inLine = gen_int(n_inLine, 2);
|
|
|
|
ret_val = xmlNodeListGetString(doc, list, inLine);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlNode_ptr(n_list, list, 1);
|
|
des_int(n_inLine, inLine, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeListGetString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_list);
|
|
printf(" %d", n_inLine);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeSetBase(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr cur; /* the node being changed */
|
|
int n_cur;
|
|
const xmlChar * uri; /* the new base URI */
|
|
int n_uri;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_uri = 0;n_uri < gen_nb_const_xmlChar_ptr;n_uri++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodePtr(n_cur, 0);
|
|
uri = gen_const_xmlChar_ptr(n_uri, 1);
|
|
|
|
xmlNodeSetBase(cur, uri);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_cur, cur, 0);
|
|
des_const_xmlChar_ptr(n_uri, uri, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeSetBase",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_uri);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeSetContent(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr cur; /* the node being modified */
|
|
int n_cur;
|
|
const xmlChar * content; /* the new value of the content */
|
|
int n_content;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodePtr(n_cur, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
|
|
xmlNodeSetContent(cur, content);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_cur, cur, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeSetContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeSetContentLen(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr cur; /* the node being modified */
|
|
int n_cur;
|
|
const xmlChar * content; /* the new value of the content */
|
|
int n_content;
|
|
int len; /* the size of @content */
|
|
int n_len;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodePtr(n_cur, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((content != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST content)))
|
|
len = 0;
|
|
|
|
xmlNodeSetContentLen(cur, content, len);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_cur, cur, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeSetContentLen",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_content);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeSetLang(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr cur; /* the node being changed */
|
|
int n_cur;
|
|
const xmlChar * lang; /* the language description */
|
|
int n_lang;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodePtr(n_cur, 0);
|
|
lang = gen_const_xmlChar_ptr(n_lang, 1);
|
|
|
|
xmlNodeSetLang(cur, lang);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_cur, cur, 0);
|
|
des_const_xmlChar_ptr(n_lang, lang, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeSetLang",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_lang);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeSetName(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr cur; /* the node being changed */
|
|
int n_cur;
|
|
const xmlChar * name; /* the new tag name */
|
|
int n_name;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodePtr(n_cur, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
xmlNodeSetName(cur, name);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_cur, cur, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeSetName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNodeSetSpacePreserve(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr cur; /* the node being changed */
|
|
int n_cur;
|
|
int val; /* the xml:space value ("0": default, 1: "preserve") */
|
|
int n_val;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
for (n_val = 0;n_val < gen_nb_int;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodePtr(n_cur, 0);
|
|
val = gen_int(n_val, 1);
|
|
|
|
xmlNodeSetSpacePreserve(cur, val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_cur, cur, 0);
|
|
des_int(n_val, val, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNodeSetSpacePreserve",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPreviousElementSibling(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr node; /* the current node */
|
|
int n_node;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
|
|
ret_val = xmlPreviousElementSibling(node);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPreviousElementSibling",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReconciliateNs(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED)
|
|
#ifdef LIBXML_TREE_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr tree; /* a node defining the subtree to reconciliate */
|
|
int n_tree;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
tree = gen_xmlNodePtr(n_tree, 1);
|
|
|
|
ret_val = xmlReconciliateNs(doc, tree);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNodePtr(n_tree, tree, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReconciliateNs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_tree);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRegisterNodeDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRemoveProp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlAttrPtr cur; /* an attribute */
|
|
int n_cur;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlAttrPtr(n_cur, 0);
|
|
|
|
ret_val = xmlRemoveProp(cur);
|
|
cur = NULL;
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlAttrPtr(n_cur, cur, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRemoveProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReplaceNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr old; /* the old node */
|
|
int n_old;
|
|
xmlNodePtr cur; /* the node */
|
|
int n_cur;
|
|
|
|
for (n_old = 0;n_old < gen_nb_xmlNodePtr;n_old++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
old = gen_xmlNodePtr(n_old, 0);
|
|
cur = gen_xmlNodePtr_in(n_cur, 1);
|
|
|
|
ret_val = xmlReplaceNode(old, cur);
|
|
if (cur != NULL) {
|
|
xmlUnlinkNode(cur);
|
|
xmlFreeNode(cur) ; cur = NULL ; }
|
|
if (old != NULL) {
|
|
xmlUnlinkNode(old);
|
|
xmlFreeNode(old) ; old = NULL ; }
|
|
ret_val = NULL;
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_old, old, 0);
|
|
des_xmlNodePtr_in(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReplaceNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_old);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * filename; /* the filename (or URL) */
|
|
int n_filename;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_fileoutput(n_filename, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
|
|
ret_val = xmlSaveFile(filename, cur);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_filename, filename, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSaveFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveFileEnc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * filename; /* the filename (or URL) */
|
|
int n_filename;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
const char * encoding; /* the name of an encoding (or NULL) */
|
|
int n_encoding;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_fileoutput(n_filename, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
|
|
ret_val = xmlSaveFileEnc(filename, cur, encoding);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_filename, filename, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSaveFileEnc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveFileTo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlOutputBufferPtr buf; /* an output I/O buffer */
|
|
int n_buf;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
const char * encoding; /* the encoding if any assuming the I/O layer handles the transcoding */
|
|
int n_encoding;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlOutputBufferPtr(n_buf, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
|
|
ret_val = xmlSaveFileTo(buf, cur, encoding);
|
|
buf = NULL;
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlOutputBufferPtr(n_buf, buf, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSaveFileTo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveFormatFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * filename; /* the filename (or URL) */
|
|
int n_filename;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
int format; /* should formatting spaces been added */
|
|
int n_format;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_fileoutput(n_filename, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
format = gen_int(n_format, 2);
|
|
|
|
ret_val = xmlSaveFormatFile(filename, cur, format);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_filename, filename, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
des_int(n_format, format, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSaveFormatFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_format);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveFormatFileEnc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * filename; /* the filename or URL to output */
|
|
int n_filename;
|
|
xmlDocPtr cur; /* the document being saved */
|
|
int n_cur;
|
|
const char * encoding; /* the name of the encoding to use or NULL. */
|
|
int n_encoding;
|
|
int format; /* should formatting spaces be added. */
|
|
int n_format;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_fileoutput(n_filename, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
format = gen_int(n_format, 3);
|
|
|
|
ret_val = xmlSaveFormatFileEnc(filename, cur, encoding, format);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_filename, filename, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
des_int(n_format, format, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSaveFormatFileEnc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_format);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveFormatFileTo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlOutputBufferPtr buf; /* an output I/O buffer */
|
|
int n_buf;
|
|
xmlDocPtr cur; /* the document */
|
|
int n_cur;
|
|
const char * encoding; /* the encoding if any assuming the I/O layer handles the transcoding */
|
|
int n_encoding;
|
|
int format; /* should formatting spaces been added */
|
|
int n_format;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_format = 0;n_format < gen_nb_int;n_format++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlOutputBufferPtr(n_buf, 0);
|
|
cur = gen_xmlDocPtr(n_cur, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
format = gen_int(n_format, 3);
|
|
|
|
ret_val = xmlSaveFormatFileTo(buf, cur, encoding, format);
|
|
buf = NULL;
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlOutputBufferPtr(n_buf, buf, 0);
|
|
des_xmlDocPtr(n_cur, cur, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
des_int(n_format, format, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSaveFormatFileTo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_format);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSearchNs(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNsPtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr node; /* the current node */
|
|
int n_node;
|
|
const xmlChar * nameSpace; /* the namespace prefix */
|
|
int n_nameSpace;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
|
|
|
|
ret_val = xmlSearchNs(doc, node, nameSpace);
|
|
desret_xmlNsPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
des_const_xmlChar_ptr(n_nameSpace, nameSpace, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSearchNs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_nameSpace);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSearchNsByHref(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNsPtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr node; /* the current node */
|
|
int n_node;
|
|
const xmlChar * href; /* the namespace value */
|
|
int n_href;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
href = gen_const_xmlChar_ptr(n_href, 2);
|
|
|
|
ret_val = xmlSearchNsByHref(doc, node, href);
|
|
desret_xmlNsPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
des_const_xmlChar_ptr(n_href, href, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSearchNsByHref",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_href);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSetBufferAllocationScheme(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlBufferAllocationScheme scheme; /* allocation method to use */
|
|
int n_scheme;
|
|
|
|
for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) {
|
|
mem_base = xmlMemBlocks();
|
|
scheme = gen_xmlBufferAllocationScheme(n_scheme, 0);
|
|
|
|
xmlSetBufferAllocationScheme(scheme);
|
|
call_tests++;
|
|
des_xmlBufferAllocationScheme(n_scheme, scheme, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSetBufferAllocationScheme",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_scheme);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSetCompressMode(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int mode; /* the compression ratio */
|
|
int n_mode;
|
|
|
|
for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
|
|
mem_base = xmlMemBlocks();
|
|
mode = gen_int(n_mode, 0);
|
|
|
|
xmlSetCompressMode(mode);
|
|
call_tests++;
|
|
des_int(n_mode, mode, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSetCompressMode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_mode);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSetDocCompressMode(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
int mode; /* the compression ratio */
|
|
int n_mode;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
mode = gen_int(n_mode, 1);
|
|
|
|
xmlSetDocCompressMode(doc, mode);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_int(n_mode, mode, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSetDocCompressMode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_mode);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSetNs(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr node; /* a node in the document */
|
|
int n_node;
|
|
xmlNsPtr ns; /* a namespace pointer */
|
|
int n_ns;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
ns = gen_xmlNsPtr(n_ns, 1);
|
|
|
|
xmlSetNs(node, ns);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_xmlNsPtr(n_ns, ns, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSetNs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_ns);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSetNsProp(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
xmlAttrPtr ret_val;
|
|
xmlNodePtr node; /* the node */
|
|
int n_node;
|
|
xmlNsPtr ns; /* the namespace definition */
|
|
int n_ns;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
const xmlChar * value; /* the attribute value */
|
|
int n_value;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
ns = gen_xmlNsPtr(n_ns, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
value = gen_const_xmlChar_ptr(n_value, 3);
|
|
|
|
ret_val = xmlSetNsProp(node, ns, name, value);
|
|
desret_xmlAttrPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_xmlNsPtr(n_ns, ns, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_value, value, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSetNsProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSetProp(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
|
|
int mem_base;
|
|
xmlAttrPtr ret_val;
|
|
xmlNodePtr node; /* the node */
|
|
int n_node;
|
|
const xmlChar * name; /* the attribute name (a QName) */
|
|
int n_name;
|
|
const xmlChar * value; /* the attribute value */
|
|
int n_value;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
value = gen_const_xmlChar_ptr(n_value, 2);
|
|
|
|
ret_val = xmlSetProp(node, name, value);
|
|
desret_xmlAttrPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_value, value, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSetProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSplitQName2(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * name; /* the full QName */
|
|
int n_name;
|
|
xmlChar ** prefix; /* a xmlChar ** */
|
|
int n_prefix;
|
|
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) {
|
|
mem_base = xmlMemBlocks();
|
|
name = gen_const_xmlChar_ptr(n_name, 0);
|
|
prefix = gen_xmlChar_ptr_ptr(n_prefix, 1);
|
|
|
|
ret_val = xmlSplitQName2(name, prefix);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_name, name, 0);
|
|
des_xmlChar_ptr_ptr(n_prefix, prefix, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSplitQName2",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_prefix);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSplitQName3(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
const xmlChar * name; /* the full QName */
|
|
int n_name;
|
|
int * len; /* an int * */
|
|
int n_len;
|
|
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
name = gen_const_xmlChar_ptr(n_name, 0);
|
|
len = gen_int_ptr(n_len, 1);
|
|
|
|
ret_val = xmlSplitQName3(name, len);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_name, name, 0);
|
|
des_int_ptr(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSplitQName3",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStringGetNodeList(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
const xmlDoc * doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * value; /* the value of the attribute */
|
|
int n_value;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_const_xmlDoc_ptr(n_doc, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
|
|
ret_val = xmlStringGetNodeList(doc, value);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlDoc_ptr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStringGetNodeList",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStringLenGetNodeList(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
const xmlDoc * doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * value; /* the value of the text */
|
|
int n_value;
|
|
int len; /* the length of the string value */
|
|
int n_len;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_const_xmlDoc_ptr;n_doc++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_const_xmlDoc_ptr(n_doc, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((value != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST value)))
|
|
len = 0;
|
|
|
|
ret_val = xmlStringLenGetNodeList(doc, value, len);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlDoc_ptr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStringLenGetNodeList",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextConcat(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodePtr node; /* the node */
|
|
int n_node;
|
|
const xmlChar * content; /* the content */
|
|
int n_content;
|
|
int len; /* @content length */
|
|
int n_len;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((content != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST content)))
|
|
len = 0;
|
|
|
|
ret_val = xmlTextConcat(node, content, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextConcat",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_content);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextMerge(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlNodePtr first; /* the first text node */
|
|
int n_first;
|
|
xmlNodePtr second; /* the second text node being merged */
|
|
int n_second;
|
|
|
|
for (n_first = 0;n_first < gen_nb_xmlNodePtr_in;n_first++) {
|
|
for (n_second = 0;n_second < gen_nb_xmlNodePtr_in;n_second++) {
|
|
mem_base = xmlMemBlocks();
|
|
first = gen_xmlNodePtr_in(n_first, 0);
|
|
second = gen_xmlNodePtr_in(n_second, 1);
|
|
|
|
ret_val = xmlTextMerge(first, second);
|
|
if (ret_val == NULL) {
|
|
xmlUnlinkNode(second);
|
|
xmlFreeNode(second) ; second = NULL ;
|
|
ret_val = first; }
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr_in(n_first, first, 0);
|
|
des_xmlNodePtr_in(n_second, second, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextMerge",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_first);
|
|
printf(" %d", n_second);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefBufferAllocScheme(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlBufferAllocationScheme ret_val;
|
|
xmlBufferAllocationScheme v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_xmlBufferAllocationScheme;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_xmlBufferAllocationScheme(n_v, 0);
|
|
|
|
ret_val = xmlThrDefBufferAllocScheme(v);
|
|
desret_xmlBufferAllocationScheme(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferAllocationScheme(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefBufferAllocScheme",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefDefaultBufferSize(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
int v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_int;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_int(n_v, 0);
|
|
|
|
ret_val = xmlThrDefDefaultBufferSize(v);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefDefaultBufferSize",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefDeregisterNodeDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefRegisterNodeDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUnsetNsProp(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodePtr node; /* the node */
|
|
int n_node;
|
|
xmlNsPtr ns; /* the namespace definition */
|
|
int n_ns;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
ns = gen_xmlNsPtr(n_ns, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
|
|
ret_val = xmlUnsetNsProp(node, ns, name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_xmlNsPtr(n_ns, ns, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUnsetNsProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUnsetProp(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodePtr node; /* the node */
|
|
int n_node;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlUnsetProp(node, name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUnsetProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateNCName(void) {
|
|
int test_ret = 0;
|
|
|
|
#ifdef LIBXML_TREE_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * value; /* the value to check */
|
|
int n_value;
|
|
int space; /* allow spaces in front and end of the string */
|
|
int n_space;
|
|
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_space = 0;n_space < gen_nb_int;n_space++) {
|
|
mem_base = xmlMemBlocks();
|
|
value = gen_const_xmlChar_ptr(n_value, 0);
|
|
space = gen_int(n_space, 1);
|
|
|
|
ret_val = xmlValidateNCName(value, space);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_value, value, 0);
|
|
des_int(n_space, space, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateNCName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_space);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateNMToken(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
#ifdef LIBXML_TREE_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * value; /* the value to check */
|
|
int n_value;
|
|
int space; /* allow spaces in front and end of the string */
|
|
int n_space;
|
|
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_space = 0;n_space < gen_nb_int;n_space++) {
|
|
mem_base = xmlMemBlocks();
|
|
value = gen_const_xmlChar_ptr(n_value, 0);
|
|
space = gen_int(n_space, 1);
|
|
|
|
ret_val = xmlValidateNMToken(value, space);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_value, value, 0);
|
|
des_int(n_space, space, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateNMToken",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_space);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateName(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
#ifdef LIBXML_TREE_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * value; /* the value to check */
|
|
int n_value;
|
|
int space; /* allow spaces in front and end of the string */
|
|
int n_space;
|
|
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_space = 0;n_space < gen_nb_int;n_space++) {
|
|
mem_base = xmlMemBlocks();
|
|
value = gen_const_xmlChar_ptr(n_value, 0);
|
|
space = gen_int(n_space, 1);
|
|
|
|
ret_val = xmlValidateName(value, space);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_value, value, 0);
|
|
des_int(n_space, space, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_space);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateQName(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
#ifdef LIBXML_TREE_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * value; /* the value to check */
|
|
int n_value;
|
|
int space; /* allow spaces in front and end of the string */
|
|
int n_space;
|
|
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_space = 0;n_space < gen_nb_int;n_space++) {
|
|
mem_base = xmlMemBlocks();
|
|
value = gen_const_xmlChar_ptr(n_value, 0);
|
|
space = gen_int(n_space, 1);
|
|
|
|
ret_val = xmlValidateQName(value, space);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_value, value, 0);
|
|
des_int(n_space, space, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateQName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_space);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_tree(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing tree : 144 of 170 functions ...\n");
|
|
test_ret += test_xmlAddChild();
|
|
test_ret += test_xmlAddChildList();
|
|
test_ret += test_xmlAddNextSibling();
|
|
test_ret += test_xmlAddPrevSibling();
|
|
test_ret += test_xmlAddSibling();
|
|
test_ret += test_xmlAttrSerializeTxtContent();
|
|
test_ret += test_xmlBufContent();
|
|
test_ret += test_xmlBufEnd();
|
|
test_ret += test_xmlBufGetNodeContent();
|
|
test_ret += test_xmlBufNodeDump();
|
|
test_ret += test_xmlBufShrink();
|
|
test_ret += test_xmlBufUse();
|
|
test_ret += test_xmlBufferAdd();
|
|
test_ret += test_xmlBufferAddHead();
|
|
test_ret += test_xmlBufferCCat();
|
|
test_ret += test_xmlBufferCat();
|
|
test_ret += test_xmlBufferContent();
|
|
test_ret += test_xmlBufferCreate();
|
|
test_ret += test_xmlBufferCreateSize();
|
|
test_ret += test_xmlBufferCreateStatic();
|
|
test_ret += test_xmlBufferDetach();
|
|
test_ret += test_xmlBufferEmpty();
|
|
test_ret += test_xmlBufferGrow();
|
|
test_ret += test_xmlBufferLength();
|
|
test_ret += test_xmlBufferResize();
|
|
test_ret += test_xmlBufferSetAllocationScheme();
|
|
test_ret += test_xmlBufferShrink();
|
|
test_ret += test_xmlBufferWriteCHAR();
|
|
test_ret += test_xmlBufferWriteChar();
|
|
test_ret += test_xmlBufferWriteQuotedString();
|
|
test_ret += test_xmlBuildQName();
|
|
test_ret += test_xmlChildElementCount();
|
|
test_ret += test_xmlCopyDoc();
|
|
test_ret += test_xmlCopyDtd();
|
|
test_ret += test_xmlCopyNamespace();
|
|
test_ret += test_xmlCopyNamespaceList();
|
|
test_ret += test_xmlCopyNode();
|
|
test_ret += test_xmlCopyNodeList();
|
|
test_ret += test_xmlCopyProp();
|
|
test_ret += test_xmlCopyPropList();
|
|
test_ret += test_xmlCreateIntSubset();
|
|
test_ret += test_xmlDOMWrapAdoptNode();
|
|
test_ret += test_xmlDOMWrapCloneNode();
|
|
test_ret += test_xmlDOMWrapNewCtxt();
|
|
test_ret += test_xmlDOMWrapReconcileNamespaces();
|
|
test_ret += test_xmlDOMWrapRemoveNode();
|
|
test_ret += test_xmlDeregisterNodeDefault();
|
|
test_ret += test_xmlDocCopyNode();
|
|
test_ret += test_xmlDocCopyNodeList();
|
|
test_ret += test_xmlDocDump();
|
|
test_ret += test_xmlDocDumpFormatMemory();
|
|
test_ret += test_xmlDocDumpFormatMemoryEnc();
|
|
test_ret += test_xmlDocDumpMemory();
|
|
test_ret += test_xmlDocDumpMemoryEnc();
|
|
test_ret += test_xmlDocFormatDump();
|
|
test_ret += test_xmlDocGetRootElement();
|
|
test_ret += test_xmlDocSetRootElement();
|
|
test_ret += test_xmlElemDump();
|
|
test_ret += test_xmlFirstElementChild();
|
|
test_ret += test_xmlGetBufferAllocationScheme();
|
|
test_ret += test_xmlGetCompressMode();
|
|
test_ret += test_xmlGetDocCompressMode();
|
|
test_ret += test_xmlGetIntSubset();
|
|
test_ret += test_xmlGetLastChild();
|
|
test_ret += test_xmlGetLineNo();
|
|
test_ret += test_xmlGetNoNsProp();
|
|
test_ret += test_xmlGetNodePath();
|
|
test_ret += test_xmlGetNsList();
|
|
test_ret += test_xmlGetNsProp();
|
|
test_ret += test_xmlGetProp();
|
|
test_ret += test_xmlHasNsProp();
|
|
test_ret += test_xmlHasProp();
|
|
test_ret += test_xmlIsBlankNode();
|
|
test_ret += test_xmlIsXHTML();
|
|
test_ret += test_xmlLastElementChild();
|
|
test_ret += test_xmlNewCDataBlock();
|
|
test_ret += test_xmlNewCharRef();
|
|
test_ret += test_xmlNewChild();
|
|
test_ret += test_xmlNewComment();
|
|
test_ret += test_xmlNewDoc();
|
|
test_ret += test_xmlNewDocComment();
|
|
test_ret += test_xmlNewDocFragment();
|
|
test_ret += test_xmlNewDocNode();
|
|
test_ret += test_xmlNewDocNodeEatName();
|
|
test_ret += test_xmlNewDocPI();
|
|
test_ret += test_xmlNewDocProp();
|
|
test_ret += test_xmlNewDocRawNode();
|
|
test_ret += test_xmlNewDocText();
|
|
test_ret += test_xmlNewDocTextLen();
|
|
test_ret += test_xmlNewDtd();
|
|
test_ret += test_xmlNewNode();
|
|
test_ret += test_xmlNewNodeEatName();
|
|
test_ret += test_xmlNewNs();
|
|
test_ret += test_xmlNewNsProp();
|
|
test_ret += test_xmlNewNsPropEatName();
|
|
test_ret += test_xmlNewPI();
|
|
test_ret += test_xmlNewProp();
|
|
test_ret += test_xmlNewReference();
|
|
test_ret += test_xmlNewText();
|
|
test_ret += test_xmlNewTextChild();
|
|
test_ret += test_xmlNewTextLen();
|
|
test_ret += test_xmlNextElementSibling();
|
|
test_ret += test_xmlNodeAddContent();
|
|
test_ret += test_xmlNodeAddContentLen();
|
|
test_ret += test_xmlNodeBufGetContent();
|
|
test_ret += test_xmlNodeDump();
|
|
test_ret += test_xmlNodeDumpOutput();
|
|
test_ret += test_xmlNodeGetBase();
|
|
test_ret += test_xmlNodeGetContent();
|
|
test_ret += test_xmlNodeGetLang();
|
|
test_ret += test_xmlNodeGetSpacePreserve();
|
|
test_ret += test_xmlNodeIsText();
|
|
test_ret += test_xmlNodeListGetRawString();
|
|
test_ret += test_xmlNodeListGetString();
|
|
test_ret += test_xmlNodeSetBase();
|
|
test_ret += test_xmlNodeSetContent();
|
|
test_ret += test_xmlNodeSetContentLen();
|
|
test_ret += test_xmlNodeSetLang();
|
|
test_ret += test_xmlNodeSetName();
|
|
test_ret += test_xmlNodeSetSpacePreserve();
|
|
test_ret += test_xmlPreviousElementSibling();
|
|
test_ret += test_xmlReconciliateNs();
|
|
test_ret += test_xmlRegisterNodeDefault();
|
|
test_ret += test_xmlRemoveProp();
|
|
test_ret += test_xmlReplaceNode();
|
|
test_ret += test_xmlSaveFile();
|
|
test_ret += test_xmlSaveFileEnc();
|
|
test_ret += test_xmlSaveFileTo();
|
|
test_ret += test_xmlSaveFormatFile();
|
|
test_ret += test_xmlSaveFormatFileEnc();
|
|
test_ret += test_xmlSaveFormatFileTo();
|
|
test_ret += test_xmlSearchNs();
|
|
test_ret += test_xmlSearchNsByHref();
|
|
test_ret += test_xmlSetBufferAllocationScheme();
|
|
test_ret += test_xmlSetCompressMode();
|
|
test_ret += test_xmlSetDocCompressMode();
|
|
test_ret += test_xmlSetNs();
|
|
test_ret += test_xmlSetNsProp();
|
|
test_ret += test_xmlSetProp();
|
|
test_ret += test_xmlSplitQName2();
|
|
test_ret += test_xmlSplitQName3();
|
|
test_ret += test_xmlStringGetNodeList();
|
|
test_ret += test_xmlStringLenGetNodeList();
|
|
test_ret += test_xmlTextConcat();
|
|
test_ret += test_xmlTextMerge();
|
|
test_ret += test_xmlThrDefBufferAllocScheme();
|
|
test_ret += test_xmlThrDefDefaultBufferSize();
|
|
test_ret += test_xmlThrDefDeregisterNodeDefault();
|
|
test_ret += test_xmlThrDefRegisterNodeDefault();
|
|
test_ret += test_xmlUnsetNsProp();
|
|
test_ret += test_xmlUnsetProp();
|
|
test_ret += test_xmlValidateNCName();
|
|
test_ret += test_xmlValidateNMToken();
|
|
test_ret += test_xmlValidateName();
|
|
test_ret += test_xmlValidateQName();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module tree: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlBuildRelativeURI(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * URI; /* the URI reference under consideration */
|
|
int n_URI;
|
|
const xmlChar * base; /* the base value */
|
|
int n_base;
|
|
|
|
for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
|
|
for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
|
|
mem_base = xmlMemBlocks();
|
|
URI = gen_const_xmlChar_ptr(n_URI, 0);
|
|
base = gen_const_xmlChar_ptr(n_base, 1);
|
|
|
|
ret_val = xmlBuildRelativeURI(URI, base);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_URI, URI, 0);
|
|
des_const_xmlChar_ptr(n_base, base, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBuildRelativeURI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URI);
|
|
printf(" %d", n_base);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlBuildURI(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * URI; /* the URI instance found in the document */
|
|
int n_URI;
|
|
const xmlChar * base; /* the base value */
|
|
int n_base;
|
|
|
|
for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
|
|
for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
|
|
mem_base = xmlMemBlocks();
|
|
URI = gen_const_xmlChar_ptr(n_URI, 0);
|
|
base = gen_const_xmlChar_ptr(n_base, 1);
|
|
|
|
ret_val = xmlBuildURI(URI, base);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_URI, URI, 0);
|
|
des_const_xmlChar_ptr(n_base, base, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlBuildURI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URI);
|
|
printf(" %d", n_base);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCanonicPath(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * path; /* the resource locator in a filesystem notation */
|
|
int n_path;
|
|
|
|
for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
|
|
mem_base = xmlMemBlocks();
|
|
path = gen_const_xmlChar_ptr(n_path, 0);
|
|
|
|
ret_val = xmlCanonicPath(path);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_path, path, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCanonicPath",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_path);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCreateURI(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNormalizeURIPath(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
char * path; /* pointer to the path string */
|
|
int n_path;
|
|
|
|
for (n_path = 0;n_path < gen_nb_char_ptr;n_path++) {
|
|
mem_base = xmlMemBlocks();
|
|
path = gen_char_ptr(n_path, 0);
|
|
|
|
ret_val = xmlNormalizeURIPath(path);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_char_ptr(n_path, path, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNormalizeURIPath",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_path);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseURI(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParseURIRaw(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlURIPtr 1
|
|
#define gen_xmlURIPtr(no, nr) NULL
|
|
#define des_xmlURIPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlParseURIReference(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlURIPtr uri; /* pointer to an URI structure */
|
|
int n_uri;
|
|
const char * str; /* the string to analyze */
|
|
int n_str;
|
|
|
|
for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
|
|
for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
uri = gen_xmlURIPtr(n_uri, 0);
|
|
str = gen_const_char_ptr(n_str, 1);
|
|
|
|
ret_val = xmlParseURIReference(uri, str);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlURIPtr(n_uri, uri, 0);
|
|
des_const_char_ptr(n_str, str, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParseURIReference",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_uri);
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPathToURI(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * path; /* the resource locator in a filesystem notation */
|
|
int n_path;
|
|
|
|
for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
|
|
mem_base = xmlMemBlocks();
|
|
path = gen_const_xmlChar_ptr(n_path, 0);
|
|
|
|
ret_val = xmlPathToURI(path);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_path, path, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPathToURI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_path);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPrintURI(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
FILE * stream; /* a FILE* for the output */
|
|
int n_stream;
|
|
xmlURIPtr uri; /* pointer to an xmlURI */
|
|
int n_uri;
|
|
|
|
for (n_stream = 0;n_stream < gen_nb_FILE_ptr;n_stream++) {
|
|
for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
|
|
mem_base = xmlMemBlocks();
|
|
stream = gen_FILE_ptr(n_stream, 0);
|
|
uri = gen_xmlURIPtr(n_uri, 1);
|
|
|
|
xmlPrintURI(stream, uri);
|
|
call_tests++;
|
|
des_FILE_ptr(n_stream, stream, 0);
|
|
des_xmlURIPtr(n_uri, uri, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPrintURI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_stream);
|
|
printf(" %d", n_uri);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveUri(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlURIPtr uri; /* pointer to an xmlURI */
|
|
int n_uri;
|
|
|
|
for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
|
|
mem_base = xmlMemBlocks();
|
|
uri = gen_xmlURIPtr(n_uri, 0);
|
|
|
|
ret_val = xmlSaveUri(uri);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlURIPtr(n_uri, uri, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSaveUri",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_uri);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlURIEscape(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * str; /* the string of the URI to escape */
|
|
int n_str;
|
|
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
str = gen_const_xmlChar_ptr(n_str, 0);
|
|
|
|
ret_val = xmlURIEscape(str);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str, str, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlURIEscape",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlURIEscapeStr(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * str; /* string to escape */
|
|
int n_str;
|
|
const xmlChar * list; /* exception list string of chars not to escape */
|
|
int n_list;
|
|
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_list = 0;n_list < gen_nb_const_xmlChar_ptr;n_list++) {
|
|
mem_base = xmlMemBlocks();
|
|
str = gen_const_xmlChar_ptr(n_str, 0);
|
|
list = gen_const_xmlChar_ptr(n_list, 1);
|
|
|
|
ret_val = xmlURIEscapeStr(str, list);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str, str, 0);
|
|
des_const_xmlChar_ptr(n_list, list, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlURIEscapeStr",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_list);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlURIUnescapeString(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_uri(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing uri : 10 of 15 functions ...\n");
|
|
test_ret += test_xmlBuildRelativeURI();
|
|
test_ret += test_xmlBuildURI();
|
|
test_ret += test_xmlCanonicPath();
|
|
test_ret += test_xmlCreateURI();
|
|
test_ret += test_xmlNormalizeURIPath();
|
|
test_ret += test_xmlParseURI();
|
|
test_ret += test_xmlParseURIRaw();
|
|
test_ret += test_xmlParseURIReference();
|
|
test_ret += test_xmlPathToURI();
|
|
test_ret += test_xmlPrintURI();
|
|
test_ret += test_xmlSaveUri();
|
|
test_ret += test_xmlURIEscape();
|
|
test_ret += test_xmlURIEscapeStr();
|
|
test_ret += test_xmlURIUnescapeString();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module uri: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlAddAttributeDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlAttributePtr ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDtdPtr dtd; /* pointer to the DTD */
|
|
int n_dtd;
|
|
const xmlChar * elem; /* the element name */
|
|
int n_elem;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
const xmlChar * ns; /* the attribute namespace prefix */
|
|
int n_ns;
|
|
xmlAttributeType type; /* the attribute type */
|
|
int n_type;
|
|
xmlAttributeDefault def; /* the attribute default type */
|
|
int n_def;
|
|
const xmlChar * defaultValue; /* the attribute default value */
|
|
int n_defaultValue;
|
|
xmlEnumerationPtr tree; /* if it's an enumeration, the associated list */
|
|
int n_tree;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
|
|
for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
|
|
for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) {
|
|
for (n_def = 0;n_def < gen_nb_xmlAttributeDefault;n_def++) {
|
|
for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) {
|
|
for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
dtd = gen_xmlDtdPtr(n_dtd, 1);
|
|
elem = gen_const_xmlChar_ptr(n_elem, 2);
|
|
name = gen_const_xmlChar_ptr(n_name, 3);
|
|
ns = gen_const_xmlChar_ptr(n_ns, 4);
|
|
type = gen_xmlAttributeType(n_type, 5);
|
|
def = gen_xmlAttributeDefault(n_def, 6);
|
|
defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 7);
|
|
tree = gen_xmlEnumerationPtr(n_tree, 8);
|
|
|
|
ret_val = xmlAddAttributeDecl(ctxt, dtd, elem, name, ns, type, def, defaultValue, tree);
|
|
desret_xmlAttributePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDtdPtr(n_dtd, dtd, 1);
|
|
des_const_xmlChar_ptr(n_elem, elem, 2);
|
|
des_const_xmlChar_ptr(n_name, name, 3);
|
|
des_const_xmlChar_ptr(n_ns, ns, 4);
|
|
des_xmlAttributeType(n_type, type, 5);
|
|
des_xmlAttributeDefault(n_def, def, 6);
|
|
des_const_xmlChar_ptr(n_defaultValue, defaultValue, 7);
|
|
des_xmlEnumerationPtr(n_tree, tree, 8);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAddAttributeDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_dtd);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_def);
|
|
printf(" %d", n_defaultValue);
|
|
printf(" %d", n_tree);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAddElementDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlElementPtr ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDtdPtr dtd; /* pointer to the DTD */
|
|
int n_dtd;
|
|
const xmlChar * name; /* the entity name */
|
|
int n_name;
|
|
xmlElementTypeVal type; /* the element type */
|
|
int n_type;
|
|
xmlElementContentPtr content; /* the element content tree or NULL */
|
|
int n_content;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_type = 0;n_type < gen_nb_xmlElementTypeVal;n_type++) {
|
|
for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
dtd = gen_xmlDtdPtr(n_dtd, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
type = gen_xmlElementTypeVal(n_type, 3);
|
|
content = gen_xmlElementContentPtr(n_content, 4);
|
|
|
|
ret_val = xmlAddElementDecl(ctxt, dtd, name, type, content);
|
|
desret_xmlElementPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDtdPtr(n_dtd, dtd, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_xmlElementTypeVal(n_type, type, 3);
|
|
des_xmlElementContentPtr(n_content, content, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAddElementDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_dtd);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAddID(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAddNotationDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAddRef(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyAttributeTable(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyDocElementContent(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlElementContentPtr ret_val;
|
|
xmlDocPtr doc; /* the document owning the element declaration */
|
|
int n_doc;
|
|
xmlElementContentPtr cur; /* An element content pointer. */
|
|
int n_cur;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
cur = gen_xmlElementContentPtr(n_cur, 1);
|
|
|
|
ret_val = xmlCopyDocElementContent(doc, cur);
|
|
desret_xmlElementContentPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlElementContentPtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyDocElementContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyElementContent(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlElementContentPtr ret_val;
|
|
xmlElementContentPtr cur; /* An element content pointer. */
|
|
int n_cur;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlElementContentPtr(n_cur, 0);
|
|
|
|
ret_val = xmlCopyElementContent(cur);
|
|
desret_xmlElementContentPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlElementContentPtr(n_cur, cur, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyElementContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyElementTable(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyEnumeration(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCopyNotationTable(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCreateEnumeration(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlAttributePtr 1
|
|
#define gen_xmlAttributePtr(no, nr) NULL
|
|
#define des_xmlAttributePtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlDumpAttributeDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* the XML buffer output */
|
|
int n_buf;
|
|
xmlAttributePtr attr; /* An attribute declaration */
|
|
int n_attr;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
attr = gen_xmlAttributePtr(n_attr, 1);
|
|
|
|
xmlDumpAttributeDecl(buf, attr);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlAttributePtr(n_attr, attr, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDumpAttributeDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_attr);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlAttributeTablePtr 1
|
|
#define gen_xmlAttributeTablePtr(no, nr) NULL
|
|
#define des_xmlAttributeTablePtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlDumpAttributeTable(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* the XML buffer output */
|
|
int n_buf;
|
|
xmlAttributeTablePtr table; /* An attribute table */
|
|
int n_table;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_table = 0;n_table < gen_nb_xmlAttributeTablePtr;n_table++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
table = gen_xmlAttributeTablePtr(n_table, 1);
|
|
|
|
xmlDumpAttributeTable(buf, table);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlAttributeTablePtr(n_table, table, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDumpAttributeTable",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_table);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlElementPtr 1
|
|
#define gen_xmlElementPtr(no, nr) NULL
|
|
#define des_xmlElementPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlDumpElementDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* the XML buffer output */
|
|
int n_buf;
|
|
xmlElementPtr elem; /* An element table */
|
|
int n_elem;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
elem = gen_xmlElementPtr(n_elem, 1);
|
|
|
|
xmlDumpElementDecl(buf, elem);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlElementPtr(n_elem, elem, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDumpElementDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlElementTablePtr 1
|
|
#define gen_xmlElementTablePtr(no, nr) NULL
|
|
#define des_xmlElementTablePtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlDumpElementTable(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* the XML buffer output */
|
|
int n_buf;
|
|
xmlElementTablePtr table; /* An element table */
|
|
int n_table;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_table = 0;n_table < gen_nb_xmlElementTablePtr;n_table++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
table = gen_xmlElementTablePtr(n_table, 1);
|
|
|
|
xmlDumpElementTable(buf, table);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlElementTablePtr(n_table, table, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDumpElementTable",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_table);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlNotationPtr 1
|
|
#define gen_xmlNotationPtr(no, nr) NULL
|
|
#define des_xmlNotationPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlDumpNotationDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* the XML buffer output */
|
|
int n_buf;
|
|
xmlNotationPtr nota; /* A notation declaration */
|
|
int n_nota;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
nota = gen_xmlNotationPtr(n_nota, 1);
|
|
|
|
xmlDumpNotationDecl(buf, nota);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlNotationPtr(n_nota, nota, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDumpNotationDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_nota);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlNotationTablePtr 1
|
|
#define gen_xmlNotationTablePtr(no, nr) NULL
|
|
#define des_xmlNotationTablePtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlDumpNotationTable(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* the XML buffer output */
|
|
int n_buf;
|
|
xmlNotationTablePtr table; /* A notation table */
|
|
int n_table;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_table = 0;n_table < gen_nb_xmlNotationTablePtr;n_table++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
table = gen_xmlNotationTablePtr(n_table, 1);
|
|
|
|
xmlDumpNotationTable(buf, table);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlNotationTablePtr(n_table, table, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlDumpNotationTable",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_table);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetDtdAttrDesc(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlAttributePtr ret_val;
|
|
xmlDtdPtr dtd; /* a pointer to the DtD to search */
|
|
int n_dtd;
|
|
const xmlChar * elem; /* the element name */
|
|
int n_elem;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
|
|
for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
|
|
for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
dtd = gen_xmlDtdPtr(n_dtd, 0);
|
|
elem = gen_const_xmlChar_ptr(n_elem, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
|
|
ret_val = xmlGetDtdAttrDesc(dtd, elem, name);
|
|
desret_xmlAttributePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDtdPtr(n_dtd, dtd, 0);
|
|
des_const_xmlChar_ptr(n_elem, elem, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetDtdAttrDesc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_dtd);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetDtdElementDesc(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlElementPtr ret_val;
|
|
xmlDtdPtr dtd; /* a pointer to the DtD to search */
|
|
int n_dtd;
|
|
const xmlChar * name; /* the element name */
|
|
int n_name;
|
|
|
|
for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
dtd = gen_xmlDtdPtr(n_dtd, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlGetDtdElementDesc(dtd, name);
|
|
desret_xmlElementPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDtdPtr(n_dtd, dtd, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetDtdElementDesc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_dtd);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetDtdNotationDesc(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetDtdQAttrDesc(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlAttributePtr ret_val;
|
|
xmlDtdPtr dtd; /* a pointer to the DtD to search */
|
|
int n_dtd;
|
|
const xmlChar * elem; /* the element name */
|
|
int n_elem;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
const xmlChar * prefix; /* the attribute namespace prefix */
|
|
int n_prefix;
|
|
|
|
for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
|
|
for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
mem_base = xmlMemBlocks();
|
|
dtd = gen_xmlDtdPtr(n_dtd, 0);
|
|
elem = gen_const_xmlChar_ptr(n_elem, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 3);
|
|
|
|
ret_val = xmlGetDtdQAttrDesc(dtd, elem, name, prefix);
|
|
desret_xmlAttributePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDtdPtr(n_dtd, dtd, 0);
|
|
des_const_xmlChar_ptr(n_elem, elem, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetDtdQAttrDesc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_dtd);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_prefix);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetDtdQElementDesc(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlElementPtr ret_val;
|
|
xmlDtdPtr dtd; /* a pointer to the DtD to search */
|
|
int n_dtd;
|
|
const xmlChar * name; /* the element name */
|
|
int n_name;
|
|
const xmlChar * prefix; /* the element namespace prefix */
|
|
int n_prefix;
|
|
|
|
for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
mem_base = xmlMemBlocks();
|
|
dtd = gen_xmlDtdPtr(n_dtd, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 2);
|
|
|
|
ret_val = xmlGetDtdQElementDesc(dtd, name, prefix);
|
|
desret_xmlElementPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDtdPtr(n_dtd, dtd, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetDtdQElementDesc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_dtd);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_prefix);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetID(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlAttrPtr ret_val;
|
|
xmlDocPtr doc; /* pointer to the document */
|
|
int n_doc;
|
|
const xmlChar * ID; /* the ID value */
|
|
int n_ID;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
ID = gen_const_xmlChar_ptr(n_ID, 1);
|
|
|
|
ret_val = xmlGetID(doc, ID);
|
|
desret_xmlAttrPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_ID, ID, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetID",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_ID);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetRefs(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsID(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr elem; /* the element carrying the attribute */
|
|
int n_elem;
|
|
xmlAttrPtr attr; /* the attribute */
|
|
int n_attr;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
elem = gen_xmlNodePtr(n_elem, 1);
|
|
attr = gen_xmlAttrPtr(n_attr, 2);
|
|
|
|
ret_val = xmlIsID(doc, elem, attr);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNodePtr(n_elem, elem, 1);
|
|
des_xmlAttrPtr(n_attr, attr, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsID",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_attr);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsMixedElement(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * name; /* the element name */
|
|
int n_name;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlIsMixedElement(doc, name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsMixedElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIsRef(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr elem; /* the element carrying the attribute */
|
|
int n_elem;
|
|
xmlAttrPtr attr; /* the attribute */
|
|
int n_attr;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
elem = gen_xmlNodePtr(n_elem, 1);
|
|
attr = gen_xmlAttrPtr(n_attr, 2);
|
|
|
|
ret_val = xmlIsRef(doc, elem, attr);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNodePtr(n_elem, elem, 1);
|
|
des_xmlAttrPtr(n_attr, attr, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIsRef",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_attr);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewDocElementContent(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlElementContentPtr ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * name; /* the subelement name or NULL */
|
|
int n_name;
|
|
xmlElementContentType type; /* the type of element content decl */
|
|
int n_type;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
type = gen_xmlElementContentType(n_type, 2);
|
|
|
|
ret_val = xmlNewDocElementContent(doc, name, type);
|
|
xmlFreeDocElementContent(doc, ret_val); ret_val = NULL;
|
|
desret_xmlElementContentPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_xmlElementContentType(n_type, type, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewDocElementContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_type);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewElementContent(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlElementContentPtr ret_val;
|
|
const xmlChar * name; /* the subelement name or NULL */
|
|
int n_name;
|
|
xmlElementContentType type; /* the type of element content decl */
|
|
int n_type;
|
|
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) {
|
|
mem_base = xmlMemBlocks();
|
|
name = gen_const_xmlChar_ptr(n_name, 0);
|
|
type = gen_xmlElementContentType(n_type, 1);
|
|
|
|
ret_val = xmlNewElementContent(name, type);
|
|
desret_xmlElementContentPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_name, name, 0);
|
|
des_xmlElementContentType(n_type, type, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewElementContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_type);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewValidCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRemoveID(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlAttrPtr attr; /* the attribute */
|
|
int n_attr;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
attr = gen_xmlAttrPtr(n_attr, 1);
|
|
|
|
ret_val = xmlRemoveID(doc, attr);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlAttrPtr(n_attr, attr, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRemoveID",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_attr);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRemoveRef(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlAttrPtr attr; /* the attribute */
|
|
int n_attr;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
attr = gen_xmlAttrPtr(n_attr, 1);
|
|
|
|
ret_val = xmlRemoveRef(doc, attr);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlAttrPtr(n_attr, attr, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRemoveRef",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_attr);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSnprintfElementContent(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
char * buf; /* an output buffer */
|
|
int n_buf;
|
|
int size; /* the buffer size */
|
|
int n_size;
|
|
xmlElementContentPtr content; /* An element table */
|
|
int n_content;
|
|
int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */
|
|
int n_englob;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
|
|
for (n_englob = 0;n_englob < gen_nb_int;n_englob++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_char_ptr(n_buf, 0);
|
|
size = gen_int(n_size, 1);
|
|
content = gen_xmlElementContentPtr(n_content, 2);
|
|
englob = gen_int(n_englob, 3);
|
|
|
|
xmlSnprintfElementContent(buf, size, content, englob);
|
|
call_tests++;
|
|
des_char_ptr(n_buf, buf, 0);
|
|
des_int(n_size, size, 1);
|
|
des_xmlElementContentPtr(n_content, content, 2);
|
|
des_int(n_englob, englob, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSnprintfElementContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_content);
|
|
printf(" %d", n_englob);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSprintfElementContent(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
#ifdef LIBXML_OUTPUT_ENABLED
|
|
int mem_base;
|
|
char * buf; /* an output buffer */
|
|
int n_buf;
|
|
xmlElementContentPtr content; /* An element table */
|
|
int n_content;
|
|
int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */
|
|
int n_englob;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) {
|
|
for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
|
|
for (n_englob = 0;n_englob < gen_nb_int;n_englob++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_char_ptr(n_buf, 0);
|
|
content = gen_xmlElementContentPtr(n_content, 1);
|
|
englob = gen_int(n_englob, 2);
|
|
|
|
xmlSprintfElementContent(buf, content, englob);
|
|
call_tests++;
|
|
des_char_ptr(n_buf, buf, 0);
|
|
des_xmlElementContentPtr(n_content, content, 1);
|
|
des_int(n_englob, englob, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSprintfElementContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_content);
|
|
printf(" %d", n_englob);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidBuildContentModel(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* a validation context */
|
|
int n_ctxt;
|
|
xmlElementPtr elem; /* an element declaration node */
|
|
int n_elem;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
elem = gen_xmlElementPtr(n_elem, 1);
|
|
|
|
ret_val = xmlValidBuildContentModel(ctxt, elem);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlElementPtr(n_elem, elem, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidBuildContentModel",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidCtxtNormalizeAttributeValue(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context or NULL */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr elem; /* the parent */
|
|
int n_elem;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
const xmlChar * value; /* the attribute value */
|
|
int n_value;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
elem = gen_xmlNodePtr(n_elem, 2);
|
|
name = gen_const_xmlChar_ptr(n_name, 3);
|
|
value = gen_const_xmlChar_ptr(n_value, 4);
|
|
|
|
ret_val = xmlValidCtxtNormalizeAttributeValue(ctxt, doc, elem, name, value);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_elem, elem, 2);
|
|
des_const_xmlChar_ptr(n_name, name, 3);
|
|
des_const_xmlChar_ptr(n_value, value, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidCtxtNormalizeAttributeValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_xmlElementContent_ptr 1
|
|
#define gen_xmlElementContent_ptr(no, nr) NULL
|
|
#define des_xmlElementContent_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlValidGetPotentialChildren(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
#ifdef LIBXML_VALID_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlElementContent * ctree; /* an element content tree */
|
|
int n_ctree;
|
|
const xmlChar ** names; /* an array to store the list of child names */
|
|
int n_names;
|
|
int * len; /* a pointer to the number of element in the list */
|
|
int n_len;
|
|
int max; /* the size of the array */
|
|
int n_max;
|
|
|
|
for (n_ctree = 0;n_ctree < gen_nb_xmlElementContent_ptr;n_ctree++) {
|
|
for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) {
|
|
for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
|
|
for (n_max = 0;n_max < gen_nb_int;n_max++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctree = gen_xmlElementContent_ptr(n_ctree, 0);
|
|
names = gen_const_xmlChar_ptr_ptr(n_names, 1);
|
|
len = gen_int_ptr(n_len, 2);
|
|
max = gen_int(n_max, 3);
|
|
|
|
ret_val = xmlValidGetPotentialChildren(ctree, names, len, max);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlElementContent_ptr(n_ctree, ctree, 0);
|
|
des_const_xmlChar_ptr_ptr(n_names, names, 1);
|
|
des_int_ptr(n_len, len, 2);
|
|
des_int(n_max, max, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidGetPotentialChildren",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctree);
|
|
printf(" %d", n_names);
|
|
printf(" %d", n_len);
|
|
printf(" %d", n_max);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidGetValidElements(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
#ifdef LIBXML_VALID_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNode * prev; /* an element to insert after */
|
|
int n_prev;
|
|
xmlNode * next; /* an element to insert next */
|
|
int n_next;
|
|
const xmlChar ** names; /* an array to store the list of child names */
|
|
int n_names;
|
|
int max; /* the size of the array */
|
|
int n_max;
|
|
|
|
for (n_prev = 0;n_prev < gen_nb_xmlNodePtr;n_prev++) {
|
|
for (n_next = 0;n_next < gen_nb_xmlNodePtr;n_next++) {
|
|
for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) {
|
|
for (n_max = 0;n_max < gen_nb_int;n_max++) {
|
|
mem_base = xmlMemBlocks();
|
|
prev = gen_xmlNodePtr(n_prev, 0);
|
|
next = gen_xmlNodePtr(n_next, 1);
|
|
names = gen_const_xmlChar_ptr_ptr(n_names, 2);
|
|
max = gen_int(n_max, 3);
|
|
|
|
ret_val = xmlValidGetValidElements(prev, next, names, max);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_prev, prev, 0);
|
|
des_xmlNodePtr(n_next, next, 1);
|
|
des_const_xmlChar_ptr_ptr(n_names, names, 2);
|
|
des_int(n_max, max, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidGetValidElements",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_prev);
|
|
printf(" %d", n_next);
|
|
printf(" %d", n_names);
|
|
printf(" %d", n_max);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidNormalizeAttributeValue(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
xmlNodePtr elem; /* the parent */
|
|
int n_elem;
|
|
const xmlChar * name; /* the attribute name */
|
|
int n_name;
|
|
const xmlChar * value; /* the attribute value */
|
|
int n_value;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
elem = gen_xmlNodePtr(n_elem, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
value = gen_const_xmlChar_ptr(n_value, 3);
|
|
|
|
ret_val = xmlValidNormalizeAttributeValue(doc, elem, name, value);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNodePtr(n_elem, elem, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_value, value, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidNormalizeAttributeValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateAttributeDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlAttributePtr attr; /* an attribute definition */
|
|
int n_attr;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
attr = gen_xmlAttributePtr(n_attr, 2);
|
|
|
|
ret_val = xmlValidateAttributeDecl(ctxt, doc, attr);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlAttributePtr(n_attr, attr, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateAttributeDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_attr);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateAttributeValue(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlAttributeType type; /* an attribute type */
|
|
int n_type;
|
|
const xmlChar * value; /* an attribute value */
|
|
int n_value;
|
|
|
|
for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
type = gen_xmlAttributeType(n_type, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
|
|
ret_val = xmlValidateAttributeValue(type, value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlAttributeType(n_type, type, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateAttributeValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateDocument(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
|
|
ret_val = xmlValidateDocument(ctxt, doc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateDocument",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateDocumentFinal(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
|
|
ret_val = xmlValidateDocumentFinal(ctxt, doc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateDocumentFinal",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateDtd(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlDtdPtr dtd; /* a dtd instance */
|
|
int n_dtd;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
dtd = gen_xmlDtdPtr(n_dtd, 2);
|
|
|
|
ret_val = xmlValidateDtd(ctxt, doc, dtd);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlDtdPtr(n_dtd, dtd, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateDtd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_dtd);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateDtdFinal(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
|
|
ret_val = xmlValidateDtdFinal(ctxt, doc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateDtdFinal",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlNodePtr root; /* an element instance */
|
|
int n_root;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_root = 0;n_root < gen_nb_xmlNodePtr;n_root++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
root = gen_xmlNodePtr(n_root, 2);
|
|
|
|
ret_val = xmlValidateElement(ctxt, doc, root);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_root, root, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_root);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateElementDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlElementPtr elem; /* an element definition */
|
|
int n_elem;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
elem = gen_xmlElementPtr(n_elem, 2);
|
|
|
|
ret_val = xmlValidateElementDecl(ctxt, doc, elem);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlElementPtr(n_elem, elem, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateElementDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateNameValue(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * value; /* an Name value */
|
|
int n_value;
|
|
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
value = gen_const_xmlChar_ptr(n_value, 0);
|
|
|
|
ret_val = xmlValidateNameValue(value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_value, value, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateNameValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateNamesValue(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * value; /* an Names value */
|
|
int n_value;
|
|
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
value = gen_const_xmlChar_ptr(n_value, 0);
|
|
|
|
ret_val = xmlValidateNamesValue(value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_value, value, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateNamesValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateNmtokenValue(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * value; /* an Nmtoken value */
|
|
int n_value;
|
|
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
value = gen_const_xmlChar_ptr(n_value, 0);
|
|
|
|
ret_val = xmlValidateNmtokenValue(value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_value, value, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateNmtokenValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateNmtokensValue(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * value; /* an Nmtokens value */
|
|
int n_value;
|
|
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
value = gen_const_xmlChar_ptr(n_value, 0);
|
|
|
|
ret_val = xmlValidateNmtokensValue(value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_value, value, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateNmtokensValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateNotationDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlNotationPtr nota; /* a notation definition */
|
|
int n_nota;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
nota = gen_xmlNotationPtr(n_nota, 2);
|
|
|
|
ret_val = xmlValidateNotationDecl(ctxt, doc, nota);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNotationPtr(n_nota, nota, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateNotationDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_nota);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateNotationUse(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* the document */
|
|
int n_doc;
|
|
const xmlChar * notationName; /* the notation name to check */
|
|
int n_notationName;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
notationName = gen_const_xmlChar_ptr(n_notationName, 2);
|
|
|
|
ret_val = xmlValidateNotationUse(ctxt, doc, notationName);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_const_xmlChar_ptr(n_notationName, notationName, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateNotationUse",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_notationName);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateOneAttribute(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlNodePtr elem; /* an element instance */
|
|
int n_elem;
|
|
xmlAttrPtr attr; /* an attribute instance */
|
|
int n_attr;
|
|
const xmlChar * value; /* the attribute value (without entities processing) */
|
|
int n_value;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
elem = gen_xmlNodePtr(n_elem, 2);
|
|
attr = gen_xmlAttrPtr(n_attr, 3);
|
|
value = gen_const_xmlChar_ptr(n_value, 4);
|
|
|
|
ret_val = xmlValidateOneAttribute(ctxt, doc, elem, attr, value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_elem, elem, 2);
|
|
des_xmlAttrPtr(n_attr, attr, 3);
|
|
des_const_xmlChar_ptr(n_value, value, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateOneAttribute",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_attr);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateOneElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlNodePtr elem; /* an element instance */
|
|
int n_elem;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
elem = gen_xmlNodePtr(n_elem, 2);
|
|
|
|
ret_val = xmlValidateOneElement(ctxt, doc, elem);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_elem, elem, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateOneElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateOneNamespace(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlNodePtr elem; /* an element instance */
|
|
int n_elem;
|
|
const xmlChar * prefix; /* the namespace prefix */
|
|
int n_prefix;
|
|
xmlNsPtr ns; /* an namespace declaration instance */
|
|
int n_ns;
|
|
const xmlChar * value; /* the attribute value (without entities processing) */
|
|
int n_value;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
elem = gen_xmlNodePtr(n_elem, 2);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 3);
|
|
ns = gen_xmlNsPtr(n_ns, 4);
|
|
value = gen_const_xmlChar_ptr(n_value, 5);
|
|
|
|
ret_val = xmlValidateOneNamespace(ctxt, doc, elem, prefix, ns, value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_elem, elem, 2);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 3);
|
|
des_xmlNsPtr(n_ns, ns, 4);
|
|
des_const_xmlChar_ptr(n_value, value, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateOneNamespace",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_ns);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidatePopElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlNodePtr elem; /* an element instance */
|
|
int n_elem;
|
|
const xmlChar * qname; /* the qualified name as appearing in the serialization */
|
|
int n_qname;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
elem = gen_xmlNodePtr(n_elem, 2);
|
|
qname = gen_const_xmlChar_ptr(n_qname, 3);
|
|
|
|
ret_val = xmlValidatePopElement(ctxt, doc, elem, qname);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_elem, elem, 2);
|
|
des_const_xmlChar_ptr(n_qname, qname, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidatePopElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_qname);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidatePushCData(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
const xmlChar * data; /* some character data read */
|
|
int n_data;
|
|
int len; /* the length of the data */
|
|
int n_len;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
data = gen_const_xmlChar_ptr(n_data, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((data != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST data)))
|
|
len = 0;
|
|
|
|
ret_val = xmlValidatePushCData(ctxt, data, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_data, data, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidatePushCData",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_data);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidatePushElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
xmlNodePtr elem; /* an element instance */
|
|
int n_elem;
|
|
const xmlChar * qname; /* the qualified name as appearing in the serialization */
|
|
int n_qname;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
elem = gen_xmlNodePtr(n_elem, 2);
|
|
qname = gen_const_xmlChar_ptr(n_qname, 3);
|
|
|
|
ret_val = xmlValidatePushElement(ctxt, doc, elem, qname);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
des_xmlNodePtr(n_elem, elem, 2);
|
|
des_const_xmlChar_ptr(n_qname, qname, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidatePushElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_elem);
|
|
printf(" %d", n_qname);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlValidateRoot(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_VALID_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlValidCtxtPtr ctxt; /* the validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document instance */
|
|
int n_doc;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
|
|
ret_val = xmlValidateRoot(ctxt, doc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlValidateRoot",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_valid(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing valid : 50 of 70 functions ...\n");
|
|
test_ret += test_xmlAddAttributeDecl();
|
|
test_ret += test_xmlAddElementDecl();
|
|
test_ret += test_xmlAddID();
|
|
test_ret += test_xmlAddNotationDecl();
|
|
test_ret += test_xmlAddRef();
|
|
test_ret += test_xmlCopyAttributeTable();
|
|
test_ret += test_xmlCopyDocElementContent();
|
|
test_ret += test_xmlCopyElementContent();
|
|
test_ret += test_xmlCopyElementTable();
|
|
test_ret += test_xmlCopyEnumeration();
|
|
test_ret += test_xmlCopyNotationTable();
|
|
test_ret += test_xmlCreateEnumeration();
|
|
test_ret += test_xmlDumpAttributeDecl();
|
|
test_ret += test_xmlDumpAttributeTable();
|
|
test_ret += test_xmlDumpElementDecl();
|
|
test_ret += test_xmlDumpElementTable();
|
|
test_ret += test_xmlDumpNotationDecl();
|
|
test_ret += test_xmlDumpNotationTable();
|
|
test_ret += test_xmlGetDtdAttrDesc();
|
|
test_ret += test_xmlGetDtdElementDesc();
|
|
test_ret += test_xmlGetDtdNotationDesc();
|
|
test_ret += test_xmlGetDtdQAttrDesc();
|
|
test_ret += test_xmlGetDtdQElementDesc();
|
|
test_ret += test_xmlGetID();
|
|
test_ret += test_xmlGetRefs();
|
|
test_ret += test_xmlIsID();
|
|
test_ret += test_xmlIsMixedElement();
|
|
test_ret += test_xmlIsRef();
|
|
test_ret += test_xmlNewDocElementContent();
|
|
test_ret += test_xmlNewElementContent();
|
|
test_ret += test_xmlNewValidCtxt();
|
|
test_ret += test_xmlRemoveID();
|
|
test_ret += test_xmlRemoveRef();
|
|
test_ret += test_xmlSnprintfElementContent();
|
|
test_ret += test_xmlSprintfElementContent();
|
|
test_ret += test_xmlValidBuildContentModel();
|
|
test_ret += test_xmlValidCtxtNormalizeAttributeValue();
|
|
test_ret += test_xmlValidGetPotentialChildren();
|
|
test_ret += test_xmlValidGetValidElements();
|
|
test_ret += test_xmlValidNormalizeAttributeValue();
|
|
test_ret += test_xmlValidateAttributeDecl();
|
|
test_ret += test_xmlValidateAttributeValue();
|
|
test_ret += test_xmlValidateDocument();
|
|
test_ret += test_xmlValidateDocumentFinal();
|
|
test_ret += test_xmlValidateDtd();
|
|
test_ret += test_xmlValidateDtdFinal();
|
|
test_ret += test_xmlValidateElement();
|
|
test_ret += test_xmlValidateElementDecl();
|
|
test_ret += test_xmlValidateNameValue();
|
|
test_ret += test_xmlValidateNamesValue();
|
|
test_ret += test_xmlValidateNmtokenValue();
|
|
test_ret += test_xmlValidateNmtokensValue();
|
|
test_ret += test_xmlValidateNotationDecl();
|
|
test_ret += test_xmlValidateNotationUse();
|
|
test_ret += test_xmlValidateOneAttribute();
|
|
test_ret += test_xmlValidateOneElement();
|
|
test_ret += test_xmlValidateOneNamespace();
|
|
test_ret += test_xmlValidatePopElement();
|
|
test_ret += test_xmlValidatePushCData();
|
|
test_ret += test_xmlValidatePushElement();
|
|
test_ret += test_xmlValidateRoot();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module valid: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlXIncludeNewContext(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXIncludeProcess(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XINCLUDE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* an XML document */
|
|
int n_doc;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
|
|
ret_val = xmlXIncludeProcess(doc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXIncludeProcess",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXIncludeProcessFlags(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XINCLUDE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* an XML document */
|
|
int n_doc;
|
|
int flags; /* a set of xmlParserOption used for parsing XML includes */
|
|
int n_flags;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
flags = gen_int(n_flags, 1);
|
|
|
|
ret_val = xmlXIncludeProcessFlags(doc, flags);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_int(n_flags, flags, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXIncludeProcessFlags",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_flags);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXIncludeProcessFlagsData(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XINCLUDE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlDocPtr doc; /* an XML document */
|
|
int n_doc;
|
|
int flags; /* a set of xmlParserOption used for parsing XML includes */
|
|
int n_flags;
|
|
void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */
|
|
int n_data;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
flags = gen_int(n_flags, 1);
|
|
data = gen_userdata(n_data, 2);
|
|
|
|
ret_val = xmlXIncludeProcessFlagsData(doc, flags, data);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_int(n_flags, flags, 1);
|
|
des_userdata(n_data, data, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXIncludeProcessFlagsData",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_flags);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_XINCLUDE_ENABLED
|
|
|
|
#define gen_nb_xmlXIncludeCtxtPtr 1
|
|
#define gen_xmlXIncludeCtxtPtr(no, nr) NULL
|
|
#define des_xmlXIncludeCtxtPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlXIncludeProcessNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XINCLUDE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXIncludeCtxtPtr ctxt; /* an existing XInclude context */
|
|
int n_ctxt;
|
|
xmlNodePtr node; /* a node in an XML document */
|
|
int n_node;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
|
|
ret_val = xmlXIncludeProcessNode(ctxt, node);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXIncludeProcessNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXIncludeProcessTree(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XINCLUDE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodePtr tree; /* a node in an XML document */
|
|
int n_tree;
|
|
|
|
for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
|
|
mem_base = xmlMemBlocks();
|
|
tree = gen_xmlNodePtr(n_tree, 0);
|
|
|
|
ret_val = xmlXIncludeProcessTree(tree);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_tree, tree, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXIncludeProcessTree",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_tree);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXIncludeProcessTreeFlags(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XINCLUDE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodePtr tree; /* a node in an XML document */
|
|
int n_tree;
|
|
int flags; /* a set of xmlParserOption used for parsing XML includes */
|
|
int n_flags;
|
|
|
|
for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
|
|
for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
|
|
mem_base = xmlMemBlocks();
|
|
tree = gen_xmlNodePtr(n_tree, 0);
|
|
flags = gen_int(n_flags, 1);
|
|
|
|
ret_val = xmlXIncludeProcessTreeFlags(tree, flags);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_tree, tree, 0);
|
|
des_int(n_flags, flags, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlags",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_tree);
|
|
printf(" %d", n_flags);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXIncludeProcessTreeFlagsData(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XINCLUDE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodePtr tree; /* an XML node */
|
|
int n_tree;
|
|
int flags; /* a set of xmlParserOption used for parsing XML includes */
|
|
int n_flags;
|
|
void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */
|
|
int n_data;
|
|
|
|
for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
|
|
for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
tree = gen_xmlNodePtr(n_tree, 0);
|
|
flags = gen_int(n_flags, 1);
|
|
data = gen_userdata(n_data, 2);
|
|
|
|
ret_val = xmlXIncludeProcessTreeFlagsData(tree, flags, data);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_tree, tree, 0);
|
|
des_int(n_flags, flags, 1);
|
|
des_userdata(n_data, data, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlagsData",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_tree);
|
|
printf(" %d", n_flags);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXIncludeSetFlags(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XINCLUDE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXIncludeCtxtPtr ctxt; /* an XInclude processing context */
|
|
int n_ctxt;
|
|
int flags; /* a set of xmlParserOption used for parsing XML includes */
|
|
int n_flags;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) {
|
|
for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0);
|
|
flags = gen_int(n_flags, 1);
|
|
|
|
ret_val = xmlXIncludeSetFlags(ctxt, flags);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_flags, flags, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXIncludeSetFlags",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_flags);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xinclude(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xinclude : 8 of 10 functions ...\n");
|
|
test_ret += test_xmlXIncludeNewContext();
|
|
test_ret += test_xmlXIncludeProcess();
|
|
test_ret += test_xmlXIncludeProcessFlags();
|
|
test_ret += test_xmlXIncludeProcessFlagsData();
|
|
test_ret += test_xmlXIncludeProcessNode();
|
|
test_ret += test_xmlXIncludeProcessTree();
|
|
test_ret += test_xmlXIncludeProcessTreeFlags();
|
|
test_ret += test_xmlXIncludeProcessTreeFlagsData();
|
|
test_ret += test_xmlXIncludeSetFlags();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xinclude: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlAllocOutputBuffer(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlOutputBufferPtr ret_val;
|
|
xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
|
|
int n_encoder;
|
|
|
|
for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
|
|
mem_base = xmlMemBlocks();
|
|
encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 0);
|
|
|
|
ret_val = xmlAllocOutputBuffer(encoder);
|
|
desret_xmlOutputBufferPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAllocOutputBuffer",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_encoder);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAllocParserInputBuffer(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputBufferPtr ret_val;
|
|
xmlCharEncoding enc; /* the charset encoding if known */
|
|
int n_enc;
|
|
|
|
for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
|
|
mem_base = xmlMemBlocks();
|
|
enc = gen_xmlCharEncoding(n_enc, 0);
|
|
|
|
ret_val = xmlAllocParserInputBuffer(enc);
|
|
desret_xmlParserInputBufferPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlCharEncoding(n_enc, enc, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAllocParserInputBuffer",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_enc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCheckFilename(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * path; /* the path to check */
|
|
int n_path;
|
|
|
|
for (n_path = 0;n_path < gen_nb_const_char_ptr;n_path++) {
|
|
mem_base = xmlMemBlocks();
|
|
path = gen_const_char_ptr(n_path, 0);
|
|
|
|
ret_val = xmlCheckFilename(path);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_path, path, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCheckFilename",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_path);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCheckHTTPInput(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr ret_val;
|
|
xmlParserCtxtPtr ctxt; /* an XML parser context */
|
|
int n_ctxt;
|
|
xmlParserInputPtr ret; /* an XML parser input */
|
|
int n_ret;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_ret = 0;n_ret < gen_nb_xmlParserInputPtr;n_ret++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
ret = gen_xmlParserInputPtr(n_ret, 1);
|
|
|
|
ret_val = xmlCheckHTTPInput(ctxt, ret);
|
|
desret_xmlParserInputPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlParserInputPtr(n_ret, ret, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCheckHTTPInput",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_ret);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCleanupInputCallbacks(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlCleanupInputCallbacks();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCleanupInputCallbacks",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCleanupOutputCallbacks(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlCleanupOutputCallbacks();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCleanupOutputCallbacks",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlFileClose(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
void * context; /* the I/O context */
|
|
int n_context;
|
|
|
|
for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
|
|
mem_base = xmlMemBlocks();
|
|
context = gen_void_ptr(n_context, 0);
|
|
|
|
ret_val = xmlFileClose(context);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_context, context, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlFileClose",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_context);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlFileMatch(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * filename; /* the URI for matching */
|
|
int n_filename;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
|
|
ret_val = xmlFileMatch(filename);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlFileMatch",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlFileOpen(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ret_val;
|
|
const char * filename; /* the URI for matching */
|
|
int n_filename;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
|
|
ret_val = xmlFileOpen(filename);
|
|
desret_void_ptr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlFileOpen",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlFileRead(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
void * context; /* the I/O context */
|
|
int n_context;
|
|
char * buffer; /* where to drop data */
|
|
int n_buffer;
|
|
int len; /* number of bytes to write */
|
|
int n_len;
|
|
|
|
for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
|
|
for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
context = gen_void_ptr(n_context, 0);
|
|
buffer = gen_char_ptr(n_buffer, 1);
|
|
len = gen_int(n_len, 2);
|
|
|
|
ret_val = xmlFileRead(context, buffer, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_context, context, 0);
|
|
des_char_ptr(n_buffer, buffer, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlFileRead",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_context);
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIOFTPClose(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_FTP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
void * context; /* the I/O context */
|
|
int n_context;
|
|
|
|
for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
|
|
mem_base = xmlMemBlocks();
|
|
context = gen_void_ptr(n_context, 0);
|
|
|
|
ret_val = xmlIOFTPClose(context);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_context, context, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIOFTPClose",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_context);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIOFTPMatch(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_FTP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * filename; /* the URI for matching */
|
|
int n_filename;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
|
|
ret_val = xmlIOFTPMatch(filename);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIOFTPMatch",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIOFTPOpen(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_FTP_ENABLED)
|
|
int mem_base;
|
|
void * ret_val;
|
|
const char * filename; /* the URI for matching */
|
|
int n_filename;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
|
|
ret_val = xmlIOFTPOpen(filename);
|
|
desret_void_ptr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIOFTPOpen",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIOFTPRead(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_FTP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
void * context; /* the I/O context */
|
|
int n_context;
|
|
char * buffer; /* where to drop data */
|
|
int n_buffer;
|
|
int len; /* number of bytes to write */
|
|
int n_len;
|
|
|
|
for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
|
|
for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
context = gen_void_ptr(n_context, 0);
|
|
buffer = gen_char_ptr(n_buffer, 1);
|
|
len = gen_int(n_len, 2);
|
|
|
|
ret_val = xmlIOFTPRead(context, buffer, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_context, context, 0);
|
|
des_char_ptr(n_buffer, buffer, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIOFTPRead",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_context);
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIOHTTPClose(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
void * context; /* the I/O context */
|
|
int n_context;
|
|
|
|
for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
|
|
mem_base = xmlMemBlocks();
|
|
context = gen_void_ptr(n_context, 0);
|
|
|
|
ret_val = xmlIOHTTPClose(context);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_context, context, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIOHTTPClose",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_context);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIOHTTPMatch(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const char * filename; /* the URI for matching */
|
|
int n_filename;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
|
|
ret_val = xmlIOHTTPMatch(filename);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIOHTTPMatch",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIOHTTPOpen(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
void * ret_val;
|
|
const char * filename; /* the URI for matching */
|
|
int n_filename;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
|
|
ret_val = xmlIOHTTPOpen(filename);
|
|
desret_xmlNanoHTTPCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIOHTTPOpen",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlIOHTTPRead(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
void * context; /* the I/O context */
|
|
int n_context;
|
|
char * buffer; /* where to drop data */
|
|
int n_buffer;
|
|
int len; /* number of bytes to write */
|
|
int n_len;
|
|
|
|
for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
|
|
for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
context = gen_void_ptr(n_context, 0);
|
|
buffer = gen_char_ptr(n_buffer, 1);
|
|
len = gen_int(n_len, 2);
|
|
|
|
ret_val = xmlIOHTTPRead(context, buffer, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_context, context, 0);
|
|
des_char_ptr(n_buffer, buffer, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlIOHTTPRead",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_context);
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNoNetExternalEntityLoader(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr ret_val;
|
|
const char * URL; /* the URL for the entity to load */
|
|
int n_URL;
|
|
const char * ID; /* the System ID for the entity to load */
|
|
int n_ID;
|
|
xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */
|
|
int n_ctxt;
|
|
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) {
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
URL = gen_filepath(n_URL, 0);
|
|
ID = gen_const_char_ptr(n_ID, 1);
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2);
|
|
|
|
ret_val = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
|
|
desret_xmlParserInputPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_URL, URL, 0);
|
|
des_const_char_ptr(n_ID, ID, 1);
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNoNetExternalEntityLoader",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_ID);
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNormalizeWindowsPath(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * path; /* the input file path */
|
|
int n_path;
|
|
|
|
for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
|
|
mem_base = xmlMemBlocks();
|
|
path = gen_const_xmlChar_ptr(n_path, 0);
|
|
|
|
ret_val = xmlNormalizeWindowsPath(path);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_path, path, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNormalizeWindowsPath",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_path);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlOutputBufferCreateBuffer(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlOutputBufferPtr ret_val;
|
|
xmlBufferPtr buffer; /* a xmlBufferPtr */
|
|
int n_buffer;
|
|
xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
|
|
int n_encoder;
|
|
|
|
for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) {
|
|
for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
|
|
mem_base = xmlMemBlocks();
|
|
buffer = gen_xmlBufferPtr(n_buffer, 0);
|
|
encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
|
|
|
|
ret_val = xmlOutputBufferCreateBuffer(buffer, encoder);
|
|
desret_xmlOutputBufferPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buffer, buffer, 0);
|
|
des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlOutputBufferCreateBuffer",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_encoder);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlOutputBufferCreateFd(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlOutputBufferPtr ret_val;
|
|
int fd; /* a file descriptor number */
|
|
int n_fd;
|
|
xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
|
|
int n_encoder;
|
|
|
|
for (n_fd = 0;n_fd < gen_nb_int;n_fd++) {
|
|
for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
|
|
mem_base = xmlMemBlocks();
|
|
fd = gen_int(n_fd, 0);
|
|
encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
|
|
|
|
ret_val = xmlOutputBufferCreateFd(fd, encoder);
|
|
desret_xmlOutputBufferPtr(ret_val);
|
|
call_tests++;
|
|
des_int(n_fd, fd, 0);
|
|
des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlOutputBufferCreateFd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_fd);
|
|
printf(" %d", n_encoder);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlOutputBufferCreateFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlOutputBufferPtr ret_val;
|
|
FILE * file; /* a FILE* */
|
|
int n_file;
|
|
xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
|
|
int n_encoder;
|
|
|
|
for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) {
|
|
for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
|
|
mem_base = xmlMemBlocks();
|
|
file = gen_FILE_ptr(n_file, 0);
|
|
encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
|
|
|
|
ret_val = xmlOutputBufferCreateFile(file, encoder);
|
|
desret_xmlOutputBufferPtr(ret_val);
|
|
call_tests++;
|
|
des_FILE_ptr(n_file, file, 0);
|
|
des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlOutputBufferCreateFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_file);
|
|
printf(" %d", n_encoder);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlOutputBufferCreateFilename(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
xmlOutputBufferPtr ret_val;
|
|
const char * URI; /* a C string containing the URI or filename */
|
|
int n_URI;
|
|
xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
|
|
int n_encoder;
|
|
int compression; /* the compression ration (0 none, 9 max). */
|
|
int n_compression;
|
|
|
|
for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) {
|
|
for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
|
|
for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
|
|
mem_base = xmlMemBlocks();
|
|
URI = gen_fileoutput(n_URI, 0);
|
|
encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
|
|
compression = gen_int(n_compression, 2);
|
|
|
|
ret_val = xmlOutputBufferCreateFilename(URI, encoder, compression);
|
|
desret_xmlOutputBufferPtr(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_URI, URI, 0);
|
|
des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
|
|
des_int(n_compression, compression, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlOutputBufferCreateFilename",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URI);
|
|
printf(" %d", n_encoder);
|
|
printf(" %d", n_compression);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlOutputBufferCreateFilenameDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlOutputBufferFlush(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlOutputBufferPtr out; /* a buffered output */
|
|
int n_out;
|
|
|
|
for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_xmlOutputBufferPtr(n_out, 0);
|
|
|
|
ret_val = xmlOutputBufferFlush(out);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlOutputBufferPtr(n_out, out, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlOutputBufferFlush",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlOutputBufferGetContent(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlOutputBufferPtr out; /* an xmlOutputBufferPtr */
|
|
int n_out;
|
|
|
|
for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_xmlOutputBufferPtr(n_out, 0);
|
|
|
|
ret_val = xmlOutputBufferGetContent(out);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlOutputBufferPtr(n_out, out, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlOutputBufferGetContent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlOutputBufferGetSize(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlOutputBufferWrite(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlOutputBufferPtr out; /* a buffered parser output */
|
|
int n_out;
|
|
int len; /* the size in bytes of the array. */
|
|
int n_len;
|
|
const char * buf; /* an char array */
|
|
int n_buf;
|
|
|
|
for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_xmlOutputBufferPtr(n_out, 0);
|
|
len = gen_int(n_len, 1);
|
|
buf = gen_const_char_ptr(n_buf, 2);
|
|
if ((buf != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST buf)))
|
|
len = 0;
|
|
|
|
ret_val = xmlOutputBufferWrite(out, len, buf);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlOutputBufferPtr(n_out, out, 0);
|
|
des_int(n_len, len, 1);
|
|
des_const_char_ptr(n_buf, buf, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlOutputBufferWrite",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_len);
|
|
printf(" %d", n_buf);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlOutputBufferWriteEscape(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlOutputBufferWriteString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlOutputBufferPtr out; /* a buffered parser output */
|
|
int n_out;
|
|
const char * str; /* a zero terminated C string */
|
|
int n_str;
|
|
|
|
for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
|
|
for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_xmlOutputBufferPtr(n_out, 0);
|
|
str = gen_const_char_ptr(n_str, 1);
|
|
|
|
ret_val = xmlOutputBufferWriteString(out, str);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlOutputBufferPtr(n_out, out, 0);
|
|
des_const_char_ptr(n_str, str, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlOutputBufferWriteString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserGetDirectory(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserInputBufferCreateFd(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputBufferPtr ret_val;
|
|
int fd; /* a file descriptor number */
|
|
int n_fd;
|
|
xmlCharEncoding enc; /* the charset encoding if known */
|
|
int n_enc;
|
|
|
|
for (n_fd = 0;n_fd < gen_nb_int;n_fd++) {
|
|
for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
|
|
mem_base = xmlMemBlocks();
|
|
fd = gen_int(n_fd, 0);
|
|
enc = gen_xmlCharEncoding(n_enc, 1);
|
|
if (fd >= 0) fd = -1;
|
|
|
|
ret_val = xmlParserInputBufferCreateFd(fd, enc);
|
|
desret_xmlParserInputBufferPtr(ret_val);
|
|
call_tests++;
|
|
des_int(n_fd, fd, 0);
|
|
des_xmlCharEncoding(n_enc, enc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserInputBufferCreateFd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_fd);
|
|
printf(" %d", n_enc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserInputBufferCreateFile(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputBufferPtr ret_val;
|
|
FILE * file; /* a FILE* */
|
|
int n_file;
|
|
xmlCharEncoding enc; /* the charset encoding if known */
|
|
int n_enc;
|
|
|
|
for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) {
|
|
for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
|
|
mem_base = xmlMemBlocks();
|
|
file = gen_FILE_ptr(n_file, 0);
|
|
enc = gen_xmlCharEncoding(n_enc, 1);
|
|
|
|
ret_val = xmlParserInputBufferCreateFile(file, enc);
|
|
desret_xmlParserInputBufferPtr(ret_val);
|
|
call_tests++;
|
|
des_FILE_ptr(n_file, file, 0);
|
|
des_xmlCharEncoding(n_enc, enc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserInputBufferCreateFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_file);
|
|
printf(" %d", n_enc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserInputBufferCreateFilename(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputBufferPtr ret_val;
|
|
const char * URI; /* a C string containing the URI or filename */
|
|
int n_URI;
|
|
xmlCharEncoding enc; /* the charset encoding if known */
|
|
int n_enc;
|
|
|
|
for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) {
|
|
for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
|
|
mem_base = xmlMemBlocks();
|
|
URI = gen_fileoutput(n_URI, 0);
|
|
enc = gen_xmlCharEncoding(n_enc, 1);
|
|
|
|
ret_val = xmlParserInputBufferCreateFilename(URI, enc);
|
|
desret_xmlParserInputBufferPtr(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_URI, URI, 0);
|
|
des_xmlCharEncoding(n_enc, enc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserInputBufferCreateFilename",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URI);
|
|
printf(" %d", n_enc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserInputBufferCreateFilenameDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserInputBufferCreateMem(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputBufferPtr ret_val;
|
|
const char * mem; /* the memory input */
|
|
int n_mem;
|
|
int size; /* the length of the memory block */
|
|
int n_size;
|
|
xmlCharEncoding enc; /* the charset encoding if known */
|
|
int n_enc;
|
|
|
|
for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
|
|
mem_base = xmlMemBlocks();
|
|
mem = gen_const_char_ptr(n_mem, 0);
|
|
size = gen_int(n_size, 1);
|
|
enc = gen_xmlCharEncoding(n_enc, 2);
|
|
if ((mem != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST mem)))
|
|
size = 0;
|
|
|
|
ret_val = xmlParserInputBufferCreateMem(mem, size, enc);
|
|
desret_xmlParserInputBufferPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_mem, mem, 0);
|
|
des_int(n_size, size, 1);
|
|
des_xmlCharEncoding(n_enc, enc, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserInputBufferCreateMem",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_mem);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_enc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserInputBufferCreateStatic(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputBufferPtr ret_val;
|
|
const char * mem; /* the memory input */
|
|
int n_mem;
|
|
int size; /* the length of the memory block */
|
|
int n_size;
|
|
xmlCharEncoding enc; /* the charset encoding if known */
|
|
int n_enc;
|
|
|
|
for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
|
|
mem_base = xmlMemBlocks();
|
|
mem = gen_const_char_ptr(n_mem, 0);
|
|
size = gen_int(n_size, 1);
|
|
enc = gen_xmlCharEncoding(n_enc, 2);
|
|
if ((mem != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST mem)))
|
|
size = 0;
|
|
|
|
ret_val = xmlParserInputBufferCreateStatic(mem, size, enc);
|
|
desret_xmlParserInputBufferPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_mem, mem, 0);
|
|
des_int(n_size, size, 1);
|
|
des_xmlCharEncoding(n_enc, enc, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserInputBufferCreateStatic",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_mem);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_enc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserInputBufferGrow(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserInputBufferPtr in; /* a buffered parser input */
|
|
int n_in;
|
|
int len; /* indicative value of the amount of chars to read */
|
|
int n_len;
|
|
|
|
for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
in = gen_xmlParserInputBufferPtr(n_in, 0);
|
|
len = gen_int(n_len, 1);
|
|
|
|
ret_val = xmlParserInputBufferGrow(in, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserInputBufferPtr(n_in, in, 0);
|
|
des_int(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserInputBufferGrow",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_in);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserInputBufferPush(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserInputBufferPtr in; /* a buffered parser input */
|
|
int n_in;
|
|
int len; /* the size in bytes of the array. */
|
|
int n_len;
|
|
const char * buf; /* an char array */
|
|
int n_buf;
|
|
|
|
for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) {
|
|
mem_base = xmlMemBlocks();
|
|
in = gen_xmlParserInputBufferPtr(n_in, 0);
|
|
len = gen_int(n_len, 1);
|
|
buf = gen_const_char_ptr(n_buf, 2);
|
|
if ((buf != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST buf)))
|
|
len = 0;
|
|
|
|
ret_val = xmlParserInputBufferPush(in, len, buf);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserInputBufferPtr(n_in, in, 0);
|
|
des_int(n_len, len, 1);
|
|
des_const_char_ptr(n_buf, buf, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserInputBufferPush",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_in);
|
|
printf(" %d", n_len);
|
|
printf(" %d", n_buf);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserInputBufferRead(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlParserInputBufferPtr in; /* a buffered parser input */
|
|
int n_in;
|
|
int len; /* indicative value of the amount of chars to read */
|
|
int n_len;
|
|
|
|
for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
in = gen_xmlParserInputBufferPtr(n_in, 0);
|
|
len = gen_int(n_len, 1);
|
|
|
|
ret_val = xmlParserInputBufferRead(in, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlParserInputBufferPtr(n_in, in, 0);
|
|
des_int(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserInputBufferRead",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_in);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPopInputCallbacks(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
ret_val = xmlPopInputCallbacks();
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPopInputCallbacks",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlPopOutputCallbacks(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
ret_val = xmlPopOutputCallbacks();
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlPopOutputCallbacks",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRegisterDefaultInputCallbacks(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlRegisterDefaultInputCallbacks();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRegisterDefaultInputCallbacks",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRegisterDefaultOutputCallbacks(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlRegisterDefaultOutputCallbacks();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRegisterDefaultOutputCallbacks",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRegisterHTTPPostCallbacks(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTTP_ENABLED)
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlRegisterHTTPPostCallbacks();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRegisterHTTPPostCallbacks",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefOutputBufferCreateFilenameDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefParserInputBufferCreateFilenameDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlIO(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xmlIO : 41 of 55 functions ...\n");
|
|
test_ret += test_xmlAllocOutputBuffer();
|
|
test_ret += test_xmlAllocParserInputBuffer();
|
|
test_ret += test_xmlCheckFilename();
|
|
test_ret += test_xmlCheckHTTPInput();
|
|
test_ret += test_xmlCleanupInputCallbacks();
|
|
test_ret += test_xmlCleanupOutputCallbacks();
|
|
test_ret += test_xmlFileClose();
|
|
test_ret += test_xmlFileMatch();
|
|
test_ret += test_xmlFileOpen();
|
|
test_ret += test_xmlFileRead();
|
|
test_ret += test_xmlIOFTPClose();
|
|
test_ret += test_xmlIOFTPMatch();
|
|
test_ret += test_xmlIOFTPOpen();
|
|
test_ret += test_xmlIOFTPRead();
|
|
test_ret += test_xmlIOHTTPClose();
|
|
test_ret += test_xmlIOHTTPMatch();
|
|
test_ret += test_xmlIOHTTPOpen();
|
|
test_ret += test_xmlIOHTTPRead();
|
|
test_ret += test_xmlNoNetExternalEntityLoader();
|
|
test_ret += test_xmlNormalizeWindowsPath();
|
|
test_ret += test_xmlOutputBufferCreateBuffer();
|
|
test_ret += test_xmlOutputBufferCreateFd();
|
|
test_ret += test_xmlOutputBufferCreateFile();
|
|
test_ret += test_xmlOutputBufferCreateFilename();
|
|
test_ret += test_xmlOutputBufferCreateFilenameDefault();
|
|
test_ret += test_xmlOutputBufferFlush();
|
|
test_ret += test_xmlOutputBufferGetContent();
|
|
test_ret += test_xmlOutputBufferGetSize();
|
|
test_ret += test_xmlOutputBufferWrite();
|
|
test_ret += test_xmlOutputBufferWriteEscape();
|
|
test_ret += test_xmlOutputBufferWriteString();
|
|
test_ret += test_xmlParserGetDirectory();
|
|
test_ret += test_xmlParserInputBufferCreateFd();
|
|
test_ret += test_xmlParserInputBufferCreateFile();
|
|
test_ret += test_xmlParserInputBufferCreateFilename();
|
|
test_ret += test_xmlParserInputBufferCreateFilenameDefault();
|
|
test_ret += test_xmlParserInputBufferCreateMem();
|
|
test_ret += test_xmlParserInputBufferCreateStatic();
|
|
test_ret += test_xmlParserInputBufferGrow();
|
|
test_ret += test_xmlParserInputBufferPush();
|
|
test_ret += test_xmlParserInputBufferRead();
|
|
test_ret += test_xmlPopInputCallbacks();
|
|
test_ret += test_xmlPopOutputCallbacks();
|
|
test_ret += test_xmlRegisterDefaultInputCallbacks();
|
|
test_ret += test_xmlRegisterDefaultOutputCallbacks();
|
|
test_ret += test_xmlRegisterHTTPPostCallbacks();
|
|
test_ret += test_xmlThrDefOutputBufferCreateFilenameDefault();
|
|
test_ret += test_xmlThrDefParserInputBufferCreateFilenameDefault();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xmlIO: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlAutomataCompile(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataGetInitState(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_AUTOMATA_ENABLED
|
|
|
|
#define gen_nb_xmlAutomataPtr 1
|
|
#define gen_xmlAutomataPtr(no, nr) NULL
|
|
#define des_xmlAutomataPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlAutomataIsDeterminist(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlAutomataPtr am; /* an automata */
|
|
int n_am;
|
|
|
|
for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
|
|
mem_base = xmlMemBlocks();
|
|
am = gen_xmlAutomataPtr(n_am, 0);
|
|
|
|
ret_val = xmlAutomataIsDeterminist(am);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlAutomataPtr(n_am, am, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAutomataIsDeterminist",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_am);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewAllTrans(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewCountTrans(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewCountTrans2(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewCountedTrans(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewCounter(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlAutomataPtr am; /* an automata */
|
|
int n_am;
|
|
int min; /* the minimal value on the counter */
|
|
int n_min;
|
|
int max; /* the maximal value on the counter */
|
|
int n_max;
|
|
|
|
for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
|
|
for (n_min = 0;n_min < gen_nb_int;n_min++) {
|
|
for (n_max = 0;n_max < gen_nb_int;n_max++) {
|
|
mem_base = xmlMemBlocks();
|
|
am = gen_xmlAutomataPtr(n_am, 0);
|
|
min = gen_int(n_min, 1);
|
|
max = gen_int(n_max, 2);
|
|
|
|
ret_val = xmlAutomataNewCounter(am, min, max);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlAutomataPtr(n_am, am, 0);
|
|
des_int(n_min, min, 1);
|
|
des_int(n_max, max, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAutomataNewCounter",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_am);
|
|
printf(" %d", n_min);
|
|
printf(" %d", n_max);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewCounterTrans(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewEpsilon(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewNegTrans(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewOnceTrans(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewOnceTrans2(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewState(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewTransition(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlAutomataNewTransition2(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_AUTOMATA_ENABLED
|
|
|
|
#define gen_nb_xmlAutomataStatePtr 1
|
|
#define gen_xmlAutomataStatePtr(no, nr) NULL
|
|
#define des_xmlAutomataStatePtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlAutomataSetFinalState(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlAutomataPtr am; /* an automata */
|
|
int n_am;
|
|
xmlAutomataStatePtr state; /* a state in this automata */
|
|
int n_state;
|
|
|
|
for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
|
|
for (n_state = 0;n_state < gen_nb_xmlAutomataStatePtr;n_state++) {
|
|
mem_base = xmlMemBlocks();
|
|
am = gen_xmlAutomataPtr(n_am, 0);
|
|
state = gen_xmlAutomataStatePtr(n_state, 1);
|
|
|
|
ret_val = xmlAutomataSetFinalState(am, state);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlAutomataPtr(n_am, am, 0);
|
|
des_xmlAutomataStatePtr(n_state, state, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlAutomataSetFinalState",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_am);
|
|
printf(" %d", n_state);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewAutomata(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlautomata(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xmlautomata : 3 of 19 functions ...\n");
|
|
test_ret += test_xmlAutomataCompile();
|
|
test_ret += test_xmlAutomataGetInitState();
|
|
test_ret += test_xmlAutomataIsDeterminist();
|
|
test_ret += test_xmlAutomataNewAllTrans();
|
|
test_ret += test_xmlAutomataNewCountTrans();
|
|
test_ret += test_xmlAutomataNewCountTrans2();
|
|
test_ret += test_xmlAutomataNewCountedTrans();
|
|
test_ret += test_xmlAutomataNewCounter();
|
|
test_ret += test_xmlAutomataNewCounterTrans();
|
|
test_ret += test_xmlAutomataNewEpsilon();
|
|
test_ret += test_xmlAutomataNewNegTrans();
|
|
test_ret += test_xmlAutomataNewOnceTrans();
|
|
test_ret += test_xmlAutomataNewOnceTrans2();
|
|
test_ret += test_xmlAutomataNewState();
|
|
test_ret += test_xmlAutomataNewTransition();
|
|
test_ret += test_xmlAutomataNewTransition2();
|
|
test_ret += test_xmlAutomataSetFinalState();
|
|
test_ret += test_xmlNewAutomata();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xmlautomata: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
#define gen_nb_xmlGenericErrorFunc_ptr 1
|
|
#define gen_xmlGenericErrorFunc_ptr(no, nr) NULL
|
|
#define des_xmlGenericErrorFunc_ptr(no, val, nr)
|
|
|
|
static int
|
|
test_initGenericErrorDefaultFunc(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlGenericErrorFunc * handler; /* the handler */
|
|
int n_handler;
|
|
|
|
for (n_handler = 0;n_handler < gen_nb_xmlGenericErrorFunc_ptr;n_handler++) {
|
|
mem_base = xmlMemBlocks();
|
|
handler = gen_xmlGenericErrorFunc_ptr(n_handler, 0);
|
|
|
|
initGenericErrorDefaultFunc(handler);
|
|
call_tests++;
|
|
des_xmlGenericErrorFunc_ptr(n_handler, handler, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in initGenericErrorDefaultFunc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_handler);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
#define gen_nb_const_xmlError_ptr 1
|
|
#define gen_const_xmlError_ptr(no, nr) NULL
|
|
#define des_const_xmlError_ptr(no, val, nr)
|
|
|
|
#define gen_nb_xmlErrorPtr 1
|
|
#define gen_xmlErrorPtr(no, nr) NULL
|
|
#define des_xmlErrorPtr(no, val, nr)
|
|
|
|
static int
|
|
test_xmlCopyError(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlError * from; /* a source error */
|
|
int n_from;
|
|
xmlErrorPtr to; /* a target error */
|
|
int n_to;
|
|
|
|
for (n_from = 0;n_from < gen_nb_const_xmlError_ptr;n_from++) {
|
|
for (n_to = 0;n_to < gen_nb_xmlErrorPtr;n_to++) {
|
|
mem_base = xmlMemBlocks();
|
|
from = gen_const_xmlError_ptr(n_from, 0);
|
|
to = gen_xmlErrorPtr(n_to, 1);
|
|
|
|
ret_val = xmlCopyError(from, to);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlError_ptr(n_from, from, 0);
|
|
des_xmlErrorPtr(n_to, to, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCopyError",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_from);
|
|
printf(" %d", n_to);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCtxtGetLastError(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCtxtResetLastError(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
void * ctx; /* an XML parser context */
|
|
int n_ctx;
|
|
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctx = gen_void_ptr(n_ctx, 0);
|
|
|
|
xmlCtxtResetLastError(ctx);
|
|
call_tests++;
|
|
des_void_ptr(n_ctx, ctx, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCtxtResetLastError",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetLastError(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserError(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserPrintFileContext(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr input; /* an xmlParserInputPtr input */
|
|
int n_input;
|
|
|
|
for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
|
|
mem_base = xmlMemBlocks();
|
|
input = gen_xmlParserInputPtr(n_input, 0);
|
|
|
|
xmlParserPrintFileContext(input);
|
|
call_tests++;
|
|
des_xmlParserInputPtr(n_input, input, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserPrintFileContext",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_input);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserPrintFileInfo(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlParserInputPtr input; /* an xmlParserInputPtr input */
|
|
int n_input;
|
|
|
|
for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
|
|
mem_base = xmlMemBlocks();
|
|
input = gen_xmlParserInputPtr(n_input, 0);
|
|
|
|
xmlParserPrintFileInfo(input);
|
|
call_tests++;
|
|
des_xmlParserInputPtr(n_input, input, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlParserPrintFileInfo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_input);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserValidityError(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserValidityWarning(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlParserWarning(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlResetError(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlErrorPtr err; /* pointer to the error. */
|
|
int n_err;
|
|
|
|
for (n_err = 0;n_err < gen_nb_xmlErrorPtr;n_err++) {
|
|
mem_base = xmlMemBlocks();
|
|
err = gen_xmlErrorPtr(n_err, 0);
|
|
|
|
xmlResetError(err);
|
|
call_tests++;
|
|
des_xmlErrorPtr(n_err, err, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlResetError",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_err);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlResetLastError(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
|
|
xmlResetLastError();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSetGenericErrorFunc(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSetStructuredErrorFunc(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefSetGenericErrorFunc(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefSetStructuredErrorFunc(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlerror(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xmlerror : 7 of 17 functions ...\n");
|
|
test_ret += test_initGenericErrorDefaultFunc();
|
|
test_ret += test_xmlCopyError();
|
|
test_ret += test_xmlCtxtGetLastError();
|
|
test_ret += test_xmlCtxtResetLastError();
|
|
test_ret += test_xmlGetLastError();
|
|
test_ret += test_xmlParserError();
|
|
test_ret += test_xmlParserPrintFileContext();
|
|
test_ret += test_xmlParserPrintFileInfo();
|
|
test_ret += test_xmlParserValidityError();
|
|
test_ret += test_xmlParserValidityWarning();
|
|
test_ret += test_xmlParserWarning();
|
|
test_ret += test_xmlResetError();
|
|
test_ret += test_xmlResetLastError();
|
|
test_ret += test_xmlSetGenericErrorFunc();
|
|
test_ret += test_xmlSetStructuredErrorFunc();
|
|
test_ret += test_xmlThrDefSetGenericErrorFunc();
|
|
test_ret += test_xmlThrDefSetStructuredErrorFunc();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xmlerror: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
#ifdef LIBXML_MODULES_ENABLED
|
|
|
|
#define gen_nb_xmlModulePtr 1
|
|
#define gen_xmlModulePtr(no, nr) NULL
|
|
#define des_xmlModulePtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlModuleClose(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_MODULES_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlModulePtr module; /* the module handle */
|
|
int n_module;
|
|
|
|
for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) {
|
|
mem_base = xmlMemBlocks();
|
|
module = gen_xmlModulePtr(n_module, 0);
|
|
|
|
ret_val = xmlModuleClose(module);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlModulePtr(n_module, module, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlModuleClose",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_module);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlModuleOpen(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlModuleSymbol(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_MODULES_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlModulePtr module; /* the module */
|
|
int n_module;
|
|
const char * name; /* the name of the symbol */
|
|
int n_name;
|
|
void ** symbol; /* the resulting symbol address */
|
|
int n_symbol;
|
|
|
|
for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) {
|
|
for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
|
|
for (n_symbol = 0;n_symbol < gen_nb_void_ptr_ptr;n_symbol++) {
|
|
mem_base = xmlMemBlocks();
|
|
module = gen_xmlModulePtr(n_module, 0);
|
|
name = gen_const_char_ptr(n_name, 1);
|
|
symbol = gen_void_ptr_ptr(n_symbol, 2);
|
|
|
|
ret_val = xmlModuleSymbol(module, name, symbol);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlModulePtr(n_module, module, 0);
|
|
des_const_char_ptr(n_name, name, 1);
|
|
des_void_ptr_ptr(n_symbol, symbol, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlModuleSymbol",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_module);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_symbol);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlmodule(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xmlmodule : 2 of 4 functions ...\n");
|
|
test_ret += test_xmlModuleClose();
|
|
test_ret += test_xmlModuleOpen();
|
|
test_ret += test_xmlModuleSymbol();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xmlmodule: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlNewTextReader(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlTextReaderPtr ret_val;
|
|
xmlParserInputBufferPtr input; /* the xmlParserInputBufferPtr used to read data */
|
|
int n_input;
|
|
const char * URI; /* the URI information for the source if available */
|
|
int n_URI;
|
|
|
|
for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
|
|
for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) {
|
|
mem_base = xmlMemBlocks();
|
|
input = gen_xmlParserInputBufferPtr(n_input, 0);
|
|
URI = gen_filepath(n_URI, 1);
|
|
|
|
ret_val = xmlNewTextReader(input, URI);
|
|
desret_xmlTextReaderPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserInputBufferPtr(n_input, input, 0);
|
|
des_filepath(n_URI, URI, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewTextReader",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_input);
|
|
printf(" %d", n_URI);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewTextReaderFilename(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlTextReaderPtr ret_val;
|
|
const char * URI; /* the URI of the resource to process */
|
|
int n_URI;
|
|
|
|
for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) {
|
|
mem_base = xmlMemBlocks();
|
|
URI = gen_filepath(n_URI, 0);
|
|
|
|
ret_val = xmlNewTextReaderFilename(URI);
|
|
desret_xmlTextReaderPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_URI, URI, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewTextReaderFilename",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URI);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReaderForDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlTextReaderPtr ret_val;
|
|
const xmlChar * cur; /* a pointer to a zero terminated string */
|
|
int n_cur;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_xmlChar_ptr(n_cur, 0);
|
|
URL = gen_filepath(n_URL, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
options = gen_parseroptions(n_options, 3);
|
|
|
|
ret_val = xmlReaderForDoc(cur, URL, encoding, options);
|
|
desret_xmlTextReaderPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_cur, cur, 0);
|
|
des_filepath(n_URL, URL, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
des_parseroptions(n_options, options, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReaderForDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReaderForFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlTextReaderPtr ret_val;
|
|
const char * filename; /* a file or URL */
|
|
int n_filename;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
filename = gen_filepath(n_filename, 0);
|
|
encoding = gen_const_char_ptr(n_encoding, 1);
|
|
options = gen_parseroptions(n_options, 2);
|
|
|
|
ret_val = xmlReaderForFile(filename, encoding, options);
|
|
desret_xmlTextReaderPtr(ret_val);
|
|
call_tests++;
|
|
des_filepath(n_filename, filename, 0);
|
|
des_const_char_ptr(n_encoding, encoding, 1);
|
|
des_parseroptions(n_options, options, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReaderForFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReaderForMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlTextReaderPtr ret_val;
|
|
const char * buffer; /* a pointer to a char array */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
buffer = gen_const_char_ptr(n_buffer, 0);
|
|
size = gen_int(n_size, 1);
|
|
URL = gen_filepath(n_URL, 2);
|
|
encoding = gen_const_char_ptr(n_encoding, 3);
|
|
options = gen_parseroptions(n_options, 4);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = xmlReaderForMemory(buffer, size, URL, encoding, options);
|
|
desret_xmlTextReaderPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_buffer, buffer, 0);
|
|
des_int(n_size, size, 1);
|
|
des_filepath(n_URL, URL, 2);
|
|
des_const_char_ptr(n_encoding, encoding, 3);
|
|
des_parseroptions(n_options, options, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReaderForMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReaderNewDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* an XML reader */
|
|
int n_reader;
|
|
const xmlChar * cur; /* a pointer to a zero terminated string */
|
|
int n_cur;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
cur = gen_const_xmlChar_ptr(n_cur, 1);
|
|
URL = gen_filepath(n_URL, 2);
|
|
encoding = gen_const_char_ptr(n_encoding, 3);
|
|
options = gen_parseroptions(n_options, 4);
|
|
|
|
ret_val = xmlReaderNewDoc(reader, cur, URL, encoding, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_const_xmlChar_ptr(n_cur, cur, 1);
|
|
des_filepath(n_URL, URL, 2);
|
|
des_const_char_ptr(n_encoding, encoding, 3);
|
|
des_parseroptions(n_options, options, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReaderNewDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReaderNewFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* an XML reader */
|
|
int n_reader;
|
|
const char * filename; /* a file or URL */
|
|
int n_filename;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
filename = gen_filepath(n_filename, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
options = gen_parseroptions(n_options, 3);
|
|
|
|
ret_val = xmlReaderNewFile(reader, filename, encoding, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_filepath(n_filename, filename, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
des_parseroptions(n_options, options, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReaderNewFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReaderNewMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* an XML reader */
|
|
int n_reader;
|
|
const char * buffer; /* a pointer to a char array */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
buffer = gen_const_char_ptr(n_buffer, 1);
|
|
size = gen_int(n_size, 2);
|
|
URL = gen_filepath(n_URL, 3);
|
|
encoding = gen_const_char_ptr(n_encoding, 4);
|
|
options = gen_parseroptions(n_options, 5);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = xmlReaderNewMemory(reader, buffer, size, URL, encoding, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_const_char_ptr(n_buffer, buffer, 1);
|
|
des_int(n_size, size, 2);
|
|
des_filepath(n_URL, URL, 3);
|
|
des_const_char_ptr(n_encoding, encoding, 4);
|
|
des_parseroptions(n_options, options, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReaderNewMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReaderNewWalker(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* an XML reader */
|
|
int n_reader;
|
|
xmlDocPtr doc; /* a preparsed document */
|
|
int n_doc;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
|
|
ret_val = xmlReaderNewWalker(reader, doc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReaderNewWalker",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlReaderWalker(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlTextReaderPtr ret_val;
|
|
xmlDocPtr doc; /* a preparsed document */
|
|
int n_doc;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
|
|
ret_val = xmlReaderWalker(doc);
|
|
desret_xmlTextReaderPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlReaderWalker",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderAttributeCount(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderAttributeCount(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderAttributeCount",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderBaseUri(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderBaseUri(reader);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderBaseUri",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderByteConsumed(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
long ret_val;
|
|
xmlTextReaderPtr reader; /* an XML reader */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderByteConsumed(reader);
|
|
desret_long(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderByteConsumed",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderClose(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderClose(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderClose",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderConstBaseUri(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderConstBaseUri(reader);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderConstBaseUri",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderConstEncoding(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderConstEncoding(reader);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderConstEncoding",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderConstLocalName(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderConstLocalName(reader);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderConstLocalName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderConstName(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderConstName(reader);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderConstName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderConstNamespaceUri(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderConstNamespaceUri(reader);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderConstNamespaceUri",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderConstPrefix(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderConstPrefix(reader);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderConstPrefix",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderConstString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
const xmlChar * str; /* the string to intern. */
|
|
int n_str;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
str = gen_const_xmlChar_ptr(n_str, 1);
|
|
|
|
ret_val = xmlTextReaderConstString(reader, str);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_const_xmlChar_ptr(n_str, str, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderConstString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderConstValue(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderConstValue(reader);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderConstValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderConstXmlLang(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderConstXmlLang(reader);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderConstXmlLang",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderConstXmlVersion(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderConstXmlVersion(reader);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderConstXmlVersion",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderCurrentDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlDocPtr ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderCurrentDoc(reader);
|
|
desret_xmlDocPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderCurrentDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderCurrentNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderCurrentNode(reader);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderCurrentNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderDepth(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderDepth(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderDepth",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderExpand(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderExpand(reader);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderExpand",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderGetAttribute(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
const xmlChar * name; /* the qualified name of the attribute. */
|
|
int n_name;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlTextReaderGetAttribute(reader, name);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderGetAttribute",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderGetAttributeNo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
int no; /* the zero-based index of the attribute relative to the containing element */
|
|
int n_no;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_no = 0;n_no < gen_nb_int;n_no++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
no = gen_int(n_no, 1);
|
|
|
|
ret_val = xmlTextReaderGetAttributeNo(reader, no);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_int(n_no, no, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderGetAttributeNo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_no);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderGetAttributeNs(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
const xmlChar * localName; /* the local name of the attribute. */
|
|
int n_localName;
|
|
const xmlChar * namespaceURI; /* the namespace URI of the attribute. */
|
|
int n_namespaceURI;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
|
|
for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
localName = gen_const_xmlChar_ptr(n_localName, 1);
|
|
namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2);
|
|
|
|
ret_val = xmlTextReaderGetAttributeNs(reader, localName, namespaceURI);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_const_xmlChar_ptr(n_localName, localName, 1);
|
|
des_const_xmlChar_ptr(n_namespaceURI, namespaceURI, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderGetAttributeNs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_localName);
|
|
printf(" %d", n_namespaceURI);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_READER_ENABLED
|
|
|
|
#define gen_nb_xmlTextReaderErrorFunc_ptr 1
|
|
#define gen_xmlTextReaderErrorFunc_ptr(no, nr) NULL
|
|
#define des_xmlTextReaderErrorFunc_ptr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderGetErrorHandler(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
xmlTextReaderErrorFunc * f; /* the callback function or NULL is no callback has been registered */
|
|
int n_f;
|
|
void ** arg; /* a user argument */
|
|
int n_arg;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_f = 0;n_f < gen_nb_xmlTextReaderErrorFunc_ptr;n_f++) {
|
|
for (n_arg = 0;n_arg < gen_nb_void_ptr_ptr;n_arg++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
f = gen_xmlTextReaderErrorFunc_ptr(n_f, 1);
|
|
arg = gen_void_ptr_ptr(n_arg, 2);
|
|
|
|
xmlTextReaderGetErrorHandler(reader, f, arg);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_xmlTextReaderErrorFunc_ptr(n_f, f, 1);
|
|
des_void_ptr_ptr(n_arg, arg, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderGetErrorHandler",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_f);
|
|
printf(" %d", n_arg);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderGetParserColumnNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the user data (XML reader context) */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderGetParserColumnNumber(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderGetParserColumnNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderGetParserLineNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the user data (XML reader context) */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderGetParserLineNumber(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderGetParserLineNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderGetParserProp(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
int prop; /* the xmlParserProperties to get */
|
|
int n_prop;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
prop = gen_int(n_prop, 1);
|
|
|
|
ret_val = xmlTextReaderGetParserProp(reader, prop);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_int(n_prop, prop, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderGetParserProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_prop);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderGetRemainder(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlParserInputBufferPtr ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderGetRemainder(reader);
|
|
desret_xmlParserInputBufferPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderGetRemainder",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderHasAttributes(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderHasAttributes(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderHasAttributes",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderHasValue(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderHasValue(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderHasValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderIsDefault(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderIsDefault(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderIsDefault",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderIsEmptyElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderIsEmptyElement(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderIsEmptyElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderIsNamespaceDecl(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderIsNamespaceDecl(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderIsNamespaceDecl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderIsValid(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderIsValid(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderIsValid",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderLocalName(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderLocalName(reader);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderLocalName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_READER_ENABLED
|
|
|
|
#define gen_nb_xmlTextReaderLocatorPtr 1
|
|
#define gen_xmlTextReaderLocatorPtr(no, nr) NULL
|
|
#define des_xmlTextReaderLocatorPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderLocatorBaseURI(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */
|
|
int n_locator;
|
|
|
|
for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) {
|
|
mem_base = xmlMemBlocks();
|
|
locator = gen_xmlTextReaderLocatorPtr(n_locator, 0);
|
|
|
|
ret_val = xmlTextReaderLocatorBaseURI(locator);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderLocatorPtr(n_locator, locator, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderLocatorBaseURI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_locator);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderLocatorLineNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */
|
|
int n_locator;
|
|
|
|
for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) {
|
|
mem_base = xmlMemBlocks();
|
|
locator = gen_xmlTextReaderLocatorPtr(n_locator, 0);
|
|
|
|
ret_val = xmlTextReaderLocatorLineNumber(locator);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderLocatorPtr(n_locator, locator, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderLocatorLineNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_locator);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderLookupNamespace(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
const xmlChar * prefix; /* the prefix whose namespace URI is to be resolved. To return the default namespace, specify NULL */
|
|
int n_prefix;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 1);
|
|
|
|
ret_val = xmlTextReaderLookupNamespace(reader, prefix);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderLookupNamespace",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_prefix);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderMoveToAttribute(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
const xmlChar * name; /* the qualified name of the attribute. */
|
|
int n_name;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlTextReaderMoveToAttribute(reader, name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderMoveToAttribute",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderMoveToAttributeNo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
int no; /* the zero-based index of the attribute relative to the containing element. */
|
|
int n_no;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_no = 0;n_no < gen_nb_int;n_no++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
no = gen_int(n_no, 1);
|
|
|
|
ret_val = xmlTextReaderMoveToAttributeNo(reader, no);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_int(n_no, no, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_no);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderMoveToAttributeNs(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
const xmlChar * localName; /* the local name of the attribute. */
|
|
int n_localName;
|
|
const xmlChar * namespaceURI; /* the namespace URI of the attribute. */
|
|
int n_namespaceURI;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
|
|
for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
localName = gen_const_xmlChar_ptr(n_localName, 1);
|
|
namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2);
|
|
|
|
ret_val = xmlTextReaderMoveToAttributeNs(reader, localName, namespaceURI);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_const_xmlChar_ptr(n_localName, localName, 1);
|
|
des_const_xmlChar_ptr(n_namespaceURI, namespaceURI, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_localName);
|
|
printf(" %d", n_namespaceURI);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderMoveToElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderMoveToElement(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderMoveToElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderMoveToFirstAttribute(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderMoveToFirstAttribute(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderMoveToFirstAttribute",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderMoveToNextAttribute(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderMoveToNextAttribute(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderMoveToNextAttribute",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderName(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderName(reader);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderNamespaceUri(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderNamespaceUri(reader);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderNamespaceUri",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderNext(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderNext(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderNext",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderNextSibling(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderNextSibling(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderNextSibling",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderNodeType(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderNodeType(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderNodeType",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderNormalization(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderNormalization(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderNormalization",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderPrefix(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderPrefix(reader);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderPrefix",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderPreserve(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderPreserve(reader);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderPreserve",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderPreservePattern(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED) && defined(LIBXML_PATTERN_ENABLED)
|
|
#ifdef LIBXML_PATTERN_ENABLED
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
const xmlChar * pattern; /* an XPath subset pattern */
|
|
int n_pattern;
|
|
const xmlChar ** namespaces; /* the prefix definitions, array of [URI, prefix] or NULL */
|
|
int n_namespaces;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_pattern = 0;n_pattern < gen_nb_const_xmlChar_ptr;n_pattern++) {
|
|
for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
pattern = gen_const_xmlChar_ptr(n_pattern, 1);
|
|
namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 2);
|
|
|
|
ret_val = xmlTextReaderPreservePattern(reader, pattern, namespaces);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_const_xmlChar_ptr(n_pattern, pattern, 1);
|
|
des_const_xmlChar_ptr_ptr(n_namespaces, namespaces, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderPreservePattern",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_pattern);
|
|
printf(" %d", n_namespaces);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderQuoteChar(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderQuoteChar(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderQuoteChar",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderRead(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderRead(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderRead",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderReadAttributeValue(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderReadAttributeValue(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderReadAttributeValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderReadState(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderReadState(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderReadState",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderRelaxNGSetSchema(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
xmlRelaxNGPtr schema; /* a precompiled RelaxNG schema */
|
|
int n_schema;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
schema = gen_xmlRelaxNGPtr(n_schema, 1);
|
|
|
|
ret_val = xmlTextReaderRelaxNGSetSchema(reader, schema);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_xmlRelaxNGPtr(n_schema, schema, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderRelaxNGSetSchema",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_schema);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderRelaxNGValidate(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
const char * rng; /* the path to a RelaxNG schema or NULL */
|
|
int n_rng;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_rng = 0;n_rng < gen_nb_const_char_ptr;n_rng++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
rng = gen_const_char_ptr(n_rng, 1);
|
|
|
|
ret_val = xmlTextReaderRelaxNGValidate(reader, rng);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_const_char_ptr(n_rng, rng, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidate",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_rng);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderRelaxNGValidateCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG schema validation context or NULL */
|
|
int n_ctxt;
|
|
int options; /* options (not used yet) */
|
|
int n_options;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 1);
|
|
options = gen_parseroptions(n_options, 2);
|
|
|
|
ret_val = xmlTextReaderRelaxNGValidateCtxt(reader, ctxt, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 1);
|
|
des_parseroptions(n_options, options, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidateCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderSchemaValidate(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
const char * xsd; /* the path to a W3C XSD schema or NULL */
|
|
int n_xsd;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_xsd = 0;n_xsd < gen_nb_const_char_ptr;n_xsd++) {
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
xsd = gen_const_char_ptr(n_xsd, 1);
|
|
|
|
ret_val = xmlTextReaderSchemaValidate(reader, xsd);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_const_char_ptr(n_xsd, xsd, 1);
|
|
xmlResetLastError();
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderSchemaValidateCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
xmlSchemaValidCtxtPtr ctxt; /* the XML Schema validation context or NULL */
|
|
int n_ctxt;
|
|
int options; /* options (not used yet) */
|
|
int n_options;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 1);
|
|
options = gen_parseroptions(n_options, 2);
|
|
|
|
ret_val = xmlTextReaderSchemaValidateCtxt(reader, ctxt, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 1);
|
|
des_parseroptions(n_options, options, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderSchemaValidateCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderSetErrorHandler(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderSetMaxAmplification(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderSetParserProp(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
int prop; /* the xmlParserProperties to set */
|
|
int n_prop;
|
|
int value; /* usually 0 or 1 to (de)activate it */
|
|
int n_value;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
|
|
for (n_value = 0;n_value < gen_nb_int;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
prop = gen_int(n_prop, 1);
|
|
value = gen_int(n_value, 2);
|
|
|
|
ret_val = xmlTextReaderSetParserProp(reader, prop, value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_int(n_prop, prop, 1);
|
|
des_int(n_value, value, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderSetParserProp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_prop);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderSetSchema(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
xmlSchemaPtr schema; /* a precompiled Schema schema */
|
|
int n_schema;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
schema = gen_xmlSchemaPtr(n_schema, 1);
|
|
|
|
ret_val = xmlTextReaderSetSchema(reader, schema);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_xmlSchemaPtr(n_schema, schema, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderSetSchema",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_schema);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderSetStructuredErrorHandler(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderSetup(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* an XML reader */
|
|
int n_reader;
|
|
xmlParserInputBufferPtr input; /* xmlParserInputBufferPtr used to feed the reader, will be destroyed with it. */
|
|
int n_input;
|
|
const char * URL; /* the base URL to use for the document */
|
|
int n_URL;
|
|
const char * encoding; /* the document encoding, or NULL */
|
|
int n_encoding;
|
|
int options; /* a combination of xmlParserOption */
|
|
int n_options;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
|
|
for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
input = gen_xmlParserInputBufferPtr(n_input, 1);
|
|
URL = gen_filepath(n_URL, 2);
|
|
encoding = gen_const_char_ptr(n_encoding, 3);
|
|
options = gen_parseroptions(n_options, 4);
|
|
|
|
ret_val = xmlTextReaderSetup(reader, input, URL, encoding, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
des_filepath(n_URL, URL, 2);
|
|
des_const_char_ptr(n_encoding, encoding, 3);
|
|
des_parseroptions(n_options, options, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderSetup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf(" %d", n_input);
|
|
printf(" %d", n_URL);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderStandalone(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderStandalone(reader);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderStandalone",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderValue(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderValue(reader);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextReaderXmlLang(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_READER_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
|
|
int n_reader;
|
|
|
|
for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
|
|
mem_base = xmlMemBlocks();
|
|
reader = gen_xmlTextReaderPtr(n_reader, 0);
|
|
|
|
ret_val = xmlTextReaderXmlLang(reader);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlTextReaderPtr(n_reader, reader, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextReaderXmlLang",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_reader);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlreader(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xmlreader : 76 of 87 functions ...\n");
|
|
test_ret += test_xmlNewTextReader();
|
|
test_ret += test_xmlNewTextReaderFilename();
|
|
test_ret += test_xmlReaderForDoc();
|
|
test_ret += test_xmlReaderForFile();
|
|
test_ret += test_xmlReaderForMemory();
|
|
test_ret += test_xmlReaderNewDoc();
|
|
test_ret += test_xmlReaderNewFile();
|
|
test_ret += test_xmlReaderNewMemory();
|
|
test_ret += test_xmlReaderNewWalker();
|
|
test_ret += test_xmlReaderWalker();
|
|
test_ret += test_xmlTextReaderAttributeCount();
|
|
test_ret += test_xmlTextReaderBaseUri();
|
|
test_ret += test_xmlTextReaderByteConsumed();
|
|
test_ret += test_xmlTextReaderClose();
|
|
test_ret += test_xmlTextReaderConstBaseUri();
|
|
test_ret += test_xmlTextReaderConstEncoding();
|
|
test_ret += test_xmlTextReaderConstLocalName();
|
|
test_ret += test_xmlTextReaderConstName();
|
|
test_ret += test_xmlTextReaderConstNamespaceUri();
|
|
test_ret += test_xmlTextReaderConstPrefix();
|
|
test_ret += test_xmlTextReaderConstString();
|
|
test_ret += test_xmlTextReaderConstValue();
|
|
test_ret += test_xmlTextReaderConstXmlLang();
|
|
test_ret += test_xmlTextReaderConstXmlVersion();
|
|
test_ret += test_xmlTextReaderCurrentDoc();
|
|
test_ret += test_xmlTextReaderCurrentNode();
|
|
test_ret += test_xmlTextReaderDepth();
|
|
test_ret += test_xmlTextReaderExpand();
|
|
test_ret += test_xmlTextReaderGetAttribute();
|
|
test_ret += test_xmlTextReaderGetAttributeNo();
|
|
test_ret += test_xmlTextReaderGetAttributeNs();
|
|
test_ret += test_xmlTextReaderGetErrorHandler();
|
|
test_ret += test_xmlTextReaderGetParserColumnNumber();
|
|
test_ret += test_xmlTextReaderGetParserLineNumber();
|
|
test_ret += test_xmlTextReaderGetParserProp();
|
|
test_ret += test_xmlTextReaderGetRemainder();
|
|
test_ret += test_xmlTextReaderHasAttributes();
|
|
test_ret += test_xmlTextReaderHasValue();
|
|
test_ret += test_xmlTextReaderIsDefault();
|
|
test_ret += test_xmlTextReaderIsEmptyElement();
|
|
test_ret += test_xmlTextReaderIsNamespaceDecl();
|
|
test_ret += test_xmlTextReaderIsValid();
|
|
test_ret += test_xmlTextReaderLocalName();
|
|
test_ret += test_xmlTextReaderLocatorBaseURI();
|
|
test_ret += test_xmlTextReaderLocatorLineNumber();
|
|
test_ret += test_xmlTextReaderLookupNamespace();
|
|
test_ret += test_xmlTextReaderMoveToAttribute();
|
|
test_ret += test_xmlTextReaderMoveToAttributeNo();
|
|
test_ret += test_xmlTextReaderMoveToAttributeNs();
|
|
test_ret += test_xmlTextReaderMoveToElement();
|
|
test_ret += test_xmlTextReaderMoveToFirstAttribute();
|
|
test_ret += test_xmlTextReaderMoveToNextAttribute();
|
|
test_ret += test_xmlTextReaderName();
|
|
test_ret += test_xmlTextReaderNamespaceUri();
|
|
test_ret += test_xmlTextReaderNext();
|
|
test_ret += test_xmlTextReaderNextSibling();
|
|
test_ret += test_xmlTextReaderNodeType();
|
|
test_ret += test_xmlTextReaderNormalization();
|
|
test_ret += test_xmlTextReaderPrefix();
|
|
test_ret += test_xmlTextReaderPreserve();
|
|
test_ret += test_xmlTextReaderPreservePattern();
|
|
test_ret += test_xmlTextReaderQuoteChar();
|
|
test_ret += test_xmlTextReaderRead();
|
|
test_ret += test_xmlTextReaderReadAttributeValue();
|
|
test_ret += test_xmlTextReaderReadState();
|
|
test_ret += test_xmlTextReaderRelaxNGSetSchema();
|
|
test_ret += test_xmlTextReaderRelaxNGValidate();
|
|
test_ret += test_xmlTextReaderRelaxNGValidateCtxt();
|
|
test_ret += test_xmlTextReaderSchemaValidate();
|
|
test_ret += test_xmlTextReaderSchemaValidateCtxt();
|
|
test_ret += test_xmlTextReaderSetErrorHandler();
|
|
test_ret += test_xmlTextReaderSetMaxAmplification();
|
|
test_ret += test_xmlTextReaderSetParserProp();
|
|
test_ret += test_xmlTextReaderSetSchema();
|
|
test_ret += test_xmlTextReaderSetStructuredErrorHandler();
|
|
test_ret += test_xmlTextReaderSetup();
|
|
test_ret += test_xmlTextReaderStandalone();
|
|
test_ret += test_xmlTextReaderValue();
|
|
test_ret += test_xmlTextReaderXmlLang();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xmlreader: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlExpCtxtNbCons(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlExpCtxtPtr ctxt; /* an expression context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlExpCtxtNbCons(ctxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlExpCtxtNbCons",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpCtxtNbNodes(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlExpCtxtPtr ctxt; /* an expression context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlExpCtxtNbNodes(ctxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlExpCtxtNbNodes",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpDump(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
|
|
int mem_base;
|
|
xmlBufferPtr buf; /* a buffer to receive the output */
|
|
int n_buf;
|
|
xmlExpNodePtr expr; /* the compiled expression */
|
|
int n_expr;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
expr = gen_xmlExpNodePtr(n_expr, 1);
|
|
|
|
xmlExpDump(buf, expr);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_xmlExpNodePtr(n_expr, expr, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlExpDump",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_expr);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpExpDerive(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpGetLanguage(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlExpCtxtPtr ctxt; /* the expression context */
|
|
int n_ctxt;
|
|
xmlExpNodePtr exp; /* the expression */
|
|
int n_exp;
|
|
const xmlChar ** langList; /* where to store the tokens */
|
|
int n_langList;
|
|
int len; /* the allocated length of @list */
|
|
int n_len;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
|
|
for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
|
|
for (n_langList = 0;n_langList < gen_nb_const_xmlChar_ptr_ptr;n_langList++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
|
|
exp = gen_xmlExpNodePtr(n_exp, 1);
|
|
langList = gen_const_xmlChar_ptr_ptr(n_langList, 2);
|
|
len = gen_int(n_len, 3);
|
|
|
|
ret_val = xmlExpGetLanguage(ctxt, exp, langList, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlExpNodePtr(n_exp, exp, 1);
|
|
des_const_xmlChar_ptr_ptr(n_langList, langList, 2);
|
|
des_int(n_len, len, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlExpGetLanguage",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_exp);
|
|
printf(" %d", n_langList);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpGetStart(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlExpCtxtPtr ctxt; /* the expression context */
|
|
int n_ctxt;
|
|
xmlExpNodePtr exp; /* the expression */
|
|
int n_exp;
|
|
const xmlChar ** tokList; /* where to store the tokens */
|
|
int n_tokList;
|
|
int len; /* the allocated length of @list */
|
|
int n_len;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
|
|
for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
|
|
for (n_tokList = 0;n_tokList < gen_nb_const_xmlChar_ptr_ptr;n_tokList++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
|
|
exp = gen_xmlExpNodePtr(n_exp, 1);
|
|
tokList = gen_const_xmlChar_ptr_ptr(n_tokList, 2);
|
|
len = gen_int(n_len, 3);
|
|
|
|
ret_val = xmlExpGetStart(ctxt, exp, tokList, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlExpNodePtr(n_exp, exp, 1);
|
|
des_const_xmlChar_ptr_ptr(n_tokList, tokList, 2);
|
|
des_int(n_len, len, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlExpGetStart",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_exp);
|
|
printf(" %d", n_tokList);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpIsNillable(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlExpNodePtr exp; /* the expression */
|
|
int n_exp;
|
|
|
|
for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
|
|
mem_base = xmlMemBlocks();
|
|
exp = gen_xmlExpNodePtr(n_exp, 0);
|
|
|
|
ret_val = xmlExpIsNillable(exp);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlExpNodePtr(n_exp, exp, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlExpIsNillable",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_exp);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpMaxToken(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlExpNodePtr expr; /* a compiled expression */
|
|
int n_expr;
|
|
|
|
for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) {
|
|
mem_base = xmlMemBlocks();
|
|
expr = gen_xmlExpNodePtr(n_expr, 0);
|
|
|
|
ret_val = xmlExpMaxToken(expr);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlExpNodePtr(n_expr, expr, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlExpMaxToken",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_expr);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpNewAtom(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpNewCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpNewOr(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpNewRange(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpNewSeq(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpParse(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpRef(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
|
|
int mem_base;
|
|
xmlExpNodePtr exp; /* the expression */
|
|
int n_exp;
|
|
|
|
for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
|
|
mem_base = xmlMemBlocks();
|
|
exp = gen_xmlExpNodePtr(n_exp, 0);
|
|
|
|
xmlExpRef(exp);
|
|
call_tests++;
|
|
des_xmlExpNodePtr(n_exp, exp, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlExpRef",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_exp);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpStringDerive(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlExpSubsume(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlExpCtxtPtr ctxt; /* the expressions context */
|
|
int n_ctxt;
|
|
xmlExpNodePtr exp; /* the englobing expression */
|
|
int n_exp;
|
|
xmlExpNodePtr sub; /* the subexpression */
|
|
int n_sub;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
|
|
for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
|
|
for (n_sub = 0;n_sub < gen_nb_xmlExpNodePtr;n_sub++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
|
|
exp = gen_xmlExpNodePtr(n_exp, 1);
|
|
sub = gen_xmlExpNodePtr(n_sub, 2);
|
|
|
|
ret_val = xmlExpSubsume(ctxt, exp, sub);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlExpNodePtr(n_exp, exp, 1);
|
|
des_xmlExpNodePtr(n_sub, sub, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlExpSubsume",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_exp);
|
|
printf(" %d", n_sub);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_REGEXP_ENABLED
|
|
|
|
#define gen_nb_xmlRegExecCtxtPtr 1
|
|
#define gen_xmlRegExecCtxtPtr(no, nr) NULL
|
|
#define des_xmlRegExecCtxtPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlRegExecErrInfo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRegExecCtxtPtr exec; /* a regexp execution context generating an error */
|
|
int n_exec;
|
|
const xmlChar ** string; /* return value for the error string */
|
|
int n_string;
|
|
int * nbval; /* pointer to the number of accepted values IN/OUT */
|
|
int n_nbval;
|
|
int * nbneg; /* return number of negative transitions */
|
|
int n_nbneg;
|
|
xmlChar ** values; /* pointer to the array of acceptable values */
|
|
int n_values;
|
|
int * terminal; /* return value if this was a terminal state */
|
|
int n_terminal;
|
|
|
|
for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
|
|
for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr_ptr;n_string++) {
|
|
for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) {
|
|
for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) {
|
|
for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) {
|
|
for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) {
|
|
mem_base = xmlMemBlocks();
|
|
exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
|
|
string = gen_const_xmlChar_ptr_ptr(n_string, 1);
|
|
nbval = gen_int_ptr(n_nbval, 2);
|
|
nbneg = gen_int_ptr(n_nbneg, 3);
|
|
values = gen_xmlChar_ptr_ptr(n_values, 4);
|
|
terminal = gen_int_ptr(n_terminal, 5);
|
|
|
|
ret_val = xmlRegExecErrInfo(exec, string, nbval, nbneg, values, terminal);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRegExecCtxtPtr(n_exec, exec, 0);
|
|
des_const_xmlChar_ptr_ptr(n_string, string, 1);
|
|
des_int_ptr(n_nbval, nbval, 2);
|
|
des_int_ptr(n_nbneg, nbneg, 3);
|
|
des_xmlChar_ptr_ptr(n_values, values, 4);
|
|
des_int_ptr(n_terminal, terminal, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRegExecErrInfo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_exec);
|
|
printf(" %d", n_string);
|
|
printf(" %d", n_nbval);
|
|
printf(" %d", n_nbneg);
|
|
printf(" %d", n_values);
|
|
printf(" %d", n_terminal);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRegExecNextValues(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRegExecCtxtPtr exec; /* a regexp execution context */
|
|
int n_exec;
|
|
int * nbval; /* pointer to the number of accepted values IN/OUT */
|
|
int n_nbval;
|
|
int * nbneg; /* return number of negative transitions */
|
|
int n_nbneg;
|
|
xmlChar ** values; /* pointer to the array of acceptable values */
|
|
int n_values;
|
|
int * terminal; /* return value if this was a terminal state */
|
|
int n_terminal;
|
|
|
|
for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
|
|
for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) {
|
|
for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) {
|
|
for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) {
|
|
for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) {
|
|
mem_base = xmlMemBlocks();
|
|
exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
|
|
nbval = gen_int_ptr(n_nbval, 1);
|
|
nbneg = gen_int_ptr(n_nbneg, 2);
|
|
values = gen_xmlChar_ptr_ptr(n_values, 3);
|
|
terminal = gen_int_ptr(n_terminal, 4);
|
|
|
|
ret_val = xmlRegExecNextValues(exec, nbval, nbneg, values, terminal);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRegExecCtxtPtr(n_exec, exec, 0);
|
|
des_int_ptr(n_nbval, nbval, 1);
|
|
des_int_ptr(n_nbneg, nbneg, 2);
|
|
des_xmlChar_ptr_ptr(n_values, values, 3);
|
|
des_int_ptr(n_terminal, terminal, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRegExecNextValues",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_exec);
|
|
printf(" %d", n_nbval);
|
|
printf(" %d", n_nbneg);
|
|
printf(" %d", n_values);
|
|
printf(" %d", n_terminal);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRegExecPushString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */
|
|
int n_exec;
|
|
const xmlChar * value; /* a string token input */
|
|
int n_value;
|
|
void * data; /* data associated to the token to reuse in callbacks */
|
|
int n_data;
|
|
|
|
for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
data = gen_userdata(n_data, 2);
|
|
|
|
ret_val = xmlRegExecPushString(exec, value, data);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRegExecCtxtPtr(n_exec, exec, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
des_userdata(n_data, data, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRegExecPushString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_exec);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRegExecPushString2(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */
|
|
int n_exec;
|
|
const xmlChar * value; /* the first string token input */
|
|
int n_value;
|
|
const xmlChar * value2; /* the second string token input */
|
|
int n_value2;
|
|
void * data; /* data associated to the token to reuse in callbacks */
|
|
int n_data;
|
|
|
|
for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_value2 = 0;n_value2 < gen_nb_const_xmlChar_ptr;n_value2++) {
|
|
for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
value2 = gen_const_xmlChar_ptr(n_value2, 2);
|
|
data = gen_userdata(n_data, 3);
|
|
|
|
ret_val = xmlRegExecPushString2(exec, value, value2, data);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRegExecCtxtPtr(n_exec, exec, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
des_const_xmlChar_ptr(n_value2, value2, 2);
|
|
des_userdata(n_data, data, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRegExecPushString2",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_exec);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_value2);
|
|
printf(" %d", n_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRegNewExecCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRegexpCompile(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_REGEXP_ENABLED
|
|
|
|
#define gen_nb_xmlRegexpPtr 1
|
|
#define gen_xmlRegexpPtr(no, nr) NULL
|
|
#define des_xmlRegexpPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlRegexpExec(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRegexpPtr comp; /* the compiled regular expression */
|
|
int n_comp;
|
|
const xmlChar * content; /* the value to check against the regular expression */
|
|
int n_content;
|
|
|
|
for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
comp = gen_xmlRegexpPtr(n_comp, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
|
|
ret_val = xmlRegexpExec(comp, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRegexpPtr(n_comp, comp, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRegexpExec",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_comp);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRegexpIsDeterminist(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlRegexpPtr comp; /* the compiled regular expression */
|
|
int n_comp;
|
|
|
|
for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) {
|
|
mem_base = xmlMemBlocks();
|
|
comp = gen_xmlRegexpPtr(n_comp, 0);
|
|
|
|
ret_val = xmlRegexpIsDeterminist(comp);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlRegexpPtr(n_comp, comp, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRegexpIsDeterminist",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_comp);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlRegexpPrint(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_REGEXP_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the file for the output debug */
|
|
int n_output;
|
|
xmlRegexpPtr regexp; /* the compiled regexp */
|
|
int n_regexp;
|
|
|
|
for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
|
|
for (n_regexp = 0;n_regexp < gen_nb_xmlRegexpPtr;n_regexp++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_FILE_ptr(n_output, 0);
|
|
regexp = gen_xmlRegexpPtr(n_regexp, 1);
|
|
|
|
xmlRegexpPrint(output, regexp);
|
|
call_tests++;
|
|
des_FILE_ptr(n_output, output, 0);
|
|
des_xmlRegexpPtr(n_regexp, regexp, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlRegexpPrint",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_regexp);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlregexp(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xmlregexp : 16 of 30 functions ...\n");
|
|
test_ret += test_xmlExpCtxtNbCons();
|
|
test_ret += test_xmlExpCtxtNbNodes();
|
|
test_ret += test_xmlExpDump();
|
|
test_ret += test_xmlExpExpDerive();
|
|
test_ret += test_xmlExpGetLanguage();
|
|
test_ret += test_xmlExpGetStart();
|
|
test_ret += test_xmlExpIsNillable();
|
|
test_ret += test_xmlExpMaxToken();
|
|
test_ret += test_xmlExpNewAtom();
|
|
test_ret += test_xmlExpNewCtxt();
|
|
test_ret += test_xmlExpNewOr();
|
|
test_ret += test_xmlExpNewRange();
|
|
test_ret += test_xmlExpNewSeq();
|
|
test_ret += test_xmlExpParse();
|
|
test_ret += test_xmlExpRef();
|
|
test_ret += test_xmlExpStringDerive();
|
|
test_ret += test_xmlExpSubsume();
|
|
test_ret += test_xmlRegExecErrInfo();
|
|
test_ret += test_xmlRegExecNextValues();
|
|
test_ret += test_xmlRegExecPushString();
|
|
test_ret += test_xmlRegExecPushString2();
|
|
test_ret += test_xmlRegNewExecCtxt();
|
|
test_ret += test_xmlRegexpCompile();
|
|
test_ret += test_xmlRegexpExec();
|
|
test_ret += test_xmlRegexpIsDeterminist();
|
|
test_ret += test_xmlRegexpPrint();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xmlregexp: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
#ifdef LIBXML_OUTPUT_ENABLED
|
|
|
|
#define gen_nb_xmlSaveCtxtPtr 1
|
|
#define gen_xmlSaveCtxtPtr(no, nr) NULL
|
|
#define des_xmlSaveCtxtPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlSaveClose(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSaveCtxtPtr ctxt; /* a document saving context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlSaveClose(ctxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSaveClose",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
long ret_val;
|
|
xmlSaveCtxtPtr ctxt; /* a document saving context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a document */
|
|
int n_doc;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
|
|
ret_val = xmlSaveDoc(ctxt, doc);
|
|
desret_long(ret_val);
|
|
call_tests++;
|
|
des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSaveDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveFlush(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSaveCtxtPtr ctxt; /* a document saving context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlSaveFlush(ctxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSaveFlush",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveSetAttrEscape(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveSetEscape(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveToBuffer(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveToFd(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveToFilename(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSaveTree(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
long ret_val;
|
|
xmlSaveCtxtPtr ctxt; /* a document saving context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the top node of the subtree to save */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlSaveTree(ctxt, cur);
|
|
desret_long(ret_val);
|
|
call_tests++;
|
|
des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSaveTree",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefIndentTreeOutput(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_int;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_int(n_v, 0);
|
|
|
|
ret_val = xmlThrDefIndentTreeOutput(v);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefIndentTreeOutput",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefSaveNoEmptyTags(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_int;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_int(n_v, 0);
|
|
|
|
ret_val = xmlThrDefSaveNoEmptyTags(v);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefSaveNoEmptyTags",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlThrDefTreeIndentString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
const char * ret_val;
|
|
const char * v; /* */
|
|
int n_v;
|
|
|
|
for (n_v = 0;n_v < gen_nb_const_char_ptr;n_v++) {
|
|
mem_base = xmlMemBlocks();
|
|
v = gen_const_char_ptr(n_v, 0);
|
|
|
|
ret_val = xmlThrDefTreeIndentString(v);
|
|
desret_const_char_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_v, v, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlThrDefTreeIndentString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_v);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlsave(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xmlsave : 7 of 13 functions ...\n");
|
|
test_ret += test_xmlSaveClose();
|
|
test_ret += test_xmlSaveDoc();
|
|
test_ret += test_xmlSaveFlush();
|
|
test_ret += test_xmlSaveSetAttrEscape();
|
|
test_ret += test_xmlSaveSetEscape();
|
|
test_ret += test_xmlSaveToBuffer();
|
|
test_ret += test_xmlSaveToFd();
|
|
test_ret += test_xmlSaveToFilename();
|
|
test_ret += test_xmlSaveTree();
|
|
test_ret += test_xmlThrDefIndentTreeOutput();
|
|
test_ret += test_xmlThrDefSaveNoEmptyTags();
|
|
test_ret += test_xmlThrDefTreeIndentString();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xmlsave: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlSchemaDump(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the file output */
|
|
int n_output;
|
|
xmlSchemaPtr schema; /* a schema structure */
|
|
int n_schema;
|
|
|
|
for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
|
|
for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_FILE_ptr(n_output, 0);
|
|
schema = gen_xmlSchemaPtr(n_schema, 1);
|
|
|
|
xmlSchemaDump(output, schema);
|
|
call_tests++;
|
|
des_FILE_ptr(n_output, output, 0);
|
|
des_xmlSchemaPtr(n_schema, schema, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaDump",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_schema);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlSchemaParserCtxtPtr 1
|
|
#define gen_xmlSchemaParserCtxtPtr(no, nr) NULL
|
|
#define des_xmlSchemaParserCtxtPtr(no, val, nr)
|
|
#endif
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlSchemaValidityErrorFunc_ptr 1
|
|
#define gen_xmlSchemaValidityErrorFunc_ptr(no, nr) NULL
|
|
#define des_xmlSchemaValidityErrorFunc_ptr(no, val, nr)
|
|
#endif
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlSchemaValidityWarningFunc_ptr 1
|
|
#define gen_xmlSchemaValidityWarningFunc_ptr(no, nr) NULL
|
|
#define des_xmlSchemaValidityWarningFunc_ptr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlSchemaGetParserErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaParserCtxtPtr ctxt; /* a XMl-Schema parser context */
|
|
int n_ctxt;
|
|
xmlSchemaValidityErrorFunc * err; /* the error callback result */
|
|
int n_err;
|
|
xmlSchemaValidityWarningFunc * warn; /* the warning callback result */
|
|
int n_warn;
|
|
void ** ctx; /* contextual data for the callbacks result */
|
|
int n_ctx;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaParserCtxtPtr;n_ctxt++) {
|
|
for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) {
|
|
for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) {
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSchemaParserCtxtPtr(n_ctxt, 0);
|
|
err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1);
|
|
warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2);
|
|
ctx = gen_void_ptr_ptr(n_ctx, 3);
|
|
|
|
ret_val = xmlSchemaGetParserErrors(ctxt, err, warn, ctx);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1);
|
|
des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2);
|
|
des_void_ptr_ptr(n_ctx, ctx, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaGetParserErrors",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_err);
|
|
printf(" %d", n_warn);
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaGetValidErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValidCtxtPtr ctxt; /* a XML-Schema validation context */
|
|
int n_ctxt;
|
|
xmlSchemaValidityErrorFunc * err; /* the error function result */
|
|
int n_err;
|
|
xmlSchemaValidityWarningFunc * warn; /* the warning function result */
|
|
int n_warn;
|
|
void ** ctx; /* the functions context result */
|
|
int n_ctx;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
|
|
for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) {
|
|
for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) {
|
|
for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
|
|
err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1);
|
|
warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2);
|
|
ctx = gen_void_ptr_ptr(n_ctx, 3);
|
|
|
|
ret_val = xmlSchemaGetValidErrors(ctxt, err, warn, ctx);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1);
|
|
des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2);
|
|
des_void_ptr_ptr(n_ctx, ctx, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaGetValidErrors",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_err);
|
|
printf(" %d", n_warn);
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaIsValid(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValidCtxtPtr ctxt; /* the schema validation context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlSchemaIsValid(ctxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaIsValid",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaNewDocParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlSchemaParserCtxtPtr ret_val;
|
|
xmlDocPtr doc; /* a preparsed document tree */
|
|
int n_doc;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
|
|
ret_val = xmlSchemaNewDocParserCtxt(doc);
|
|
desret_xmlSchemaParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaNewDocParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaNewMemParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlSchemaParserCtxtPtr ret_val;
|
|
const char * buffer; /* a pointer to a char array containing the schemas */
|
|
int n_buffer;
|
|
int size; /* the size of the array */
|
|
int n_size;
|
|
|
|
for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
|
|
for (n_size = 0;n_size < gen_nb_int;n_size++) {
|
|
mem_base = xmlMemBlocks();
|
|
buffer = gen_const_char_ptr(n_buffer, 0);
|
|
size = gen_int(n_size, 1);
|
|
if ((buffer != NULL) &&
|
|
(size > xmlStrlen(BAD_CAST buffer)))
|
|
size = 0;
|
|
|
|
ret_val = xmlSchemaNewMemParserCtxt(buffer, size);
|
|
desret_xmlSchemaParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_buffer, buffer, 0);
|
|
des_int(n_size, size, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaNewMemParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buffer);
|
|
printf(" %d", n_size);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaNewParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlSchemaParserCtxtPtr ret_val;
|
|
const char * URL; /* the location of the schema */
|
|
int n_URL;
|
|
|
|
for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) {
|
|
mem_base = xmlMemBlocks();
|
|
URL = gen_const_char_ptr(n_URL, 0);
|
|
|
|
ret_val = xmlSchemaNewParserCtxt(URL);
|
|
desret_xmlSchemaParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_URL, URL, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaNewParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_URL);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaNewValidCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaParse(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaSAXPlug(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlSchemaSAXPlugPtr 1
|
|
#define gen_xmlSchemaSAXPlugPtr(no, nr) NULL
|
|
#define des_xmlSchemaSAXPlugPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlSchemaSAXUnplug(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaSAXPlugPtr plug; /* a data structure returned by xmlSchemaSAXPlug */
|
|
int n_plug;
|
|
|
|
for (n_plug = 0;n_plug < gen_nb_xmlSchemaSAXPlugPtr;n_plug++) {
|
|
mem_base = xmlMemBlocks();
|
|
plug = gen_xmlSchemaSAXPlugPtr(n_plug, 0);
|
|
|
|
ret_val = xmlSchemaSAXUnplug(plug);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaSAXPlugPtr(n_plug, plug, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaSAXUnplug",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_plug);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaSetParserErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaSetParserStructuredErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaSetValidErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaSetValidOptions(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
|
|
int n_ctxt;
|
|
int options; /* a combination of xmlSchemaValidOption */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
|
|
options = gen_int(n_options, 1);
|
|
|
|
ret_val = xmlSchemaSetValidOptions(ctxt, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_options, options, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaSetValidOptions",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaSetValidStructuredErrors(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidCtxtGetOptions(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlSchemaValidCtxtGetOptions(ctxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidCtxtGetOptions",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidCtxtGetParserCtxt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlParserCtxtPtr ret_val;
|
|
xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlSchemaValidCtxtGetParserCtxt(ctxt);
|
|
desret_xmlParserCtxtPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidCtxtGetParserCtxt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidateDoc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
|
|
int n_ctxt;
|
|
xmlDocPtr doc; /* a parsed document tree */
|
|
int n_doc;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
|
|
doc = gen_xmlDocPtr(n_doc, 1);
|
|
|
|
ret_val = xmlSchemaValidateDoc(ctxt, doc);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlDocPtr(n_doc, doc, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidateDoc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidateFile(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
|
|
int n_ctxt;
|
|
const char * filename; /* the URI of the instance */
|
|
int n_filename;
|
|
int options; /* a future set of options, currently unused */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
|
|
filename = gen_filepath(n_filename, 1);
|
|
options = gen_int(n_options, 2);
|
|
|
|
ret_val = xmlSchemaValidateFile(ctxt, filename, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_filepath(n_filename, filename, 1);
|
|
des_int(n_options, options, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidateFile",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_filename);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidateOneElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
|
|
int n_ctxt;
|
|
xmlNodePtr elem; /* an element node */
|
|
int n_elem;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
|
|
for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
|
|
elem = gen_xmlNodePtr(n_elem, 1);
|
|
|
|
ret_val = xmlSchemaValidateOneElement(ctxt, elem);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_elem, elem, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidateOneElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_elem);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidateSetFilename(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlSchemaValidCtxtPtr vctxt; /* the schema validation context */
|
|
int n_vctxt;
|
|
const char * filename; /* the file name */
|
|
int n_filename;
|
|
|
|
for (n_vctxt = 0;n_vctxt < gen_nb_xmlSchemaValidCtxtPtr;n_vctxt++) {
|
|
for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
|
|
mem_base = xmlMemBlocks();
|
|
vctxt = gen_xmlSchemaValidCtxtPtr(n_vctxt, 0);
|
|
filename = gen_filepath(n_filename, 1);
|
|
|
|
xmlSchemaValidateSetFilename(vctxt, filename);
|
|
call_tests++;
|
|
des_xmlSchemaValidCtxtPtr(n_vctxt, vctxt, 0);
|
|
des_filepath(n_filename, filename, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidateSetFilename",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_vctxt);
|
|
printf(" %d", n_filename);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidateSetLocator(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidateStream(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
|
|
int n_ctxt;
|
|
xmlParserInputBufferPtr input; /* the input to use for reading the data */
|
|
int n_input;
|
|
xmlCharEncoding enc; /* an optional encoding information */
|
|
int n_enc;
|
|
xmlSAXHandlerPtr sax; /* a SAX handler for the resulting events */
|
|
int n_sax;
|
|
void * user_data; /* the context to provide to the SAX handler. */
|
|
int n_user_data;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
|
|
for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
|
|
for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
|
|
for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
|
|
for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
|
|
input = gen_xmlParserInputBufferPtr(n_input, 1);
|
|
enc = gen_xmlCharEncoding(n_enc, 2);
|
|
sax = gen_xmlSAXHandlerPtr(n_sax, 3);
|
|
user_data = gen_userdata(n_user_data, 4);
|
|
|
|
ret_val = xmlSchemaValidateStream(ctxt, input, enc, sax, user_data);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_xmlParserInputBufferPtr(n_input, input, 1);
|
|
des_xmlCharEncoding(n_enc, enc, 2);
|
|
des_xmlSAXHandlerPtr(n_sax, sax, 3);
|
|
des_userdata(n_user_data, user_data, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidateStream",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_input);
|
|
printf(" %d", n_enc);
|
|
printf(" %d", n_sax);
|
|
printf(" %d", n_user_data);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlschemas(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xmlschemas : 16 of 27 functions ...\n");
|
|
test_ret += test_xmlSchemaDump();
|
|
test_ret += test_xmlSchemaGetParserErrors();
|
|
test_ret += test_xmlSchemaGetValidErrors();
|
|
test_ret += test_xmlSchemaIsValid();
|
|
test_ret += test_xmlSchemaNewDocParserCtxt();
|
|
test_ret += test_xmlSchemaNewMemParserCtxt();
|
|
test_ret += test_xmlSchemaNewParserCtxt();
|
|
test_ret += test_xmlSchemaNewValidCtxt();
|
|
test_ret += test_xmlSchemaParse();
|
|
test_ret += test_xmlSchemaSAXPlug();
|
|
test_ret += test_xmlSchemaSAXUnplug();
|
|
test_ret += test_xmlSchemaSetParserErrors();
|
|
test_ret += test_xmlSchemaSetParserStructuredErrors();
|
|
test_ret += test_xmlSchemaSetValidErrors();
|
|
test_ret += test_xmlSchemaSetValidOptions();
|
|
test_ret += test_xmlSchemaSetValidStructuredErrors();
|
|
test_ret += test_xmlSchemaValidCtxtGetOptions();
|
|
test_ret += test_xmlSchemaValidCtxtGetParserCtxt();
|
|
test_ret += test_xmlSchemaValidateDoc();
|
|
test_ret += test_xmlSchemaValidateFile();
|
|
test_ret += test_xmlSchemaValidateOneElement();
|
|
test_ret += test_xmlSchemaValidateSetFilename();
|
|
test_ret += test_xmlSchemaValidateSetLocator();
|
|
test_ret += test_xmlSchemaValidateStream();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xmlschemas: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlSchemaFacetPtr 1
|
|
#define gen_xmlSchemaFacetPtr(no, nr) NULL
|
|
#define des_xmlSchemaFacetPtr(no, val, nr)
|
|
#endif
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlSchemaTypePtr 1
|
|
#define gen_xmlSchemaTypePtr(no, nr) NULL
|
|
#define des_xmlSchemaTypePtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlSchemaCheckFacet(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaFacetPtr facet; /* the facet */
|
|
int n_facet;
|
|
xmlSchemaTypePtr typeDecl; /* the schema type definition */
|
|
int n_typeDecl;
|
|
xmlSchemaParserCtxtPtr pctxt; /* the schema parser context or NULL */
|
|
int n_pctxt;
|
|
const xmlChar * name; /* the optional name of the type */
|
|
int n_name;
|
|
|
|
for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
|
|
for (n_typeDecl = 0;n_typeDecl < gen_nb_xmlSchemaTypePtr;n_typeDecl++) {
|
|
for (n_pctxt = 0;n_pctxt < gen_nb_xmlSchemaParserCtxtPtr;n_pctxt++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
facet = gen_xmlSchemaFacetPtr(n_facet, 0);
|
|
typeDecl = gen_xmlSchemaTypePtr(n_typeDecl, 1);
|
|
pctxt = gen_xmlSchemaParserCtxtPtr(n_pctxt, 2);
|
|
name = gen_const_xmlChar_ptr(n_name, 3);
|
|
|
|
ret_val = xmlSchemaCheckFacet(facet, typeDecl, pctxt, name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaFacetPtr(n_facet, facet, 0);
|
|
des_xmlSchemaTypePtr(n_typeDecl, typeDecl, 1);
|
|
des_xmlSchemaParserCtxtPtr(n_pctxt, pctxt, 2);
|
|
des_const_xmlChar_ptr(n_name, name, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaCheckFacet",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_facet);
|
|
printf(" %d", n_typeDecl);
|
|
printf(" %d", n_pctxt);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaCleanupTypes(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
|
|
|
|
xmlSchemaCleanupTypes();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaCollapseString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * value; /* a value */
|
|
int n_value;
|
|
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
value = gen_const_xmlChar_ptr(n_value, 0);
|
|
|
|
ret_val = xmlSchemaCollapseString(value);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_value, value, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaCollapseString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlSchemaValPtr 1
|
|
#define gen_xmlSchemaValPtr(no, nr) NULL
|
|
#define des_xmlSchemaValPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlSchemaCompareValues(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValPtr x; /* a first value */
|
|
int n_x;
|
|
xmlSchemaValPtr y; /* a second value */
|
|
int n_y;
|
|
|
|
for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) {
|
|
for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) {
|
|
mem_base = xmlMemBlocks();
|
|
x = gen_xmlSchemaValPtr(n_x, 0);
|
|
y = gen_xmlSchemaValPtr(n_y, 1);
|
|
|
|
ret_val = xmlSchemaCompareValues(x, y);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValPtr(n_x, x, 0);
|
|
des_xmlSchemaValPtr(n_y, y, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaCompareValues",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_x);
|
|
printf(" %d", n_y);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaCompareValuesWhtsp(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValPtr x; /* a first value */
|
|
int n_x;
|
|
xmlSchemaWhitespaceValueType xws; /* the whitespace value of x */
|
|
int n_xws;
|
|
xmlSchemaValPtr y; /* a second value */
|
|
int n_y;
|
|
xmlSchemaWhitespaceValueType yws; /* the whitespace value of y */
|
|
int n_yws;
|
|
|
|
for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) {
|
|
for (n_xws = 0;n_xws < gen_nb_xmlSchemaWhitespaceValueType;n_xws++) {
|
|
for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) {
|
|
for (n_yws = 0;n_yws < gen_nb_xmlSchemaWhitespaceValueType;n_yws++) {
|
|
mem_base = xmlMemBlocks();
|
|
x = gen_xmlSchemaValPtr(n_x, 0);
|
|
xws = gen_xmlSchemaWhitespaceValueType(n_xws, 1);
|
|
y = gen_xmlSchemaValPtr(n_y, 2);
|
|
yws = gen_xmlSchemaWhitespaceValueType(n_yws, 3);
|
|
|
|
ret_val = xmlSchemaCompareValuesWhtsp(x, xws, y, yws);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValPtr(n_x, x, 0);
|
|
des_xmlSchemaWhitespaceValueType(n_xws, xws, 1);
|
|
des_xmlSchemaValPtr(n_y, y, 2);
|
|
des_xmlSchemaWhitespaceValueType(n_yws, yws, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaCompareValuesWhtsp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_x);
|
|
printf(" %d", n_xws);
|
|
printf(" %d", n_y);
|
|
printf(" %d", n_yws);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaCopyValue(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaGetBuiltInListSimpleTypeItemType(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlSchemaTypePtr ret_val;
|
|
xmlSchemaTypePtr type; /* the built-in simple type. */
|
|
int n_type;
|
|
|
|
for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
|
|
mem_base = xmlMemBlocks();
|
|
type = gen_xmlSchemaTypePtr(n_type, 0);
|
|
|
|
ret_val = xmlSchemaGetBuiltInListSimpleTypeItemType(type);
|
|
desret_xmlSchemaTypePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaTypePtr(n_type, type, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaGetBuiltInListSimpleTypeItemType",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_type);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaGetBuiltInType(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
xmlSchemaTypePtr ret_val;
|
|
xmlSchemaValType type; /* the type of the built in type */
|
|
int n_type;
|
|
|
|
for (n_type = 0;n_type < gen_nb_xmlSchemaValType;n_type++) {
|
|
type = gen_xmlSchemaValType(n_type, 0);
|
|
|
|
ret_val = xmlSchemaGetBuiltInType(type);
|
|
desret_xmlSchemaTypePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValType(n_type, type, 0);
|
|
xmlResetLastError();
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaGetCanonValue(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValPtr val; /* the precomputed value */
|
|
int n_val;
|
|
const xmlChar ** retValue; /* the returned value */
|
|
int n_retValue;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
|
|
for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlSchemaValPtr(n_val, 0);
|
|
retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1);
|
|
|
|
ret_val = xmlSchemaGetCanonValue(val, retValue);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValPtr(n_val, val, 0);
|
|
des_const_xmlChar_ptr_ptr(n_retValue, retValue, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaGetCanonValue",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf(" %d", n_retValue);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaGetCanonValueWhtsp(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValPtr val; /* the precomputed value */
|
|
int n_val;
|
|
const xmlChar ** retValue; /* the returned value */
|
|
int n_retValue;
|
|
xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
|
|
int n_ws;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
|
|
for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) {
|
|
for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlSchemaValPtr(n_val, 0);
|
|
retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1);
|
|
ws = gen_xmlSchemaWhitespaceValueType(n_ws, 2);
|
|
|
|
ret_val = xmlSchemaGetCanonValueWhtsp(val, retValue, ws);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValPtr(n_val, val, 0);
|
|
des_const_xmlChar_ptr_ptr(n_retValue, retValue, 1);
|
|
des_xmlSchemaWhitespaceValueType(n_ws, ws, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaGetCanonValueWhtsp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf(" %d", n_retValue);
|
|
printf(" %d", n_ws);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaGetFacetValueAsULong(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
unsigned long ret_val;
|
|
xmlSchemaFacetPtr facet; /* an schemas type facet */
|
|
int n_facet;
|
|
|
|
for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
|
|
mem_base = xmlMemBlocks();
|
|
facet = gen_xmlSchemaFacetPtr(n_facet, 0);
|
|
|
|
ret_val = xmlSchemaGetFacetValueAsULong(facet);
|
|
desret_unsigned_long(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaFacetPtr(n_facet, facet, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaGetFacetValueAsULong",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_facet);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaGetPredefinedType(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlSchemaTypePtr ret_val;
|
|
const xmlChar * name; /* the type name */
|
|
int n_name;
|
|
const xmlChar * ns; /* the URI of the namespace usually "http://www.w3.org/2001/XMLSchema" */
|
|
int n_ns;
|
|
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
|
|
mem_base = xmlMemBlocks();
|
|
name = gen_const_xmlChar_ptr(n_name, 0);
|
|
ns = gen_const_xmlChar_ptr(n_ns, 1);
|
|
|
|
ret_val = xmlSchemaGetPredefinedType(name, ns);
|
|
desret_xmlSchemaTypePtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_name, name, 0);
|
|
des_const_xmlChar_ptr(n_ns, ns, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaGetPredefinedType",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_ns);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaGetValType(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlSchemaValType ret_val;
|
|
xmlSchemaValPtr val; /* a schemas value */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlSchemaValPtr(n_val, 0);
|
|
|
|
ret_val = xmlSchemaGetValType(val);
|
|
desret_xmlSchemaValType(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValPtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaGetValType",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaInitTypes(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int ret_val;
|
|
|
|
|
|
ret_val = xmlSchemaInitTypes();
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaIsBuiltInTypeFacet(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaTypePtr type; /* the built-in type */
|
|
int n_type;
|
|
int facetType; /* the facet type */
|
|
int n_facetType;
|
|
|
|
for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
|
|
for (n_facetType = 0;n_facetType < gen_nb_int;n_facetType++) {
|
|
mem_base = xmlMemBlocks();
|
|
type = gen_xmlSchemaTypePtr(n_type, 0);
|
|
facetType = gen_int(n_facetType, 1);
|
|
|
|
ret_val = xmlSchemaIsBuiltInTypeFacet(type, facetType);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaTypePtr(n_type, type, 0);
|
|
des_int(n_facetType, facetType, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaIsBuiltInTypeFacet",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_facetType);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaNewFacet(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaNewNOTATIONValue(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaNewQNameValue(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaNewStringValue(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_SCHEMAS_ENABLED
|
|
|
|
#define gen_nb_xmlSchemaValPtr_ptr 1
|
|
#define gen_xmlSchemaValPtr_ptr(no, nr) NULL
|
|
#define des_xmlSchemaValPtr_ptr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValPredefTypeNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaTypePtr type; /* the predefined type */
|
|
int n_type;
|
|
const xmlChar * value; /* the value to check */
|
|
int n_value;
|
|
xmlSchemaValPtr * val; /* the return computed value */
|
|
int n_val;
|
|
xmlNodePtr node; /* the node containing the value */
|
|
int n_node;
|
|
|
|
for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
type = gen_xmlSchemaTypePtr(n_type, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
val = gen_xmlSchemaValPtr_ptr(n_val, 2);
|
|
node = gen_xmlNodePtr(n_node, 3);
|
|
|
|
ret_val = xmlSchemaValPredefTypeNode(type, value, val, node);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaTypePtr(n_type, type, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
des_xmlSchemaValPtr_ptr(n_val, val, 2);
|
|
des_xmlNodePtr(n_node, node, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValPredefTypeNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_val);
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValPredefTypeNodeNoNorm(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaTypePtr type; /* the predefined type */
|
|
int n_type;
|
|
const xmlChar * value; /* the value to check */
|
|
int n_value;
|
|
xmlSchemaValPtr * val; /* the return computed value */
|
|
int n_val;
|
|
xmlNodePtr node; /* the node containing the value */
|
|
int n_node;
|
|
|
|
for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
type = gen_xmlSchemaTypePtr(n_type, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
val = gen_xmlSchemaValPtr_ptr(n_val, 2);
|
|
node = gen_xmlNodePtr(n_node, 3);
|
|
|
|
ret_val = xmlSchemaValPredefTypeNodeNoNorm(type, value, val, node);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaTypePtr(n_type, type, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
des_xmlSchemaValPtr_ptr(n_val, val, 2);
|
|
des_xmlNodePtr(n_node, node, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValPredefTypeNodeNoNorm",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_val);
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidateFacet(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaTypePtr base; /* the base type */
|
|
int n_base;
|
|
xmlSchemaFacetPtr facet; /* the facet to check */
|
|
int n_facet;
|
|
const xmlChar * value; /* the lexical repr of the value to validate */
|
|
int n_value;
|
|
xmlSchemaValPtr val; /* the precomputed value */
|
|
int n_val;
|
|
|
|
for (n_base = 0;n_base < gen_nb_xmlSchemaTypePtr;n_base++) {
|
|
for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
base = gen_xmlSchemaTypePtr(n_base, 0);
|
|
facet = gen_xmlSchemaFacetPtr(n_facet, 1);
|
|
value = gen_const_xmlChar_ptr(n_value, 2);
|
|
val = gen_xmlSchemaValPtr(n_val, 3);
|
|
|
|
ret_val = xmlSchemaValidateFacet(base, facet, value, val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaTypePtr(n_base, base, 0);
|
|
des_xmlSchemaFacetPtr(n_facet, facet, 1);
|
|
des_const_xmlChar_ptr(n_value, value, 2);
|
|
des_xmlSchemaValPtr(n_val, val, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidateFacet",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_base);
|
|
printf(" %d", n_facet);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidateFacetWhtsp(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaFacetPtr facet; /* the facet to check */
|
|
int n_facet;
|
|
xmlSchemaWhitespaceValueType fws; /* the whitespace type of the facet's value */
|
|
int n_fws;
|
|
xmlSchemaValType valType; /* the built-in type of the value */
|
|
int n_valType;
|
|
const xmlChar * value; /* the lexical (or normalized for pattern) repr of the value to validate */
|
|
int n_value;
|
|
xmlSchemaValPtr val; /* the precomputed value */
|
|
int n_val;
|
|
xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
|
|
int n_ws;
|
|
|
|
for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
|
|
for (n_fws = 0;n_fws < gen_nb_xmlSchemaWhitespaceValueType;n_fws++) {
|
|
for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
|
|
for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
|
|
mem_base = xmlMemBlocks();
|
|
facet = gen_xmlSchemaFacetPtr(n_facet, 0);
|
|
fws = gen_xmlSchemaWhitespaceValueType(n_fws, 1);
|
|
valType = gen_xmlSchemaValType(n_valType, 2);
|
|
value = gen_const_xmlChar_ptr(n_value, 3);
|
|
val = gen_xmlSchemaValPtr(n_val, 4);
|
|
ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5);
|
|
|
|
ret_val = xmlSchemaValidateFacetWhtsp(facet, fws, valType, value, val, ws);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaFacetPtr(n_facet, facet, 0);
|
|
des_xmlSchemaWhitespaceValueType(n_fws, fws, 1);
|
|
des_xmlSchemaValType(n_valType, valType, 2);
|
|
des_const_xmlChar_ptr(n_value, value, 3);
|
|
des_xmlSchemaValPtr(n_val, val, 4);
|
|
des_xmlSchemaWhitespaceValueType(n_ws, ws, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidateFacetWhtsp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_facet);
|
|
printf(" %d", n_fws);
|
|
printf(" %d", n_valType);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_val);
|
|
printf(" %d", n_ws);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidateLengthFacet(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaTypePtr type; /* the built-in type */
|
|
int n_type;
|
|
xmlSchemaFacetPtr facet; /* the facet to check */
|
|
int n_facet;
|
|
const xmlChar * value; /* the lexical repr. of the value to be validated */
|
|
int n_value;
|
|
xmlSchemaValPtr val; /* the precomputed value */
|
|
int n_val;
|
|
unsigned long * length; /* the actual length of the value */
|
|
int n_length;
|
|
|
|
for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
|
|
for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
|
|
for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) {
|
|
mem_base = xmlMemBlocks();
|
|
type = gen_xmlSchemaTypePtr(n_type, 0);
|
|
facet = gen_xmlSchemaFacetPtr(n_facet, 1);
|
|
value = gen_const_xmlChar_ptr(n_value, 2);
|
|
val = gen_xmlSchemaValPtr(n_val, 3);
|
|
length = gen_unsigned_long_ptr(n_length, 4);
|
|
|
|
ret_val = xmlSchemaValidateLengthFacet(type, facet, value, val, length);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaTypePtr(n_type, type, 0);
|
|
des_xmlSchemaFacetPtr(n_facet, facet, 1);
|
|
des_const_xmlChar_ptr(n_value, value, 2);
|
|
des_xmlSchemaValPtr(n_val, val, 3);
|
|
des_unsigned_long_ptr(n_length, length, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidateLengthFacet",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_facet);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_val);
|
|
printf(" %d", n_length);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidateLengthFacetWhtsp(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaFacetPtr facet; /* the facet to check */
|
|
int n_facet;
|
|
xmlSchemaValType valType; /* the built-in type */
|
|
int n_valType;
|
|
const xmlChar * value; /* the lexical repr. of the value to be validated */
|
|
int n_value;
|
|
xmlSchemaValPtr val; /* the precomputed value */
|
|
int n_val;
|
|
unsigned long * length; /* the actual length of the value */
|
|
int n_length;
|
|
xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
|
|
int n_ws;
|
|
|
|
for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
|
|
for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
|
|
for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) {
|
|
for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
|
|
mem_base = xmlMemBlocks();
|
|
facet = gen_xmlSchemaFacetPtr(n_facet, 0);
|
|
valType = gen_xmlSchemaValType(n_valType, 1);
|
|
value = gen_const_xmlChar_ptr(n_value, 2);
|
|
val = gen_xmlSchemaValPtr(n_val, 3);
|
|
length = gen_unsigned_long_ptr(n_length, 4);
|
|
ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5);
|
|
|
|
ret_val = xmlSchemaValidateLengthFacetWhtsp(facet, valType, value, val, length, ws);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaFacetPtr(n_facet, facet, 0);
|
|
des_xmlSchemaValType(n_valType, valType, 1);
|
|
des_const_xmlChar_ptr(n_value, value, 2);
|
|
des_xmlSchemaValPtr(n_val, val, 3);
|
|
des_unsigned_long_ptr(n_length, length, 4);
|
|
des_xmlSchemaWhitespaceValueType(n_ws, ws, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidateLengthFacetWhtsp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_facet);
|
|
printf(" %d", n_valType);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_val);
|
|
printf(" %d", n_length);
|
|
printf(" %d", n_ws);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidateListSimpleTypeFacet(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaFacetPtr facet; /* the facet to check */
|
|
int n_facet;
|
|
const xmlChar * value; /* the lexical repr of the value to validate */
|
|
int n_value;
|
|
unsigned long actualLen; /* the number of list items */
|
|
int n_actualLen;
|
|
unsigned long * expectedLen; /* the resulting expected number of list items */
|
|
int n_expectedLen;
|
|
|
|
for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_actualLen = 0;n_actualLen < gen_nb_unsigned_long;n_actualLen++) {
|
|
for (n_expectedLen = 0;n_expectedLen < gen_nb_unsigned_long_ptr;n_expectedLen++) {
|
|
mem_base = xmlMemBlocks();
|
|
facet = gen_xmlSchemaFacetPtr(n_facet, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
actualLen = gen_unsigned_long(n_actualLen, 2);
|
|
expectedLen = gen_unsigned_long_ptr(n_expectedLen, 3);
|
|
|
|
ret_val = xmlSchemaValidateListSimpleTypeFacet(facet, value, actualLen, expectedLen);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaFacetPtr(n_facet, facet, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
des_unsigned_long(n_actualLen, actualLen, 2);
|
|
des_unsigned_long_ptr(n_expectedLen, expectedLen, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidateListSimpleTypeFacet",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_facet);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_actualLen);
|
|
printf(" %d", n_expectedLen);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValidatePredefinedType(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaTypePtr type; /* the predefined type */
|
|
int n_type;
|
|
const xmlChar * value; /* the value to check */
|
|
int n_value;
|
|
xmlSchemaValPtr * val; /* the return computed value */
|
|
int n_val;
|
|
|
|
for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
type = gen_xmlSchemaTypePtr(n_type, 0);
|
|
value = gen_const_xmlChar_ptr(n_value, 1);
|
|
val = gen_xmlSchemaValPtr_ptr(n_val, 2);
|
|
|
|
ret_val = xmlSchemaValidatePredefinedType(type, value, val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaTypePtr(n_type, type, 0);
|
|
des_const_xmlChar_ptr(n_value, value, 1);
|
|
des_xmlSchemaValPtr_ptr(n_val, val, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValidatePredefinedType",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_type);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValueAppend(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValPtr prev; /* the value */
|
|
int n_prev;
|
|
xmlSchemaValPtr cur; /* the value to be appended */
|
|
int n_cur;
|
|
|
|
for (n_prev = 0;n_prev < gen_nb_xmlSchemaValPtr;n_prev++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlSchemaValPtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
prev = gen_xmlSchemaValPtr(n_prev, 0);
|
|
cur = gen_xmlSchemaValPtr(n_cur, 1);
|
|
|
|
ret_val = xmlSchemaValueAppend(prev, cur);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValPtr(n_prev, prev, 0);
|
|
des_xmlSchemaValPtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValueAppend",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_prev);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValueGetAsBoolean(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlSchemaValPtr val; /* the value */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlSchemaValPtr(n_val, 0);
|
|
|
|
ret_val = xmlSchemaValueGetAsBoolean(val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValPtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValueGetAsBoolean",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValueGetAsString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlSchemaValPtr val; /* the value */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlSchemaValPtr(n_val, 0);
|
|
|
|
ret_val = xmlSchemaValueGetAsString(val);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlSchemaValPtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaValueGetAsString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaValueGetNext(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlSchemaWhiteSpaceReplace(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * value; /* a value */
|
|
int n_value;
|
|
|
|
for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
value = gen_const_xmlChar_ptr(n_value, 0);
|
|
|
|
ret_val = xmlSchemaWhiteSpaceReplace(value);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_value, value, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlSchemaWhiteSpaceReplace",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlschemastypes(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xmlschemastypes : 26 of 34 functions ...\n");
|
|
test_ret += test_xmlSchemaCheckFacet();
|
|
test_ret += test_xmlSchemaCleanupTypes();
|
|
test_ret += test_xmlSchemaCollapseString();
|
|
test_ret += test_xmlSchemaCompareValues();
|
|
test_ret += test_xmlSchemaCompareValuesWhtsp();
|
|
test_ret += test_xmlSchemaCopyValue();
|
|
test_ret += test_xmlSchemaGetBuiltInListSimpleTypeItemType();
|
|
test_ret += test_xmlSchemaGetBuiltInType();
|
|
test_ret += test_xmlSchemaGetCanonValue();
|
|
test_ret += test_xmlSchemaGetCanonValueWhtsp();
|
|
test_ret += test_xmlSchemaGetFacetValueAsULong();
|
|
test_ret += test_xmlSchemaGetPredefinedType();
|
|
test_ret += test_xmlSchemaGetValType();
|
|
test_ret += test_xmlSchemaInitTypes();
|
|
test_ret += test_xmlSchemaIsBuiltInTypeFacet();
|
|
test_ret += test_xmlSchemaNewFacet();
|
|
test_ret += test_xmlSchemaNewNOTATIONValue();
|
|
test_ret += test_xmlSchemaNewQNameValue();
|
|
test_ret += test_xmlSchemaNewStringValue();
|
|
test_ret += test_xmlSchemaValPredefTypeNode();
|
|
test_ret += test_xmlSchemaValPredefTypeNodeNoNorm();
|
|
test_ret += test_xmlSchemaValidateFacet();
|
|
test_ret += test_xmlSchemaValidateFacetWhtsp();
|
|
test_ret += test_xmlSchemaValidateLengthFacet();
|
|
test_ret += test_xmlSchemaValidateLengthFacetWhtsp();
|
|
test_ret += test_xmlSchemaValidateListSimpleTypeFacet();
|
|
test_ret += test_xmlSchemaValidatePredefinedType();
|
|
test_ret += test_xmlSchemaValueAppend();
|
|
test_ret += test_xmlSchemaValueGetAsBoolean();
|
|
test_ret += test_xmlSchemaValueGetAsString();
|
|
test_ret += test_xmlSchemaValueGetNext();
|
|
test_ret += test_xmlSchemaWhiteSpaceReplace();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xmlschemastypes: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlCharStrdup(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const char * cur; /* the input char * */
|
|
int n_cur;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_char_ptr(n_cur, 0);
|
|
|
|
ret_val = xmlCharStrdup(cur);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_cur, cur, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCharStrdup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCharStrndup(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const char * cur; /* the input char * */
|
|
int n_cur;
|
|
int len; /* the len of @cur */
|
|
int n_len;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_char_ptr(n_cur, 0);
|
|
len = gen_int(n_len, 1);
|
|
if ((cur != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST cur)))
|
|
len = 0;
|
|
|
|
ret_val = xmlCharStrndup(cur, len);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_cur, cur, 0);
|
|
des_int(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCharStrndup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlCheckUTF8(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const unsigned char * utf; /* Pointer to putative UTF-8 encoded string. */
|
|
int n_utf;
|
|
|
|
for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) {
|
|
mem_base = xmlMemBlocks();
|
|
utf = gen_const_unsigned_char_ptr(n_utf, 0);
|
|
|
|
ret_val = xmlCheckUTF8(utf);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_unsigned_char_ptr(n_utf, utf, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlCheckUTF8",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_utf);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlGetUTF8Char(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const unsigned char * utf; /* a sequence of UTF-8 encoded bytes */
|
|
int n_utf;
|
|
int * len; /* a pointer to the minimum number of bytes present in the sequence. This is used to assure the next character is completely contained within the sequence. */
|
|
int n_len;
|
|
|
|
for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) {
|
|
for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
utf = gen_const_unsigned_char_ptr(n_utf, 0);
|
|
len = gen_int_ptr(n_len, 1);
|
|
|
|
ret_val = xmlGetUTF8Char(utf, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_unsigned_char_ptr(n_utf, utf, 0);
|
|
des_int_ptr(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlGetUTF8Char",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_utf);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrEqual(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * str1; /* the first xmlChar * */
|
|
int n_str1;
|
|
const xmlChar * str2; /* the second xmlChar * */
|
|
int n_str2;
|
|
|
|
for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
|
|
for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
|
|
mem_base = xmlMemBlocks();
|
|
str1 = gen_const_xmlChar_ptr(n_str1, 0);
|
|
str2 = gen_const_xmlChar_ptr(n_str2, 1);
|
|
|
|
ret_val = xmlStrEqual(str1, str2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str1, str1, 0);
|
|
des_const_xmlChar_ptr(n_str2, str2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrEqual",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str1);
|
|
printf(" %d", n_str2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrPrintf(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrQEqual(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * pref; /* the prefix of the QName */
|
|
int n_pref;
|
|
const xmlChar * name; /* the localname of the QName */
|
|
int n_name;
|
|
const xmlChar * str; /* the second xmlChar * */
|
|
int n_str;
|
|
|
|
for (n_pref = 0;n_pref < gen_nb_const_xmlChar_ptr;n_pref++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
pref = gen_const_xmlChar_ptr(n_pref, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
str = gen_const_xmlChar_ptr(n_str, 2);
|
|
|
|
ret_val = xmlStrQEqual(pref, name, str);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_pref, pref, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_str, str, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrQEqual",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_pref);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrVPrintf(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrcasecmp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * str1; /* the first xmlChar * */
|
|
int n_str1;
|
|
const xmlChar * str2; /* the second xmlChar * */
|
|
int n_str2;
|
|
|
|
for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
|
|
for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
|
|
mem_base = xmlMemBlocks();
|
|
str1 = gen_const_xmlChar_ptr(n_str1, 0);
|
|
str2 = gen_const_xmlChar_ptr(n_str2, 1);
|
|
|
|
ret_val = xmlStrcasecmp(str1, str2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str1, str1, 0);
|
|
des_const_xmlChar_ptr(n_str2, str2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrcasecmp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str1);
|
|
printf(" %d", n_str2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrcasestr(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
const xmlChar * str; /* the xmlChar * array (haystack) */
|
|
int n_str;
|
|
const xmlChar * val; /* the xmlChar to search (needle) */
|
|
int n_val;
|
|
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
str = gen_const_xmlChar_ptr(n_str, 0);
|
|
val = gen_const_xmlChar_ptr(n_val, 1);
|
|
|
|
ret_val = xmlStrcasestr(str, val);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str, str, 0);
|
|
des_const_xmlChar_ptr(n_val, val, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrcasestr",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrchr(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
const xmlChar * str; /* the xmlChar * array */
|
|
int n_str;
|
|
xmlChar val; /* the xmlChar to search */
|
|
int n_val;
|
|
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_val = 0;n_val < gen_nb_xmlChar;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
str = gen_const_xmlChar_ptr(n_str, 0);
|
|
val = gen_xmlChar(n_val, 1);
|
|
|
|
ret_val = xmlStrchr(str, val);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str, str, 0);
|
|
des_xmlChar(n_val, val, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrchr",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrcmp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * str1; /* the first xmlChar * */
|
|
int n_str1;
|
|
const xmlChar * str2; /* the second xmlChar * */
|
|
int n_str2;
|
|
|
|
for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
|
|
for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
|
|
mem_base = xmlMemBlocks();
|
|
str1 = gen_const_xmlChar_ptr(n_str1, 0);
|
|
str2 = gen_const_xmlChar_ptr(n_str2, 1);
|
|
|
|
ret_val = xmlStrcmp(str1, str2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str1, str1, 0);
|
|
des_const_xmlChar_ptr(n_str2, str2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrcmp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str1);
|
|
printf(" %d", n_str2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrdup(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * cur; /* the input xmlChar * */
|
|
int n_cur;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_xmlChar_ptr(n_cur, 0);
|
|
|
|
ret_val = xmlStrdup(cur);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_cur, cur, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrdup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrlen(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * str; /* the xmlChar * array */
|
|
int n_str;
|
|
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
str = gen_const_xmlChar_ptr(n_str, 0);
|
|
|
|
ret_val = xmlStrlen(str);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str, str, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrlen",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrncasecmp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * str1; /* the first xmlChar * */
|
|
int n_str1;
|
|
const xmlChar * str2; /* the second xmlChar * */
|
|
int n_str2;
|
|
int len; /* the max comparison length */
|
|
int n_len;
|
|
|
|
for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
|
|
for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
str1 = gen_const_xmlChar_ptr(n_str1, 0);
|
|
str2 = gen_const_xmlChar_ptr(n_str2, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((str2 != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST str2)))
|
|
len = 0;
|
|
|
|
ret_val = xmlStrncasecmp(str1, str2, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str1, str1, 0);
|
|
des_const_xmlChar_ptr(n_str2, str2, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrncasecmp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str1);
|
|
printf(" %d", n_str2);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrncatNew(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * str1; /* first xmlChar string */
|
|
int n_str1;
|
|
const xmlChar * str2; /* second xmlChar string */
|
|
int n_str2;
|
|
int len; /* the len of @str2 or < 0 */
|
|
int n_len;
|
|
|
|
for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
|
|
for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
str1 = gen_const_xmlChar_ptr(n_str1, 0);
|
|
str2 = gen_const_xmlChar_ptr(n_str2, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((str2 != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST str2)))
|
|
len = 0;
|
|
|
|
ret_val = xmlStrncatNew(str1, str2, len);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str1, str1, 0);
|
|
des_const_xmlChar_ptr(n_str2, str2, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrncatNew",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str1);
|
|
printf(" %d", n_str2);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrncmp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * str1; /* the first xmlChar * */
|
|
int n_str1;
|
|
const xmlChar * str2; /* the second xmlChar * */
|
|
int n_str2;
|
|
int len; /* the max comparison length */
|
|
int n_len;
|
|
|
|
for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
|
|
for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
str1 = gen_const_xmlChar_ptr(n_str1, 0);
|
|
str2 = gen_const_xmlChar_ptr(n_str2, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((str2 != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST str2)))
|
|
len = 0;
|
|
|
|
ret_val = xmlStrncmp(str1, str2, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str1, str1, 0);
|
|
des_const_xmlChar_ptr(n_str2, str2, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrncmp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str1);
|
|
printf(" %d", n_str2);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrndup(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * cur; /* the input xmlChar * */
|
|
int n_cur;
|
|
int len; /* the len of @cur */
|
|
int n_len;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_const_xmlChar_ptr(n_cur, 0);
|
|
len = gen_int(n_len, 1);
|
|
if ((cur != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST cur)))
|
|
len = 0;
|
|
|
|
ret_val = xmlStrndup(cur, len);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_cur, cur, 0);
|
|
des_int(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrndup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrstr(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
const xmlChar * str; /* the xmlChar * array (haystack) */
|
|
int n_str;
|
|
const xmlChar * val; /* the xmlChar to search (needle) */
|
|
int n_val;
|
|
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
str = gen_const_xmlChar_ptr(n_str, 0);
|
|
val = gen_const_xmlChar_ptr(n_val, 1);
|
|
|
|
ret_val = xmlStrstr(str, val);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str, str, 0);
|
|
des_const_xmlChar_ptr(n_val, val, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrstr",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlStrsub(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * str; /* the xmlChar * array (haystack) */
|
|
int n_str;
|
|
int start; /* the index of the first char (zero based) */
|
|
int n_start;
|
|
int len; /* the length of the substring */
|
|
int n_len;
|
|
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_start = 0;n_start < gen_nb_int;n_start++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
str = gen_const_xmlChar_ptr(n_str, 0);
|
|
start = gen_int(n_start, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((str != NULL) &&
|
|
(start > xmlStrlen(BAD_CAST str)))
|
|
start = 0;
|
|
if ((str != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST str)))
|
|
len = 0;
|
|
|
|
ret_val = xmlStrsub(str, start, len);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str, str, 0);
|
|
des_int(n_start, start, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlStrsub",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_start);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUTF8Charcmp(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * utf1; /* pointer to first UTF8 char */
|
|
int n_utf1;
|
|
const xmlChar * utf2; /* pointer to second UTF8 char */
|
|
int n_utf2;
|
|
|
|
for (n_utf1 = 0;n_utf1 < gen_nb_const_xmlChar_ptr;n_utf1++) {
|
|
for (n_utf2 = 0;n_utf2 < gen_nb_const_xmlChar_ptr;n_utf2++) {
|
|
mem_base = xmlMemBlocks();
|
|
utf1 = gen_const_xmlChar_ptr(n_utf1, 0);
|
|
utf2 = gen_const_xmlChar_ptr(n_utf2, 1);
|
|
|
|
ret_val = xmlUTF8Charcmp(utf1, utf2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_utf1, utf1, 0);
|
|
des_const_xmlChar_ptr(n_utf2, utf2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUTF8Charcmp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_utf1);
|
|
printf(" %d", n_utf2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUTF8Size(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * utf; /* pointer to the UTF8 character */
|
|
int n_utf;
|
|
|
|
for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
|
|
mem_base = xmlMemBlocks();
|
|
utf = gen_const_xmlChar_ptr(n_utf, 0);
|
|
|
|
ret_val = xmlUTF8Size(utf);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_utf, utf, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUTF8Size",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_utf);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUTF8Strlen(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
|
|
int n_utf;
|
|
|
|
for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
|
|
mem_base = xmlMemBlocks();
|
|
utf = gen_const_xmlChar_ptr(n_utf, 0);
|
|
|
|
ret_val = xmlUTF8Strlen(utf);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_utf, utf, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUTF8Strlen",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_utf);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUTF8Strloc(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * utf; /* the input UTF8 * */
|
|
int n_utf;
|
|
const xmlChar * utfchar; /* the UTF8 character to be found */
|
|
int n_utfchar;
|
|
|
|
for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
|
|
for (n_utfchar = 0;n_utfchar < gen_nb_const_xmlChar_ptr;n_utfchar++) {
|
|
mem_base = xmlMemBlocks();
|
|
utf = gen_const_xmlChar_ptr(n_utf, 0);
|
|
utfchar = gen_const_xmlChar_ptr(n_utfchar, 1);
|
|
|
|
ret_val = xmlUTF8Strloc(utf, utfchar);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_utf, utf, 0);
|
|
des_const_xmlChar_ptr(n_utfchar, utfchar, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUTF8Strloc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_utf);
|
|
printf(" %d", n_utfchar);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUTF8Strndup(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * utf; /* the input UTF8 * */
|
|
int n_utf;
|
|
int len; /* the len of @utf (in chars) */
|
|
int n_len;
|
|
|
|
for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
utf = gen_const_xmlChar_ptr(n_utf, 0);
|
|
len = gen_int(n_len, 1);
|
|
if ((utf != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST utf)))
|
|
len = 0;
|
|
|
|
ret_val = xmlUTF8Strndup(utf, len);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_utf, utf, 0);
|
|
des_int(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUTF8Strndup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_utf);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUTF8Strpos(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
const xmlChar * utf; /* the input UTF8 * */
|
|
int n_utf;
|
|
int pos; /* the position of the desired UTF8 char (in chars) */
|
|
int n_pos;
|
|
|
|
for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
|
|
for (n_pos = 0;n_pos < gen_nb_int;n_pos++) {
|
|
mem_base = xmlMemBlocks();
|
|
utf = gen_const_xmlChar_ptr(n_utf, 0);
|
|
pos = gen_int(n_pos, 1);
|
|
|
|
ret_val = xmlUTF8Strpos(utf, pos);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_utf, utf, 0);
|
|
des_int(n_pos, pos, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUTF8Strpos",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_utf);
|
|
printf(" %d", n_pos);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUTF8Strsize(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
|
|
int n_utf;
|
|
int len; /* the number of characters in the array */
|
|
int n_len;
|
|
|
|
for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
utf = gen_const_xmlChar_ptr(n_utf, 0);
|
|
len = gen_int(n_len, 1);
|
|
if ((utf != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST utf)))
|
|
len = 0;
|
|
|
|
ret_val = xmlUTF8Strsize(utf, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_utf, utf, 0);
|
|
des_int(n_len, len, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUTF8Strsize",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_utf);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUTF8Strsub(void) {
|
|
int test_ret = 0;
|
|
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
const xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
|
|
int n_utf;
|
|
int start; /* relative pos of first char */
|
|
int n_start;
|
|
int len; /* total number to copy */
|
|
int n_len;
|
|
|
|
for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
|
|
for (n_start = 0;n_start < gen_nb_int;n_start++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
utf = gen_const_xmlChar_ptr(n_utf, 0);
|
|
start = gen_int(n_start, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((utf != NULL) &&
|
|
(start > xmlStrlen(BAD_CAST utf)))
|
|
start = 0;
|
|
if ((utf != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST utf)))
|
|
len = 0;
|
|
|
|
ret_val = xmlUTF8Strsub(utf, start, len);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_utf, utf, 0);
|
|
des_int(n_start, start, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUTF8Strsub",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_utf);
|
|
printf(" %d", n_start);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlstring(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xmlstring : 26 of 30 functions ...\n");
|
|
test_ret += test_xmlCharStrdup();
|
|
test_ret += test_xmlCharStrndup();
|
|
test_ret += test_xmlCheckUTF8();
|
|
test_ret += test_xmlGetUTF8Char();
|
|
test_ret += test_xmlStrEqual();
|
|
test_ret += test_xmlStrPrintf();
|
|
test_ret += test_xmlStrQEqual();
|
|
test_ret += test_xmlStrVPrintf();
|
|
test_ret += test_xmlStrcasecmp();
|
|
test_ret += test_xmlStrcasestr();
|
|
test_ret += test_xmlStrchr();
|
|
test_ret += test_xmlStrcmp();
|
|
test_ret += test_xmlStrdup();
|
|
test_ret += test_xmlStrlen();
|
|
test_ret += test_xmlStrncasecmp();
|
|
test_ret += test_xmlStrncatNew();
|
|
test_ret += test_xmlStrncmp();
|
|
test_ret += test_xmlStrndup();
|
|
test_ret += test_xmlStrstr();
|
|
test_ret += test_xmlStrsub();
|
|
test_ret += test_xmlUTF8Charcmp();
|
|
test_ret += test_xmlUTF8Size();
|
|
test_ret += test_xmlUTF8Strlen();
|
|
test_ret += test_xmlUTF8Strloc();
|
|
test_ret += test_xmlUTF8Strndup();
|
|
test_ret += test_xmlUTF8Strpos();
|
|
test_ret += test_xmlUTF8Strsize();
|
|
test_ret += test_xmlUTF8Strsub();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xmlstring: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlUCSIsAegeanNumbers(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsAegeanNumbers(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsAegeanNumbers",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsAlphabeticPresentationForms(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsAlphabeticPresentationForms(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsAlphabeticPresentationForms",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsArabic(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsArabic(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsArabic",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsArabicPresentationFormsA(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsArabicPresentationFormsA(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsA",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsArabicPresentationFormsB(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsArabicPresentationFormsB(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsB",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsArmenian(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsArmenian(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsArmenian",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsArrows(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsArrows(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsArrows",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsBasicLatin(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsBasicLatin(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsBasicLatin",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsBengali(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsBengali(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsBengali",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsBlock(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
const char * block; /* UCS block name */
|
|
int n_block;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
for (n_block = 0;n_block < gen_nb_const_char_ptr;n_block++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
block = gen_const_char_ptr(n_block, 1);
|
|
|
|
ret_val = xmlUCSIsBlock(code, block);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
des_const_char_ptr(n_block, block, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsBlock",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf(" %d", n_block);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsBlockElements(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsBlockElements(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsBlockElements",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsBopomofo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsBopomofo(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsBopomofo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsBopomofoExtended(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsBopomofoExtended(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsBopomofoExtended",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsBoxDrawing(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsBoxDrawing(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsBoxDrawing",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsBraillePatterns(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsBraillePatterns(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsBraillePatterns",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsBuhid(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsBuhid(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsBuhid",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsByzantineMusicalSymbols(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsByzantineMusicalSymbols(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsByzantineMusicalSymbols",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCJKCompatibility(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCJKCompatibility(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCJKCompatibility",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCJKCompatibilityForms(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCJKCompatibilityForms(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityForms",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCJKCompatibilityIdeographs(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCJKCompatibilityIdeographs(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCJKCompatibilityIdeographsSupplement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCJKCompatibilityIdeographsSupplement(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographsSupplement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCJKRadicalsSupplement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCJKRadicalsSupplement(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCJKRadicalsSupplement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCJKSymbolsandPunctuation(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCJKSymbolsandPunctuation(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCJKSymbolsandPunctuation",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCJKUnifiedIdeographs(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCJKUnifiedIdeographs(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCJKUnifiedIdeographsExtensionA(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionA(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionA",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCJKUnifiedIdeographsExtensionB(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionB(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionB",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCat(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
const char * cat; /* UCS Category name */
|
|
int n_cat;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
for (n_cat = 0;n_cat < gen_nb_const_char_ptr;n_cat++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
cat = gen_const_char_ptr(n_cat, 1);
|
|
|
|
ret_val = xmlUCSIsCat(code, cat);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
des_const_char_ptr(n_cat, cat, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCat",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf(" %d", n_cat);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatC(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatC(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatC",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatCc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatCc(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatCc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatCf(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatCf(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatCf",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatCo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatCo(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatCo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatCs(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatCs(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatCs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatL(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatL(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatL",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatLl(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatLl(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatLl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatLm(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatLm(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatLm",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatLo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatLo(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatLo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatLt(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatLt(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatLt",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatLu(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatLu(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatLu",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatM(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatM(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatM",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatMc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatMc(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatMc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatMe(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatMe(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatMe",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatMn(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatMn(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatMn",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatN(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatN(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatN",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatNd(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatNd(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatNd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatNl(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatNl(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatNl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatNo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatNo(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatNo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatP(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatP(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatP",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatPc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatPc(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatPc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatPd(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatPd(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatPd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatPe(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatPe(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatPe",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatPf(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatPf(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatPf",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatPi(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatPi(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatPi",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatPo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatPo(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatPo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatPs(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatPs(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatPs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatS(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatS(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatS",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatSc(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatSc(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatSc",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatSk(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatSk(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatSk",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatSm(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatSm(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatSm",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatSo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatSo(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatSo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatZ(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatZ(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatZ",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatZl(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatZl(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatZl",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatZp(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatZp(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatZp",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCatZs(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCatZs(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCatZs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCherokee(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCherokee(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCherokee",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCombiningDiacriticalMarks(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCombiningDiacriticalMarks(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarks",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCombiningDiacriticalMarksforSymbols(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCombiningDiacriticalMarksforSymbols(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarksforSymbols",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCombiningHalfMarks(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCombiningHalfMarks(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCombiningHalfMarks",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCombiningMarksforSymbols(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCombiningMarksforSymbols(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCombiningMarksforSymbols",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsControlPictures(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsControlPictures(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsControlPictures",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCurrencySymbols(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCurrencySymbols(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCurrencySymbols",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCypriotSyllabary(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCypriotSyllabary(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCypriotSyllabary",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCyrillic(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCyrillic(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCyrillic",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsCyrillicSupplement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsCyrillicSupplement(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsCyrillicSupplement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsDeseret(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsDeseret(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsDeseret",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsDevanagari(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsDevanagari(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsDevanagari",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsDingbats(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsDingbats(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsDingbats",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsEnclosedAlphanumerics(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsEnclosedAlphanumerics(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsEnclosedAlphanumerics",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsEnclosedCJKLettersandMonths(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsEnclosedCJKLettersandMonths(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsEnclosedCJKLettersandMonths",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsEthiopic(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsEthiopic(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsEthiopic",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsGeneralPunctuation(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsGeneralPunctuation(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsGeneralPunctuation",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsGeometricShapes(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsGeometricShapes(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsGeometricShapes",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsGeorgian(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsGeorgian(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsGeorgian",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsGothic(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsGothic(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsGothic",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsGreek(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsGreek(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsGreek",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsGreekExtended(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsGreekExtended(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsGreekExtended",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsGreekandCoptic(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsGreekandCoptic(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsGreekandCoptic",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsGujarati(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsGujarati(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsGujarati",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsGurmukhi(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsGurmukhi(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsGurmukhi",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsHalfwidthandFullwidthForms(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsHalfwidthandFullwidthForms(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsHalfwidthandFullwidthForms",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsHangulCompatibilityJamo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsHangulCompatibilityJamo(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsHangulCompatibilityJamo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsHangulJamo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsHangulJamo(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsHangulJamo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsHangulSyllables(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsHangulSyllables(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsHangulSyllables",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsHanunoo(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsHanunoo(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsHanunoo",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsHebrew(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsHebrew(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsHebrew",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsHighPrivateUseSurrogates(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsHighPrivateUseSurrogates(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsHighPrivateUseSurrogates",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsHighSurrogates(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsHighSurrogates(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsHighSurrogates",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsHiragana(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsHiragana(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsHiragana",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsIPAExtensions(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsIPAExtensions(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsIPAExtensions",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsIdeographicDescriptionCharacters(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsIdeographicDescriptionCharacters(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsIdeographicDescriptionCharacters",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsKanbun(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsKanbun(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsKanbun",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsKangxiRadicals(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsKangxiRadicals(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsKangxiRadicals",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsKannada(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsKannada(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsKannada",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsKatakana(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsKatakana(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsKatakana",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsKatakanaPhoneticExtensions(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsKatakanaPhoneticExtensions(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsKatakanaPhoneticExtensions",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsKhmer(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsKhmer(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsKhmer",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsKhmerSymbols(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsKhmerSymbols(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsKhmerSymbols",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsLao(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsLao(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsLao",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsLatin1Supplement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsLatin1Supplement(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsLatin1Supplement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsLatinExtendedA(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsLatinExtendedA(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsLatinExtendedA",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsLatinExtendedAdditional(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsLatinExtendedAdditional(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsLatinExtendedAdditional",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsLatinExtendedB(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsLatinExtendedB(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsLatinExtendedB",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsLetterlikeSymbols(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsLetterlikeSymbols(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsLetterlikeSymbols",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsLimbu(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsLimbu(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsLimbu",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsLinearBIdeograms(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsLinearBIdeograms(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsLinearBIdeograms",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsLinearBSyllabary(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsLinearBSyllabary(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsLinearBSyllabary",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsLowSurrogates(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsLowSurrogates(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsLowSurrogates",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsMalayalam(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsMalayalam(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsMalayalam",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsMathematicalAlphanumericSymbols(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsMathematicalAlphanumericSymbols(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsMathematicalAlphanumericSymbols",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsMathematicalOperators(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsMathematicalOperators(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsMathematicalOperators",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsMiscellaneousMathematicalSymbolsA(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsA(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsA",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsMiscellaneousMathematicalSymbolsB(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsB(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsB",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsMiscellaneousSymbols(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsMiscellaneousSymbols(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbols",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsMiscellaneousSymbolsandArrows(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsMiscellaneousSymbolsandArrows(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbolsandArrows",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsMiscellaneousTechnical(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsMiscellaneousTechnical(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsMiscellaneousTechnical",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsMongolian(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsMongolian(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsMongolian",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsMusicalSymbols(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsMusicalSymbols(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsMusicalSymbols",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsMyanmar(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsMyanmar(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsMyanmar",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsNumberForms(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsNumberForms(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsNumberForms",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsOgham(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsOgham(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsOgham",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsOldItalic(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsOldItalic(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsOldItalic",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsOpticalCharacterRecognition(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsOpticalCharacterRecognition(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsOpticalCharacterRecognition",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsOriya(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsOriya(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsOriya",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsOsmanya(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsOsmanya(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsOsmanya",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsPhoneticExtensions(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsPhoneticExtensions(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsPhoneticExtensions",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsPrivateUse(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsPrivateUse(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsPrivateUse",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsPrivateUseArea(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsPrivateUseArea(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsPrivateUseArea",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsRunic(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsRunic(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsRunic",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsShavian(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsShavian(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsShavian",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsSinhala(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsSinhala(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsSinhala",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsSmallFormVariants(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsSmallFormVariants(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsSmallFormVariants",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsSpacingModifierLetters(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsSpacingModifierLetters(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsSpacingModifierLetters",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsSpecials(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsSpecials(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsSpecials",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsSuperscriptsandSubscripts(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsSuperscriptsandSubscripts(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsSuperscriptsandSubscripts",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsSupplementalArrowsA(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsSupplementalArrowsA(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsA",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsSupplementalArrowsB(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsSupplementalArrowsB(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsB",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsSupplementalMathematicalOperators(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsSupplementalMathematicalOperators(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsSupplementalMathematicalOperators",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsSupplementaryPrivateUseAreaA(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsSupplementaryPrivateUseAreaA(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaA",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsSupplementaryPrivateUseAreaB(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsSupplementaryPrivateUseAreaB(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaB",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsSyriac(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsSyriac(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsSyriac",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsTagalog(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsTagalog(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsTagalog",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsTagbanwa(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsTagbanwa(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsTagbanwa",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsTags(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsTags(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsTags",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsTaiLe(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsTaiLe(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsTaiLe",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsTaiXuanJingSymbols(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsTaiXuanJingSymbols(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsTaiXuanJingSymbols",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsTamil(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsTamil(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsTamil",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsTelugu(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsTelugu(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsTelugu",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsThaana(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsThaana(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsThaana",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsThai(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsThai(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsThai",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsTibetan(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsTibetan(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsTibetan",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsUgaritic(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsUgaritic(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsUgaritic",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsUnifiedCanadianAboriginalSyllabics(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsUnifiedCanadianAboriginalSyllabics(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsUnifiedCanadianAboriginalSyllabics",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsVariationSelectors(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsVariationSelectors(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsVariationSelectors",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsVariationSelectorsSupplement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsVariationSelectorsSupplement(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsVariationSelectorsSupplement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsYiRadicals(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsYiRadicals(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsYiRadicals",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsYiSyllables(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsYiSyllables(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsYiSyllables",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlUCSIsYijingHexagramSymbols(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_UNICODE_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
int code; /* UCS code point */
|
|
int n_code;
|
|
|
|
for (n_code = 0;n_code < gen_nb_int;n_code++) {
|
|
mem_base = xmlMemBlocks();
|
|
code = gen_int(n_code, 0);
|
|
|
|
ret_val = xmlUCSIsYijingHexagramSymbols(code);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_int(n_code, code, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlUCSIsYijingHexagramSymbols",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_code);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlunicode(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xmlunicode : 166 of 166 functions ...\n");
|
|
test_ret += test_xmlUCSIsAegeanNumbers();
|
|
test_ret += test_xmlUCSIsAlphabeticPresentationForms();
|
|
test_ret += test_xmlUCSIsArabic();
|
|
test_ret += test_xmlUCSIsArabicPresentationFormsA();
|
|
test_ret += test_xmlUCSIsArabicPresentationFormsB();
|
|
test_ret += test_xmlUCSIsArmenian();
|
|
test_ret += test_xmlUCSIsArrows();
|
|
test_ret += test_xmlUCSIsBasicLatin();
|
|
test_ret += test_xmlUCSIsBengali();
|
|
test_ret += test_xmlUCSIsBlock();
|
|
test_ret += test_xmlUCSIsBlockElements();
|
|
test_ret += test_xmlUCSIsBopomofo();
|
|
test_ret += test_xmlUCSIsBopomofoExtended();
|
|
test_ret += test_xmlUCSIsBoxDrawing();
|
|
test_ret += test_xmlUCSIsBraillePatterns();
|
|
test_ret += test_xmlUCSIsBuhid();
|
|
test_ret += test_xmlUCSIsByzantineMusicalSymbols();
|
|
test_ret += test_xmlUCSIsCJKCompatibility();
|
|
test_ret += test_xmlUCSIsCJKCompatibilityForms();
|
|
test_ret += test_xmlUCSIsCJKCompatibilityIdeographs();
|
|
test_ret += test_xmlUCSIsCJKCompatibilityIdeographsSupplement();
|
|
test_ret += test_xmlUCSIsCJKRadicalsSupplement();
|
|
test_ret += test_xmlUCSIsCJKSymbolsandPunctuation();
|
|
test_ret += test_xmlUCSIsCJKUnifiedIdeographs();
|
|
test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionA();
|
|
test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionB();
|
|
test_ret += test_xmlUCSIsCat();
|
|
test_ret += test_xmlUCSIsCatC();
|
|
test_ret += test_xmlUCSIsCatCc();
|
|
test_ret += test_xmlUCSIsCatCf();
|
|
test_ret += test_xmlUCSIsCatCo();
|
|
test_ret += test_xmlUCSIsCatCs();
|
|
test_ret += test_xmlUCSIsCatL();
|
|
test_ret += test_xmlUCSIsCatLl();
|
|
test_ret += test_xmlUCSIsCatLm();
|
|
test_ret += test_xmlUCSIsCatLo();
|
|
test_ret += test_xmlUCSIsCatLt();
|
|
test_ret += test_xmlUCSIsCatLu();
|
|
test_ret += test_xmlUCSIsCatM();
|
|
test_ret += test_xmlUCSIsCatMc();
|
|
test_ret += test_xmlUCSIsCatMe();
|
|
test_ret += test_xmlUCSIsCatMn();
|
|
test_ret += test_xmlUCSIsCatN();
|
|
test_ret += test_xmlUCSIsCatNd();
|
|
test_ret += test_xmlUCSIsCatNl();
|
|
test_ret += test_xmlUCSIsCatNo();
|
|
test_ret += test_xmlUCSIsCatP();
|
|
test_ret += test_xmlUCSIsCatPc();
|
|
test_ret += test_xmlUCSIsCatPd();
|
|
test_ret += test_xmlUCSIsCatPe();
|
|
test_ret += test_xmlUCSIsCatPf();
|
|
test_ret += test_xmlUCSIsCatPi();
|
|
test_ret += test_xmlUCSIsCatPo();
|
|
test_ret += test_xmlUCSIsCatPs();
|
|
test_ret += test_xmlUCSIsCatS();
|
|
test_ret += test_xmlUCSIsCatSc();
|
|
test_ret += test_xmlUCSIsCatSk();
|
|
test_ret += test_xmlUCSIsCatSm();
|
|
test_ret += test_xmlUCSIsCatSo();
|
|
test_ret += test_xmlUCSIsCatZ();
|
|
test_ret += test_xmlUCSIsCatZl();
|
|
test_ret += test_xmlUCSIsCatZp();
|
|
test_ret += test_xmlUCSIsCatZs();
|
|
test_ret += test_xmlUCSIsCherokee();
|
|
test_ret += test_xmlUCSIsCombiningDiacriticalMarks();
|
|
test_ret += test_xmlUCSIsCombiningDiacriticalMarksforSymbols();
|
|
test_ret += test_xmlUCSIsCombiningHalfMarks();
|
|
test_ret += test_xmlUCSIsCombiningMarksforSymbols();
|
|
test_ret += test_xmlUCSIsControlPictures();
|
|
test_ret += test_xmlUCSIsCurrencySymbols();
|
|
test_ret += test_xmlUCSIsCypriotSyllabary();
|
|
test_ret += test_xmlUCSIsCyrillic();
|
|
test_ret += test_xmlUCSIsCyrillicSupplement();
|
|
test_ret += test_xmlUCSIsDeseret();
|
|
test_ret += test_xmlUCSIsDevanagari();
|
|
test_ret += test_xmlUCSIsDingbats();
|
|
test_ret += test_xmlUCSIsEnclosedAlphanumerics();
|
|
test_ret += test_xmlUCSIsEnclosedCJKLettersandMonths();
|
|
test_ret += test_xmlUCSIsEthiopic();
|
|
test_ret += test_xmlUCSIsGeneralPunctuation();
|
|
test_ret += test_xmlUCSIsGeometricShapes();
|
|
test_ret += test_xmlUCSIsGeorgian();
|
|
test_ret += test_xmlUCSIsGothic();
|
|
test_ret += test_xmlUCSIsGreek();
|
|
test_ret += test_xmlUCSIsGreekExtended();
|
|
test_ret += test_xmlUCSIsGreekandCoptic();
|
|
test_ret += test_xmlUCSIsGujarati();
|
|
test_ret += test_xmlUCSIsGurmukhi();
|
|
test_ret += test_xmlUCSIsHalfwidthandFullwidthForms();
|
|
test_ret += test_xmlUCSIsHangulCompatibilityJamo();
|
|
test_ret += test_xmlUCSIsHangulJamo();
|
|
test_ret += test_xmlUCSIsHangulSyllables();
|
|
test_ret += test_xmlUCSIsHanunoo();
|
|
test_ret += test_xmlUCSIsHebrew();
|
|
test_ret += test_xmlUCSIsHighPrivateUseSurrogates();
|
|
test_ret += test_xmlUCSIsHighSurrogates();
|
|
test_ret += test_xmlUCSIsHiragana();
|
|
test_ret += test_xmlUCSIsIPAExtensions();
|
|
test_ret += test_xmlUCSIsIdeographicDescriptionCharacters();
|
|
test_ret += test_xmlUCSIsKanbun();
|
|
test_ret += test_xmlUCSIsKangxiRadicals();
|
|
test_ret += test_xmlUCSIsKannada();
|
|
test_ret += test_xmlUCSIsKatakana();
|
|
test_ret += test_xmlUCSIsKatakanaPhoneticExtensions();
|
|
test_ret += test_xmlUCSIsKhmer();
|
|
test_ret += test_xmlUCSIsKhmerSymbols();
|
|
test_ret += test_xmlUCSIsLao();
|
|
test_ret += test_xmlUCSIsLatin1Supplement();
|
|
test_ret += test_xmlUCSIsLatinExtendedA();
|
|
test_ret += test_xmlUCSIsLatinExtendedAdditional();
|
|
test_ret += test_xmlUCSIsLatinExtendedB();
|
|
test_ret += test_xmlUCSIsLetterlikeSymbols();
|
|
test_ret += test_xmlUCSIsLimbu();
|
|
test_ret += test_xmlUCSIsLinearBIdeograms();
|
|
test_ret += test_xmlUCSIsLinearBSyllabary();
|
|
test_ret += test_xmlUCSIsLowSurrogates();
|
|
test_ret += test_xmlUCSIsMalayalam();
|
|
test_ret += test_xmlUCSIsMathematicalAlphanumericSymbols();
|
|
test_ret += test_xmlUCSIsMathematicalOperators();
|
|
test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsA();
|
|
test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsB();
|
|
test_ret += test_xmlUCSIsMiscellaneousSymbols();
|
|
test_ret += test_xmlUCSIsMiscellaneousSymbolsandArrows();
|
|
test_ret += test_xmlUCSIsMiscellaneousTechnical();
|
|
test_ret += test_xmlUCSIsMongolian();
|
|
test_ret += test_xmlUCSIsMusicalSymbols();
|
|
test_ret += test_xmlUCSIsMyanmar();
|
|
test_ret += test_xmlUCSIsNumberForms();
|
|
test_ret += test_xmlUCSIsOgham();
|
|
test_ret += test_xmlUCSIsOldItalic();
|
|
test_ret += test_xmlUCSIsOpticalCharacterRecognition();
|
|
test_ret += test_xmlUCSIsOriya();
|
|
test_ret += test_xmlUCSIsOsmanya();
|
|
test_ret += test_xmlUCSIsPhoneticExtensions();
|
|
test_ret += test_xmlUCSIsPrivateUse();
|
|
test_ret += test_xmlUCSIsPrivateUseArea();
|
|
test_ret += test_xmlUCSIsRunic();
|
|
test_ret += test_xmlUCSIsShavian();
|
|
test_ret += test_xmlUCSIsSinhala();
|
|
test_ret += test_xmlUCSIsSmallFormVariants();
|
|
test_ret += test_xmlUCSIsSpacingModifierLetters();
|
|
test_ret += test_xmlUCSIsSpecials();
|
|
test_ret += test_xmlUCSIsSuperscriptsandSubscripts();
|
|
test_ret += test_xmlUCSIsSupplementalArrowsA();
|
|
test_ret += test_xmlUCSIsSupplementalArrowsB();
|
|
test_ret += test_xmlUCSIsSupplementalMathematicalOperators();
|
|
test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaA();
|
|
test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaB();
|
|
test_ret += test_xmlUCSIsSyriac();
|
|
test_ret += test_xmlUCSIsTagalog();
|
|
test_ret += test_xmlUCSIsTagbanwa();
|
|
test_ret += test_xmlUCSIsTags();
|
|
test_ret += test_xmlUCSIsTaiLe();
|
|
test_ret += test_xmlUCSIsTaiXuanJingSymbols();
|
|
test_ret += test_xmlUCSIsTamil();
|
|
test_ret += test_xmlUCSIsTelugu();
|
|
test_ret += test_xmlUCSIsThaana();
|
|
test_ret += test_xmlUCSIsThai();
|
|
test_ret += test_xmlUCSIsTibetan();
|
|
test_ret += test_xmlUCSIsUgaritic();
|
|
test_ret += test_xmlUCSIsUnifiedCanadianAboriginalSyllabics();
|
|
test_ret += test_xmlUCSIsVariationSelectors();
|
|
test_ret += test_xmlUCSIsVariationSelectorsSupplement();
|
|
test_ret += test_xmlUCSIsYiRadicals();
|
|
test_ret += test_xmlUCSIsYiSyllables();
|
|
test_ret += test_xmlUCSIsYijingHexagramSymbols();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xmlunicode: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlNewTextWriter(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
xmlTextWriterPtr ret_val;
|
|
xmlOutputBufferPtr out; /* an xmlOutputBufferPtr */
|
|
int n_out;
|
|
|
|
for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
|
|
mem_base = xmlMemBlocks();
|
|
out = gen_xmlOutputBufferPtr(n_out, 0);
|
|
|
|
ret_val = xmlNewTextWriter(out);
|
|
if (ret_val != NULL) out = NULL;
|
|
desret_xmlTextWriterPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlOutputBufferPtr(n_out, out, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewTextWriter",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_out);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewTextWriterFilename(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
xmlTextWriterPtr ret_val;
|
|
const char * uri; /* the URI of the resource for the output */
|
|
int n_uri;
|
|
int compression; /* compress the output? */
|
|
int n_compression;
|
|
|
|
for (n_uri = 0;n_uri < gen_nb_fileoutput;n_uri++) {
|
|
for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
|
|
mem_base = xmlMemBlocks();
|
|
uri = gen_fileoutput(n_uri, 0);
|
|
compression = gen_int(n_compression, 1);
|
|
|
|
ret_val = xmlNewTextWriterFilename(uri, compression);
|
|
desret_xmlTextWriterPtr(ret_val);
|
|
call_tests++;
|
|
des_fileoutput(n_uri, uri, 0);
|
|
des_int(n_compression, compression, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewTextWriterFilename",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_uri);
|
|
printf(" %d", n_compression);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewTextWriterMemory(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
xmlTextWriterPtr ret_val;
|
|
xmlBufferPtr buf; /* xmlBufferPtr */
|
|
int n_buf;
|
|
int compression; /* compress the output? */
|
|
int n_compression;
|
|
|
|
for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
|
|
for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
|
|
mem_base = xmlMemBlocks();
|
|
buf = gen_xmlBufferPtr(n_buf, 0);
|
|
compression = gen_int(n_compression, 1);
|
|
|
|
ret_val = xmlNewTextWriterMemory(buf, compression);
|
|
desret_xmlTextWriterPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlBufferPtr(n_buf, buf, 0);
|
|
des_int(n_compression, compression, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewTextWriterMemory",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_buf);
|
|
printf(" %d", n_compression);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewTextWriterPushParser(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
xmlTextWriterPtr ret_val;
|
|
xmlParserCtxtPtr ctxt; /* xmlParserCtxtPtr to hold the new XML document tree */
|
|
int n_ctxt;
|
|
int compression; /* compress the output? */
|
|
int n_compression;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
|
|
for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
|
|
compression = gen_int(n_compression, 1);
|
|
|
|
ret_val = xmlNewTextWriterPushParser(ctxt, compression);
|
|
if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} if (ret_val != NULL) ctxt = NULL;
|
|
desret_xmlTextWriterPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_compression, compression, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewTextWriterPushParser",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_compression);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlNewTextWriterTree(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
xmlTextWriterPtr ret_val;
|
|
xmlDocPtr doc; /* xmlDocPtr */
|
|
int n_doc;
|
|
xmlNodePtr node; /* xmlNodePtr or NULL for doc->children */
|
|
int n_node;
|
|
int compression; /* compress the output? */
|
|
int n_compression;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
compression = gen_int(n_compression, 2);
|
|
|
|
ret_val = xmlNewTextWriterTree(doc, node, compression);
|
|
desret_xmlTextWriterPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
des_int(n_compression, compression, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlNewTextWriterTree",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_compression);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterEndAttribute(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterEndAttribute(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterEndAttribute",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterEndCDATA(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterEndCDATA(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterEndCDATA",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterEndComment(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterEndComment(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterEndComment",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterEndDTD(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterEndDTD(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterEndDTD",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterEndDTDAttlist(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterEndDTDAttlist(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterEndDTDAttlist",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterEndDTDElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterEndDTDElement(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterEndDTDElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterEndDTDEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterEndDTDEntity(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterEndDTDEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterEndDocument(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterEndDocument(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterEndDocument",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterEndElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterEndElement(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterEndElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterEndPI(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterEndPI(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterEndPI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterFlush(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterFlush(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterFlush",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterFullEndElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterFullEndElement(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterFullEndElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterSetIndent(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
int indent; /* do indentation? */
|
|
int n_indent;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_indent = 0;n_indent < gen_nb_int;n_indent++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
indent = gen_int(n_indent, 1);
|
|
|
|
ret_val = xmlTextWriterSetIndent(writer, indent);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_int(n_indent, indent, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterSetIndent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_indent);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterSetIndentString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * str; /* the xmlChar string */
|
|
int n_str;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
str = gen_const_xmlChar_ptr(n_str, 1);
|
|
|
|
ret_val = xmlTextWriterSetIndentString(writer, str);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_str, str, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterSetIndentString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterSetQuoteChar(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
xmlChar quotechar; /* the quote character */
|
|
int n_quotechar;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_quotechar = 0;n_quotechar < gen_nb_xmlChar;n_quotechar++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
quotechar = gen_xmlChar(n_quotechar, 1);
|
|
|
|
ret_val = xmlTextWriterSetQuoteChar(writer, quotechar);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_xmlChar(n_quotechar, quotechar, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterSetQuoteChar",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_quotechar);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterStartAttribute(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * name; /* element name */
|
|
int n_name;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlTextWriterStartAttribute(writer, name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterStartAttribute",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterStartAttributeNS(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * prefix; /* namespace prefix or NULL */
|
|
int n_prefix;
|
|
const xmlChar * name; /* element local name */
|
|
int n_name;
|
|
const xmlChar * namespaceURI; /* namespace URI or NULL */
|
|
int n_namespaceURI;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
|
|
|
|
ret_val = xmlTextWriterStartAttributeNS(writer, prefix, name, namespaceURI);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_namespaceURI, namespaceURI, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterStartAttributeNS",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_namespaceURI);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterStartCDATA(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterStartCDATA(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterStartCDATA",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterStartComment(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
|
|
ret_val = xmlTextWriterStartComment(writer);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterStartComment",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterStartDTD(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * name; /* the name of the DTD */
|
|
int n_name;
|
|
const xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
|
|
int n_pubid;
|
|
const xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
|
|
int n_sysid;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
|
|
for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
pubid = gen_const_xmlChar_ptr(n_pubid, 2);
|
|
sysid = gen_const_xmlChar_ptr(n_sysid, 3);
|
|
|
|
ret_val = xmlTextWriterStartDTD(writer, name, pubid, sysid);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_pubid, pubid, 2);
|
|
des_const_xmlChar_ptr(n_sysid, sysid, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterStartDTD",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_pubid);
|
|
printf(" %d", n_sysid);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterStartDTDAttlist(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * name; /* the name of the DTD ATTLIST */
|
|
int n_name;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlTextWriterStartDTDAttlist(writer, name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterStartDTDAttlist",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterStartDTDElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * name; /* the name of the DTD element */
|
|
int n_name;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlTextWriterStartDTDElement(writer, name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterStartDTDElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterStartDTDEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
int pe; /* TRUE if this is a parameter entity, FALSE if not */
|
|
int n_pe;
|
|
const xmlChar * name; /* the name of the DTD ATTLIST */
|
|
int n_name;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
pe = gen_int(n_pe, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
|
|
ret_val = xmlTextWriterStartDTDEntity(writer, pe, name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_int(n_pe, pe, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterStartDTDEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_pe);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterStartDocument(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const char * version; /* the xml version ("1.0") or NULL for default ("1.0") */
|
|
int n_version;
|
|
const char * encoding; /* the encoding or NULL for default */
|
|
int n_encoding;
|
|
const char * standalone; /* "yes" or "no" or NULL for default */
|
|
int n_standalone;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_version = 0;n_version < gen_nb_const_char_ptr;n_version++) {
|
|
for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
|
|
for (n_standalone = 0;n_standalone < gen_nb_const_char_ptr;n_standalone++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
version = gen_const_char_ptr(n_version, 1);
|
|
encoding = gen_const_char_ptr(n_encoding, 2);
|
|
standalone = gen_const_char_ptr(n_standalone, 3);
|
|
|
|
ret_val = xmlTextWriterStartDocument(writer, version, encoding, standalone);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_char_ptr(n_version, version, 1);
|
|
des_const_char_ptr(n_encoding, encoding, 2);
|
|
des_const_char_ptr(n_standalone, standalone, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterStartDocument",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_version);
|
|
printf(" %d", n_encoding);
|
|
printf(" %d", n_standalone);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterStartElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * name; /* element name */
|
|
int n_name;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlTextWriterStartElement(writer, name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterStartElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterStartElementNS(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * prefix; /* namespace prefix or NULL */
|
|
int n_prefix;
|
|
const xmlChar * name; /* element local name */
|
|
int n_name;
|
|
const xmlChar * namespaceURI; /* namespace URI or NULL */
|
|
int n_namespaceURI;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
|
|
|
|
ret_val = xmlTextWriterStartElementNS(writer, prefix, name, namespaceURI);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_namespaceURI, namespaceURI, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterStartElementNS",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_namespaceURI);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterStartPI(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * target; /* PI target */
|
|
int n_target;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
target = gen_const_xmlChar_ptr(n_target, 1);
|
|
|
|
ret_val = xmlTextWriterStartPI(writer, target);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_target, target, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterStartPI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_target);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteAttribute(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * name; /* attribute name */
|
|
int n_name;
|
|
const xmlChar * content; /* attribute content */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
content = gen_const_xmlChar_ptr(n_content, 2);
|
|
|
|
ret_val = xmlTextWriterWriteAttribute(writer, name, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_content, content, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteAttribute",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteAttributeNS(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * prefix; /* namespace prefix */
|
|
int n_prefix;
|
|
const xmlChar * name; /* attribute local name */
|
|
int n_name;
|
|
const xmlChar * namespaceURI; /* namespace URI */
|
|
int n_namespaceURI;
|
|
const xmlChar * content; /* attribute content */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
|
|
content = gen_const_xmlChar_ptr(n_content, 4);
|
|
|
|
ret_val = xmlTextWriterWriteAttributeNS(writer, prefix, name, namespaceURI, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_namespaceURI, namespaceURI, 3);
|
|
des_const_xmlChar_ptr(n_content, content, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteAttributeNS",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_namespaceURI);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteBase64(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const char * data; /* binary data */
|
|
int n_data;
|
|
int start; /* the position within the data of the first byte to encode */
|
|
int n_start;
|
|
int len; /* the number of bytes to encode */
|
|
int n_len;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
|
|
for (n_start = 0;n_start < gen_nb_int;n_start++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
data = gen_const_char_ptr(n_data, 1);
|
|
start = gen_int(n_start, 2);
|
|
len = gen_int(n_len, 3);
|
|
if ((data != NULL) &&
|
|
(start > xmlStrlen(BAD_CAST data)))
|
|
start = 0;
|
|
if ((data != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST data)))
|
|
len = 0;
|
|
|
|
ret_val = xmlTextWriterWriteBase64(writer, data, start, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_char_ptr(n_data, data, 1);
|
|
des_int(n_start, start, 2);
|
|
des_int(n_len, len, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteBase64",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_data);
|
|
printf(" %d", n_start);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteBinHex(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const char * data; /* binary data */
|
|
int n_data;
|
|
int start; /* the position within the data of the first byte to encode */
|
|
int n_start;
|
|
int len; /* the number of bytes to encode */
|
|
int n_len;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
|
|
for (n_start = 0;n_start < gen_nb_int;n_start++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
data = gen_const_char_ptr(n_data, 1);
|
|
start = gen_int(n_start, 2);
|
|
len = gen_int(n_len, 3);
|
|
if ((data != NULL) &&
|
|
(start > xmlStrlen(BAD_CAST data)))
|
|
start = 0;
|
|
if ((data != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST data)))
|
|
len = 0;
|
|
|
|
ret_val = xmlTextWriterWriteBinHex(writer, data, start, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_char_ptr(n_data, data, 1);
|
|
des_int(n_start, start, 2);
|
|
des_int(n_len, len, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteBinHex",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_data);
|
|
printf(" %d", n_start);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteCDATA(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * content; /* CDATA content */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
|
|
ret_val = xmlTextWriterWriteCDATA(writer, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteCDATA",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteComment(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * content; /* comment string */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
|
|
ret_val = xmlTextWriterWriteComment(writer, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteComment",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteDTD(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * name; /* the name of the DTD */
|
|
int n_name;
|
|
const xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
|
|
int n_pubid;
|
|
const xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
|
|
int n_sysid;
|
|
const xmlChar * subset; /* string content of the DTD */
|
|
int n_subset;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
|
|
for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
|
|
for (n_subset = 0;n_subset < gen_nb_const_xmlChar_ptr;n_subset++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
pubid = gen_const_xmlChar_ptr(n_pubid, 2);
|
|
sysid = gen_const_xmlChar_ptr(n_sysid, 3);
|
|
subset = gen_const_xmlChar_ptr(n_subset, 4);
|
|
|
|
ret_val = xmlTextWriterWriteDTD(writer, name, pubid, sysid, subset);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_pubid, pubid, 2);
|
|
des_const_xmlChar_ptr(n_sysid, sysid, 3);
|
|
des_const_xmlChar_ptr(n_subset, subset, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteDTD",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_pubid);
|
|
printf(" %d", n_sysid);
|
|
printf(" %d", n_subset);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteDTDAttlist(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * name; /* the name of the DTD ATTLIST */
|
|
int n_name;
|
|
const xmlChar * content; /* content of the ATTLIST */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
content = gen_const_xmlChar_ptr(n_content, 2);
|
|
|
|
ret_val = xmlTextWriterWriteDTDAttlist(writer, name, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_content, content, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteDTDAttlist",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteDTDElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * name; /* the name of the DTD element */
|
|
int n_name;
|
|
const xmlChar * content; /* content of the element */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
content = gen_const_xmlChar_ptr(n_content, 2);
|
|
|
|
ret_val = xmlTextWriterWriteDTDElement(writer, name, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_content, content, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteDTDElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteDTDEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
int pe; /* TRUE if this is a parameter entity, FALSE if not */
|
|
int n_pe;
|
|
const xmlChar * name; /* the name of the DTD entity */
|
|
int n_name;
|
|
const xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
|
|
int n_pubid;
|
|
const xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
|
|
int n_sysid;
|
|
const xmlChar * ndataid; /* the xml notation name. */
|
|
int n_ndataid;
|
|
const xmlChar * content; /* content of the entity */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
|
|
for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
|
|
for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
pe = gen_int(n_pe, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
pubid = gen_const_xmlChar_ptr(n_pubid, 3);
|
|
sysid = gen_const_xmlChar_ptr(n_sysid, 4);
|
|
ndataid = gen_const_xmlChar_ptr(n_ndataid, 5);
|
|
content = gen_const_xmlChar_ptr(n_content, 6);
|
|
|
|
ret_val = xmlTextWriterWriteDTDEntity(writer, pe, name, pubid, sysid, ndataid, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_int(n_pe, pe, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_pubid, pubid, 3);
|
|
des_const_xmlChar_ptr(n_sysid, sysid, 4);
|
|
des_const_xmlChar_ptr(n_ndataid, ndataid, 5);
|
|
des_const_xmlChar_ptr(n_content, content, 6);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteDTDEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_pe);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_pubid);
|
|
printf(" %d", n_sysid);
|
|
printf(" %d", n_ndataid);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteDTDExternalEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
int pe; /* TRUE if this is a parameter entity, FALSE if not */
|
|
int n_pe;
|
|
const xmlChar * name; /* the name of the DTD entity */
|
|
int n_name;
|
|
const xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
|
|
int n_pubid;
|
|
const xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
|
|
int n_sysid;
|
|
const xmlChar * ndataid; /* the xml notation name. */
|
|
int n_ndataid;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
|
|
for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
|
|
for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
pe = gen_int(n_pe, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
pubid = gen_const_xmlChar_ptr(n_pubid, 3);
|
|
sysid = gen_const_xmlChar_ptr(n_sysid, 4);
|
|
ndataid = gen_const_xmlChar_ptr(n_ndataid, 5);
|
|
|
|
ret_val = xmlTextWriterWriteDTDExternalEntity(writer, pe, name, pubid, sysid, ndataid);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_int(n_pe, pe, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_pubid, pubid, 3);
|
|
des_const_xmlChar_ptr(n_sysid, sysid, 4);
|
|
des_const_xmlChar_ptr(n_ndataid, ndataid, 5);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_pe);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_pubid);
|
|
printf(" %d", n_sysid);
|
|
printf(" %d", n_ndataid);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteDTDExternalEntityContents(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
|
|
int n_pubid;
|
|
const xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
|
|
int n_sysid;
|
|
const xmlChar * ndataid; /* the xml notation name. */
|
|
int n_ndataid;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
|
|
for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
|
|
for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
pubid = gen_const_xmlChar_ptr(n_pubid, 1);
|
|
sysid = gen_const_xmlChar_ptr(n_sysid, 2);
|
|
ndataid = gen_const_xmlChar_ptr(n_ndataid, 3);
|
|
|
|
ret_val = xmlTextWriterWriteDTDExternalEntityContents(writer, pubid, sysid, ndataid);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_pubid, pubid, 1);
|
|
des_const_xmlChar_ptr(n_sysid, sysid, 2);
|
|
des_const_xmlChar_ptr(n_ndataid, ndataid, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntityContents",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_pubid);
|
|
printf(" %d", n_sysid);
|
|
printf(" %d", n_ndataid);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteDTDInternalEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
int pe; /* TRUE if this is a parameter entity, FALSE if not */
|
|
int n_pe;
|
|
const xmlChar * name; /* the name of the DTD entity */
|
|
int n_name;
|
|
const xmlChar * content; /* content of the entity */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
pe = gen_int(n_pe, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
content = gen_const_xmlChar_ptr(n_content, 3);
|
|
|
|
ret_val = xmlTextWriterWriteDTDInternalEntity(writer, pe, name, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_int(n_pe, pe, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_content, content, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteDTDInternalEntity",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_pe);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteDTDNotation(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * name; /* the name of the xml notation */
|
|
int n_name;
|
|
const xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
|
|
int n_pubid;
|
|
const xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
|
|
int n_sysid;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
|
|
for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
pubid = gen_const_xmlChar_ptr(n_pubid, 2);
|
|
sysid = gen_const_xmlChar_ptr(n_sysid, 3);
|
|
|
|
ret_val = xmlTextWriterWriteDTDNotation(writer, name, pubid, sysid);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_pubid, pubid, 2);
|
|
des_const_xmlChar_ptr(n_sysid, sysid, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteDTDNotation",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_pubid);
|
|
printf(" %d", n_sysid);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteElement(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * name; /* element name */
|
|
int n_name;
|
|
const xmlChar * content; /* element content */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
content = gen_const_xmlChar_ptr(n_content, 2);
|
|
|
|
ret_val = xmlTextWriterWriteElement(writer, name, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_content, content, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteElement",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteElementNS(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * prefix; /* namespace prefix */
|
|
int n_prefix;
|
|
const xmlChar * name; /* element local name */
|
|
int n_name;
|
|
const xmlChar * namespaceURI; /* namespace URI */
|
|
int n_namespaceURI;
|
|
const xmlChar * content; /* element content */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 1);
|
|
name = gen_const_xmlChar_ptr(n_name, 2);
|
|
namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
|
|
content = gen_const_xmlChar_ptr(n_content, 4);
|
|
|
|
ret_val = xmlTextWriterWriteElementNS(writer, prefix, name, namespaceURI, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 1);
|
|
des_const_xmlChar_ptr(n_name, name, 2);
|
|
des_const_xmlChar_ptr(n_namespaceURI, namespaceURI, 3);
|
|
des_const_xmlChar_ptr(n_content, content, 4);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteElementNS",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_namespaceURI);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatAttribute(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatAttributeNS(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatCDATA(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatComment(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatDTD(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatDTDAttlist(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatDTDElement(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatDTDInternalEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatElement(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatElementNS(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatPI(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatRaw(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteFormatString(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWritePI(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * target; /* PI target */
|
|
int n_target;
|
|
const xmlChar * content; /* PI content */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
target = gen_const_xmlChar_ptr(n_target, 1);
|
|
content = gen_const_xmlChar_ptr(n_content, 2);
|
|
|
|
ret_val = xmlTextWriterWritePI(writer, target, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_target, target, 1);
|
|
des_const_xmlChar_ptr(n_content, content, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWritePI",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_target);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteRaw(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * content; /* text string */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
|
|
ret_val = xmlTextWriterWriteRaw(writer, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteRaw",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteRawLen(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * content; /* text string */
|
|
int n_content;
|
|
int len; /* length of the text string */
|
|
int n_len;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
for (n_len = 0;n_len < gen_nb_int;n_len++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
len = gen_int(n_len, 2);
|
|
if ((content != NULL) &&
|
|
(len > xmlStrlen(BAD_CAST content)))
|
|
len = 0;
|
|
|
|
ret_val = xmlTextWriterWriteRawLen(writer, content, len);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
des_int(n_len, len, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteRawLen",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_content);
|
|
printf(" %d", n_len);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_WRITER_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
|
|
int n_writer;
|
|
const xmlChar * content; /* text string */
|
|
int n_content;
|
|
|
|
for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
|
|
for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
|
|
mem_base = xmlMemBlocks();
|
|
writer = gen_xmlTextWriterPtr(n_writer, 0);
|
|
content = gen_const_xmlChar_ptr(n_content, 1);
|
|
|
|
ret_val = xmlTextWriterWriteString(writer, content);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlTextWriterPtr(n_writer, writer, 0);
|
|
des_const_xmlChar_ptr(n_content, content, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlTextWriterWriteString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_writer);
|
|
printf(" %d", n_content);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatAttribute(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatAttributeNS(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatCDATA(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatComment(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatDTD(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatDTDAttlist(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatDTDElement(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatDTDInternalEntity(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatElement(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatElementNS(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatPI(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatRaw(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlTextWriterWriteVFormatString(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlwriter(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xmlwriter : 52 of 80 functions ...\n");
|
|
test_ret += test_xmlNewTextWriter();
|
|
test_ret += test_xmlNewTextWriterFilename();
|
|
test_ret += test_xmlNewTextWriterMemory();
|
|
test_ret += test_xmlNewTextWriterPushParser();
|
|
test_ret += test_xmlNewTextWriterTree();
|
|
test_ret += test_xmlTextWriterEndAttribute();
|
|
test_ret += test_xmlTextWriterEndCDATA();
|
|
test_ret += test_xmlTextWriterEndComment();
|
|
test_ret += test_xmlTextWriterEndDTD();
|
|
test_ret += test_xmlTextWriterEndDTDAttlist();
|
|
test_ret += test_xmlTextWriterEndDTDElement();
|
|
test_ret += test_xmlTextWriterEndDTDEntity();
|
|
test_ret += test_xmlTextWriterEndDocument();
|
|
test_ret += test_xmlTextWriterEndElement();
|
|
test_ret += test_xmlTextWriterEndPI();
|
|
test_ret += test_xmlTextWriterFlush();
|
|
test_ret += test_xmlTextWriterFullEndElement();
|
|
test_ret += test_xmlTextWriterSetIndent();
|
|
test_ret += test_xmlTextWriterSetIndentString();
|
|
test_ret += test_xmlTextWriterSetQuoteChar();
|
|
test_ret += test_xmlTextWriterStartAttribute();
|
|
test_ret += test_xmlTextWriterStartAttributeNS();
|
|
test_ret += test_xmlTextWriterStartCDATA();
|
|
test_ret += test_xmlTextWriterStartComment();
|
|
test_ret += test_xmlTextWriterStartDTD();
|
|
test_ret += test_xmlTextWriterStartDTDAttlist();
|
|
test_ret += test_xmlTextWriterStartDTDElement();
|
|
test_ret += test_xmlTextWriterStartDTDEntity();
|
|
test_ret += test_xmlTextWriterStartDocument();
|
|
test_ret += test_xmlTextWriterStartElement();
|
|
test_ret += test_xmlTextWriterStartElementNS();
|
|
test_ret += test_xmlTextWriterStartPI();
|
|
test_ret += test_xmlTextWriterWriteAttribute();
|
|
test_ret += test_xmlTextWriterWriteAttributeNS();
|
|
test_ret += test_xmlTextWriterWriteBase64();
|
|
test_ret += test_xmlTextWriterWriteBinHex();
|
|
test_ret += test_xmlTextWriterWriteCDATA();
|
|
test_ret += test_xmlTextWriterWriteComment();
|
|
test_ret += test_xmlTextWriterWriteDTD();
|
|
test_ret += test_xmlTextWriterWriteDTDAttlist();
|
|
test_ret += test_xmlTextWriterWriteDTDElement();
|
|
test_ret += test_xmlTextWriterWriteDTDEntity();
|
|
test_ret += test_xmlTextWriterWriteDTDExternalEntity();
|
|
test_ret += test_xmlTextWriterWriteDTDExternalEntityContents();
|
|
test_ret += test_xmlTextWriterWriteDTDInternalEntity();
|
|
test_ret += test_xmlTextWriterWriteDTDNotation();
|
|
test_ret += test_xmlTextWriterWriteElement();
|
|
test_ret += test_xmlTextWriterWriteElementNS();
|
|
test_ret += test_xmlTextWriterWriteFormatAttribute();
|
|
test_ret += test_xmlTextWriterWriteFormatAttributeNS();
|
|
test_ret += test_xmlTextWriterWriteFormatCDATA();
|
|
test_ret += test_xmlTextWriterWriteFormatComment();
|
|
test_ret += test_xmlTextWriterWriteFormatDTD();
|
|
test_ret += test_xmlTextWriterWriteFormatDTDAttlist();
|
|
test_ret += test_xmlTextWriterWriteFormatDTDElement();
|
|
test_ret += test_xmlTextWriterWriteFormatDTDInternalEntity();
|
|
test_ret += test_xmlTextWriterWriteFormatElement();
|
|
test_ret += test_xmlTextWriterWriteFormatElementNS();
|
|
test_ret += test_xmlTextWriterWriteFormatPI();
|
|
test_ret += test_xmlTextWriterWriteFormatRaw();
|
|
test_ret += test_xmlTextWriterWriteFormatString();
|
|
test_ret += test_xmlTextWriterWritePI();
|
|
test_ret += test_xmlTextWriterWriteRaw();
|
|
test_ret += test_xmlTextWriterWriteRawLen();
|
|
test_ret += test_xmlTextWriterWriteString();
|
|
test_ret += test_xmlTextWriterWriteVFormatAttribute();
|
|
test_ret += test_xmlTextWriterWriteVFormatAttributeNS();
|
|
test_ret += test_xmlTextWriterWriteVFormatCDATA();
|
|
test_ret += test_xmlTextWriterWriteVFormatComment();
|
|
test_ret += test_xmlTextWriterWriteVFormatDTD();
|
|
test_ret += test_xmlTextWriterWriteVFormatDTDAttlist();
|
|
test_ret += test_xmlTextWriterWriteVFormatDTDElement();
|
|
test_ret += test_xmlTextWriterWriteVFormatDTDInternalEntity();
|
|
test_ret += test_xmlTextWriterWriteVFormatElement();
|
|
test_ret += test_xmlTextWriterWriteVFormatElementNS();
|
|
test_ret += test_xmlTextWriterWriteVFormatPI();
|
|
test_ret += test_xmlTextWriterWriteVFormatRaw();
|
|
test_ret += test_xmlTextWriterWriteVFormatString();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xmlwriter: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlXPathCastBooleanToNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
double ret_val;
|
|
int val; /* a boolean */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_int;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_int(n_val, 0);
|
|
|
|
ret_val = xmlXPathCastBooleanToNumber(val);
|
|
desret_double(ret_val);
|
|
call_tests++;
|
|
des_int(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastBooleanToNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastBooleanToString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
int val; /* a boolean */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_int;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_int(n_val, 0);
|
|
|
|
ret_val = xmlXPathCastBooleanToString(val);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_int(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastBooleanToString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastNodeSetToBoolean(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodeSetPtr ns; /* a node-set */
|
|
int n_ns;
|
|
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
|
|
mem_base = xmlMemBlocks();
|
|
ns = gen_xmlNodeSetPtr(n_ns, 0);
|
|
|
|
ret_val = xmlXPathCastNodeSetToBoolean(ns);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_ns, ns, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastNodeSetToBoolean",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ns);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastNodeSetToNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
double ret_val;
|
|
xmlNodeSetPtr ns; /* a node-set */
|
|
int n_ns;
|
|
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
|
|
mem_base = xmlMemBlocks();
|
|
ns = gen_xmlNodeSetPtr(n_ns, 0);
|
|
|
|
ret_val = xmlXPathCastNodeSetToNumber(ns);
|
|
desret_double(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_ns, ns, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastNodeSetToNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ns);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastNodeSetToString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlNodeSetPtr ns; /* a node-set */
|
|
int n_ns;
|
|
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
|
|
mem_base = xmlMemBlocks();
|
|
ns = gen_xmlNodeSetPtr(n_ns, 0);
|
|
|
|
ret_val = xmlXPathCastNodeSetToString(ns);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_ns, ns, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastNodeSetToString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ns);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastNodeToNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
double ret_val;
|
|
xmlNodePtr node; /* a node */
|
|
int n_node;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
|
|
ret_val = xmlXPathCastNodeToNumber(node);
|
|
desret_double(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastNodeToNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastNodeToString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlNodePtr node; /* a node */
|
|
int n_node;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
|
|
ret_val = xmlXPathCastNodeToString(node);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastNodeToString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastNumberToBoolean(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
double val; /* a number */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_double;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_double(n_val, 0);
|
|
|
|
ret_val = xmlXPathCastNumberToBoolean(val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_double(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastNumberToBoolean",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastNumberToString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
double val; /* a number */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_double;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_double(n_val, 0);
|
|
|
|
ret_val = xmlXPathCastNumberToString(val);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_double(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastNumberToString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastStringToBoolean(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * val; /* a string */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_const_xmlChar_ptr(n_val, 0);
|
|
|
|
ret_val = xmlXPathCastStringToBoolean(val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastStringToBoolean",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastStringToNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
double ret_val;
|
|
const xmlChar * val; /* a string */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_const_xmlChar_ptr(n_val, 0);
|
|
|
|
ret_val = xmlXPathCastStringToNumber(val);
|
|
desret_double(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastStringToNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastToBoolean(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathObjectPtr val; /* an XPath object */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlXPathObjectPtr(n_val, 0);
|
|
|
|
ret_val = xmlXPathCastToBoolean(val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathObjectPtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastToBoolean",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastToNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
double ret_val;
|
|
xmlXPathObjectPtr val; /* an XPath object */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlXPathObjectPtr(n_val, 0);
|
|
|
|
ret_val = xmlXPathCastToNumber(val);
|
|
desret_double(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathObjectPtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastToNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCastToString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlXPathObjectPtr val; /* an XPath object */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlXPathObjectPtr(n_val, 0);
|
|
|
|
ret_val = xmlXPathCastToString(val);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathObjectPtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCastToString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCmpNodes(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodePtr node1; /* the first node */
|
|
int n_node1;
|
|
xmlNodePtr node2; /* the second node */
|
|
int n_node2;
|
|
|
|
for (n_node1 = 0;n_node1 < gen_nb_xmlNodePtr;n_node1++) {
|
|
for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
|
|
mem_base = xmlMemBlocks();
|
|
node1 = gen_xmlNodePtr(n_node1, 0);
|
|
node2 = gen_xmlNodePtr(n_node2, 1);
|
|
|
|
ret_val = xmlXPathCmpNodes(node1, node2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node1, node1, 0);
|
|
des_xmlNodePtr(n_node2, node2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCmpNodes",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node1);
|
|
printf(" %d", n_node2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCompile(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
#ifdef LIBXML_XPATH_ENABLED
|
|
|
|
#define gen_nb_xmlXPathCompExprPtr 1
|
|
#define gen_xmlXPathCompExprPtr(no, nr) NULL
|
|
#define des_xmlXPathCompExprPtr(no, val, nr)
|
|
#endif
|
|
|
|
#ifdef LIBXML_XPATH_ENABLED
|
|
|
|
#define gen_nb_xmlXPathContextPtr 1
|
|
#define gen_xmlXPathContextPtr(no, nr) NULL
|
|
#define des_xmlXPathContextPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_xmlXPathCompiledEval(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlXPathCompExprPtr comp; /* the compiled XPath expression */
|
|
int n_comp;
|
|
xmlXPathContextPtr ctx; /* the XPath context */
|
|
int n_ctx;
|
|
|
|
for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
comp = gen_xmlXPathCompExprPtr(n_comp, 0);
|
|
ctx = gen_xmlXPathContextPtr(n_ctx, 1);
|
|
|
|
ret_val = xmlXPathCompiledEval(comp, ctx);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathCompExprPtr(n_comp, comp, 0);
|
|
des_xmlXPathContextPtr(n_ctx, ctx, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCompiledEval",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_comp);
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCompiledEvalToBoolean(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathCompExprPtr comp; /* the compiled XPath expression */
|
|
int n_comp;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
|
|
for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
comp = gen_xmlXPathCompExprPtr(n_comp, 0);
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 1);
|
|
|
|
ret_val = xmlXPathCompiledEvalToBoolean(comp, ctxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathCompExprPtr(n_comp, comp, 0);
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCompiledEvalToBoolean",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_comp);
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathContextSetCache(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
int active; /* enables/disables (creates/frees) the cache */
|
|
int n_active;
|
|
int value; /* a value with semantics dependent on @options */
|
|
int n_value;
|
|
int options; /* options (currently only the value 0 is used) */
|
|
int n_options;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
for (n_active = 0;n_active < gen_nb_int;n_active++) {
|
|
for (n_value = 0;n_value < gen_nb_int;n_value++) {
|
|
for (n_options = 0;n_options < gen_nb_int;n_options++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
|
|
active = gen_int(n_active, 1);
|
|
value = gen_int(n_value, 2);
|
|
options = gen_int(n_options, 3);
|
|
|
|
ret_val = xmlXPathContextSetCache(ctxt, active, value, options);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_active, active, 1);
|
|
des_int(n_value, value, 2);
|
|
des_int(n_options, options, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathContextSetCache",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_active);
|
|
printf(" %d", n_value);
|
|
printf(" %d", n_options);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathConvertBoolean(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlXPathObjectPtr val; /* an XPath object */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlXPathObjectPtr(n_val, 0);
|
|
|
|
ret_val = xmlXPathConvertBoolean(val);
|
|
val = NULL;
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathObjectPtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathConvertBoolean",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathConvertNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlXPathObjectPtr val; /* an XPath object */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlXPathObjectPtr(n_val, 0);
|
|
|
|
ret_val = xmlXPathConvertNumber(val);
|
|
val = NULL;
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathObjectPtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathConvertNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathConvertString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlXPathObjectPtr val; /* an XPath object */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlXPathObjectPtr(n_val, 0);
|
|
|
|
ret_val = xmlXPathConvertString(val);
|
|
val = NULL;
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathObjectPtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathConvertString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCtxtCompile(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathEval(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
const xmlChar * str; /* the XPath expression */
|
|
int n_str;
|
|
xmlXPathContextPtr ctx; /* the XPath context */
|
|
int n_ctx;
|
|
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
str = gen_const_xmlChar_ptr(n_str, 0);
|
|
ctx = gen_xmlXPathContextPtr(n_ctx, 1);
|
|
|
|
ret_val = xmlXPathEval(str, ctx);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str, str, 0);
|
|
des_xmlXPathContextPtr(n_ctx, ctx, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathEval",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathEvalExpression(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
const xmlChar * str; /* the XPath expression */
|
|
int n_str;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
str = gen_const_xmlChar_ptr(n_str, 0);
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 1);
|
|
|
|
ret_val = xmlXPathEvalExpression(str, ctxt);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str, str, 0);
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathEvalExpression",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathEvalPredicate(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */
|
|
int n_res;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
|
|
res = gen_xmlXPathObjectPtr(n_res, 1);
|
|
|
|
ret_val = xmlXPathEvalPredicate(ctxt, res);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlXPathObjectPtr(n_res, res, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathEvalPredicate",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_res);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathInit(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
|
|
mem_base = xmlMemBlocks();
|
|
|
|
xmlXPathInit();
|
|
call_tests++;
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathInit",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf("\n");
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathIsInf(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
double val; /* a double value */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_double;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_double(n_val, 0);
|
|
|
|
ret_val = xmlXPathIsInf(val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_double(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathIsInf",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathIsNaN(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
double val; /* a double value */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_double;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_double(n_val, 0);
|
|
|
|
ret_val = xmlXPathIsNaN(val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_double(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathIsNaN",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNewContext(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeEval(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlNodePtr node; /* the node to to use as the context node */
|
|
int n_node;
|
|
const xmlChar * str; /* the XPath expression */
|
|
int n_str;
|
|
xmlXPathContextPtr ctx; /* the XPath context */
|
|
int n_ctx;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
str = gen_const_xmlChar_ptr(n_str, 1);
|
|
ctx = gen_xmlXPathContextPtr(n_ctx, 2);
|
|
|
|
ret_val = xmlXPathNodeEval(node, str, ctx);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_const_xmlChar_ptr(n_str, str, 1);
|
|
des_xmlXPathContextPtr(n_ctx, ctx, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeEval",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeSetCreate(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodePtr val; /* an initial xmlNodePtr, or NULL */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlNodePtr(n_val, 0);
|
|
|
|
ret_val = xmlXPathNodeSetCreate(val);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeSetCreate",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathObjectCopy(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlXPathObjectPtr val; /* the original object */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlXPathObjectPtr(n_val, 0);
|
|
|
|
ret_val = xmlXPathObjectCopy(val);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathObjectPtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathObjectCopy",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathOrderDocElems(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
long ret_val;
|
|
xmlDocPtr doc; /* an input document */
|
|
int n_doc;
|
|
|
|
for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
|
|
mem_base = xmlMemBlocks();
|
|
doc = gen_xmlDocPtr(n_doc, 0);
|
|
|
|
ret_val = xmlXPathOrderDocElems(doc);
|
|
desret_long(ret_val);
|
|
call_tests++;
|
|
des_xmlDocPtr(n_doc, doc, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathOrderDocElems",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_doc);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathSetContextNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodePtr node; /* the node to to use as the context node */
|
|
int n_node;
|
|
xmlXPathContextPtr ctx; /* the XPath context */
|
|
int n_ctx;
|
|
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
node = gen_xmlNodePtr(n_node, 0);
|
|
ctx = gen_xmlXPathContextPtr(n_ctx, 1);
|
|
|
|
ret_val = xmlXPathSetContextNode(node, ctx);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_node, node, 0);
|
|
des_xmlXPathContextPtr(n_ctx, ctx, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathSetContextNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xpath(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xpath : 32 of 40 functions ...\n");
|
|
test_ret += test_xmlXPathCastBooleanToNumber();
|
|
test_ret += test_xmlXPathCastBooleanToString();
|
|
test_ret += test_xmlXPathCastNodeSetToBoolean();
|
|
test_ret += test_xmlXPathCastNodeSetToNumber();
|
|
test_ret += test_xmlXPathCastNodeSetToString();
|
|
test_ret += test_xmlXPathCastNodeToNumber();
|
|
test_ret += test_xmlXPathCastNodeToString();
|
|
test_ret += test_xmlXPathCastNumberToBoolean();
|
|
test_ret += test_xmlXPathCastNumberToString();
|
|
test_ret += test_xmlXPathCastStringToBoolean();
|
|
test_ret += test_xmlXPathCastStringToNumber();
|
|
test_ret += test_xmlXPathCastToBoolean();
|
|
test_ret += test_xmlXPathCastToNumber();
|
|
test_ret += test_xmlXPathCastToString();
|
|
test_ret += test_xmlXPathCmpNodes();
|
|
test_ret += test_xmlXPathCompile();
|
|
test_ret += test_xmlXPathCompiledEval();
|
|
test_ret += test_xmlXPathCompiledEvalToBoolean();
|
|
test_ret += test_xmlXPathContextSetCache();
|
|
test_ret += test_xmlXPathConvertBoolean();
|
|
test_ret += test_xmlXPathConvertNumber();
|
|
test_ret += test_xmlXPathConvertString();
|
|
test_ret += test_xmlXPathCtxtCompile();
|
|
test_ret += test_xmlXPathEval();
|
|
test_ret += test_xmlXPathEvalExpression();
|
|
test_ret += test_xmlXPathEvalPredicate();
|
|
test_ret += test_xmlXPathInit();
|
|
test_ret += test_xmlXPathIsInf();
|
|
test_ret += test_xmlXPathIsNaN();
|
|
test_ret += test_xmlXPathNewContext();
|
|
test_ret += test_xmlXPathNodeEval();
|
|
test_ret += test_xmlXPathNodeSetCreate();
|
|
test_ret += test_xmlXPathObjectCopy();
|
|
test_ret += test_xmlXPathOrderDocElems();
|
|
test_ret += test_xmlXPathSetContextNode();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xpath: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
#ifdef LIBXML_XPATH_ENABLED
|
|
|
|
#define gen_nb_xmlXPathParserContextPtr 1
|
|
#define gen_xmlXPathParserContextPtr(no, nr) NULL
|
|
#define des_xmlXPathParserContextPtr(no, val, nr)
|
|
#endif
|
|
|
|
|
|
static int
|
|
test_valuePop(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
ret_val = valuePop(ctxt);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in valuePop",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_valuePush(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */
|
|
int n_ctxt;
|
|
xmlXPathObjectPtr value; /* the XPath object */
|
|
int n_value;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
value = gen_xmlXPathObjectPtr(n_value, 1);
|
|
|
|
ret_val = valuePush(ctxt, value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlXPathObjectPtr(n_value, value, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in valuePush",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathAddValues(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPathAddValues(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathAddValues",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathBooleanFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathBooleanFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathBooleanFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCeilingFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathCeilingFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCeilingFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCompareValues(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int inf; /* less than (1) or greater than (0) */
|
|
int n_inf;
|
|
int strict; /* is the comparison strict */
|
|
int n_strict;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_inf = 0;n_inf < gen_nb_int;n_inf++) {
|
|
for (n_strict = 0;n_strict < gen_nb_int;n_strict++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
inf = gen_int(n_inf, 1);
|
|
strict = gen_int(n_strict, 2);
|
|
|
|
ret_val = xmlXPathCompareValues(ctxt, inf, strict);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_inf, inf, 1);
|
|
des_int(n_strict, strict, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCompareValues",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_inf);
|
|
printf(" %d", n_strict);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathConcatFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathConcatFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathConcatFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathContainsFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathContainsFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathContainsFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathCountFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathCountFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathCountFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathDebugDumpCompExpr(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * for the output */
|
|
int n_output;
|
|
xmlXPathCompExprPtr comp; /* the precompiled XPath expression */
|
|
int n_comp;
|
|
int depth; /* the indentation level. */
|
|
int n_depth;
|
|
|
|
for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
|
|
for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
|
|
for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_FILE_ptr(n_output, 0);
|
|
comp = gen_xmlXPathCompExprPtr(n_comp, 1);
|
|
depth = gen_int(n_depth, 2);
|
|
|
|
xmlXPathDebugDumpCompExpr(output, comp, depth);
|
|
call_tests++;
|
|
des_FILE_ptr(n_output, output, 0);
|
|
des_xmlXPathCompExprPtr(n_comp, comp, 1);
|
|
des_int(n_depth, depth, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathDebugDumpCompExpr",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_comp);
|
|
printf(" %d", n_depth);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathDebugDumpObject(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
|
|
int mem_base;
|
|
FILE * output; /* the FILE * to dump the output */
|
|
int n_output;
|
|
xmlXPathObjectPtr cur; /* the object to inspect */
|
|
int n_cur;
|
|
int depth; /* indentation level */
|
|
int n_depth;
|
|
|
|
for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlXPathObjectPtr;n_cur++) {
|
|
for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
|
|
mem_base = xmlMemBlocks();
|
|
output = gen_FILE_ptr(n_output, 0);
|
|
cur = gen_xmlXPathObjectPtr(n_cur, 1);
|
|
depth = gen_int(n_depth, 2);
|
|
|
|
xmlXPathDebugDumpObject(output, cur, depth);
|
|
call_tests++;
|
|
des_FILE_ptr(n_output, output, 0);
|
|
des_xmlXPathObjectPtr(n_cur, cur, 1);
|
|
des_int(n_depth, depth, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathDebugDumpObject",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_output);
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_depth);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathDifference(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr nodes1; /* a node-set */
|
|
int n_nodes1;
|
|
xmlNodeSetPtr nodes2; /* a node-set */
|
|
int n_nodes2;
|
|
|
|
for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
|
|
for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
|
|
nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
|
|
|
|
ret_val = xmlXPathDifference(nodes1, nodes2);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
|
|
des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathDifference",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes1);
|
|
printf(" %d", n_nodes2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathDistinct(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr nodes; /* a node-set */
|
|
int n_nodes;
|
|
|
|
for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes = gen_xmlNodeSetPtr(n_nodes, 0);
|
|
|
|
ret_val = xmlXPathDistinct(nodes);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes, nodes, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathDistinct",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathDistinctSorted(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
|
|
int n_nodes;
|
|
|
|
for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes = gen_xmlNodeSetPtr(n_nodes, 0);
|
|
|
|
ret_val = xmlXPathDistinctSorted(nodes);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes, nodes, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathDistinctSorted",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathDivValues(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPathDivValues(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathDivValues",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathEqualValues(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlXPathEqualValues(ctxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathEqualValues",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathErr(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* a XPath parser context */
|
|
int n_ctxt;
|
|
int error; /* the error code */
|
|
int n_error;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_error = 0;n_error < gen_nb_int;n_error++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
error = gen_int(n_error, 1);
|
|
|
|
xmlXPathErr(ctxt, error);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_error, error, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathErr",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_error);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathEvalExpr(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPathEvalExpr(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathEvalExpr",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathEvaluatePredicateResult(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */
|
|
int n_res;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
res = gen_xmlXPathObjectPtr(n_res, 1);
|
|
|
|
ret_val = xmlXPathEvaluatePredicateResult(ctxt, res);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlXPathObjectPtr(n_res, res, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathEvaluatePredicateResult",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_res);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathFalseFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathFalseFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathFalseFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathFloorFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathFloorFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathFloorFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathFunctionLookup(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathFunctionLookupNS(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathHasSameNodes(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodeSetPtr nodes1; /* a node-set */
|
|
int n_nodes1;
|
|
xmlNodeSetPtr nodes2; /* a node-set */
|
|
int n_nodes2;
|
|
|
|
for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
|
|
for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
|
|
nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
|
|
|
|
ret_val = xmlXPathHasSameNodes(nodes1, nodes2);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
|
|
des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathHasSameNodes",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes1);
|
|
printf(" %d", n_nodes2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathIdFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathIdFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathIdFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathIntersection(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr nodes1; /* a node-set */
|
|
int n_nodes1;
|
|
xmlNodeSetPtr nodes2; /* a node-set */
|
|
int n_nodes2;
|
|
|
|
for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
|
|
for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
|
|
nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
|
|
|
|
ret_val = xmlXPathIntersection(nodes1, nodes2);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
|
|
des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathIntersection",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes1);
|
|
printf(" %d", n_nodes2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathIsNodeType(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
const xmlChar * name; /* a name string */
|
|
int n_name;
|
|
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
name = gen_const_xmlChar_ptr(n_name, 0);
|
|
|
|
ret_val = xmlXPathIsNodeType(name);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_name, name, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathIsNodeType",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathLangFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathLangFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathLangFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathLastFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathLastFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathLastFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathLeading(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr nodes1; /* a node-set */
|
|
int n_nodes1;
|
|
xmlNodeSetPtr nodes2; /* a node-set */
|
|
int n_nodes2;
|
|
|
|
for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
|
|
for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
|
|
nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
|
|
|
|
ret_val = xmlXPathLeading(nodes1, nodes2);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
|
|
des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathLeading",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes1);
|
|
printf(" %d", n_nodes2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathLeadingSorted(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */
|
|
int n_nodes1;
|
|
xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */
|
|
int n_nodes2;
|
|
|
|
for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
|
|
for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
|
|
nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
|
|
|
|
ret_val = xmlXPathLeadingSorted(nodes1, nodes2);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
|
|
des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathLeadingSorted",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes1);
|
|
printf(" %d", n_nodes2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathLocalNameFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathLocalNameFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathLocalNameFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathModValues(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPathModValues(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathModValues",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathMultValues(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPathMultValues(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathMultValues",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNamespaceURIFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathNamespaceURIFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNamespaceURIFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNewBoolean(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
int val; /* the boolean value */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_int;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_int(n_val, 0);
|
|
|
|
ret_val = xmlXPathNewBoolean(val);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_int(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNewBoolean",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNewCString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
const char * val; /* the char * value */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_const_char_ptr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_const_char_ptr(n_val, 0);
|
|
|
|
ret_val = xmlXPathNewCString(val);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_const_char_ptr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNewCString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNewFloat(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
double val; /* the double value */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_double;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_double(n_val, 0);
|
|
|
|
ret_val = xmlXPathNewFloat(val);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_double(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNewFloat",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNewNodeSet(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlNodePtr val; /* the NodePtr value */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlNodePtr(n_val, 0);
|
|
|
|
ret_val = xmlXPathNewNodeSet(val);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNewNodeSet",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNewNodeSetList(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlNodeSetPtr val; /* an existing NodeSet */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlNodeSetPtr(n_val, 0);
|
|
|
|
ret_val = xmlXPathNewNodeSetList(val);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNewNodeSetList",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNewParserContext(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNewString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
const xmlChar * val; /* the xmlChar * value */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_const_xmlChar_ptr(n_val, 0);
|
|
|
|
ret_val = xmlXPathNewString(val);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNewString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextAncestor(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current node in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextAncestor(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextAncestor",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextAncestorOrSelf(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current node in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextAncestorOrSelf(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextAncestorOrSelf",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextAttribute(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current attribute in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextAttribute(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextAttribute",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextChild(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current node in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextChild(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextChild",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextDescendant(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current node in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextDescendant(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextDescendant",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextDescendantOrSelf(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current node in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextDescendantOrSelf(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextDescendantOrSelf",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextFollowing(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current node in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextFollowing(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextFollowing",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextFollowingSibling(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current node in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextFollowingSibling(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextFollowingSibling",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextNamespace(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current attribute in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextNamespace(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextNamespace",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextParent(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current node in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextParent(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextParent",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextPreceding(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current node in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextPreceding(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextPreceding",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextPrecedingSibling(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current node in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextPrecedingSibling(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextPrecedingSibling",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNextSelf(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
xmlNodePtr cur; /* the current node in the traversal */
|
|
int n_cur;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
cur = gen_xmlNodePtr(n_cur, 1);
|
|
|
|
ret_val = xmlXPathNextSelf(ctxt, cur);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_xmlNodePtr(n_cur, cur, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNextSelf",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_cur);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeLeading(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr nodes; /* a node-set */
|
|
int n_nodes;
|
|
xmlNodePtr node; /* a node */
|
|
int n_node;
|
|
|
|
for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes = gen_xmlNodeSetPtr(n_nodes, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
|
|
ret_val = xmlXPathNodeLeading(nodes, node);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes, nodes, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeLeading",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes);
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeLeadingSorted(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
|
|
int n_nodes;
|
|
xmlNodePtr node; /* a node */
|
|
int n_node;
|
|
|
|
for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes = gen_xmlNodeSetPtr(n_nodes, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
|
|
ret_val = xmlXPathNodeLeadingSorted(nodes, node);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes, nodes, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeLeadingSorted",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes);
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeSetAdd(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodeSetPtr cur; /* the initial node set */
|
|
int n_cur;
|
|
xmlNodePtr val; /* a new xmlNodePtr */
|
|
int n_val;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
|
|
for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodeSetPtr(n_cur, 0);
|
|
val = gen_xmlNodePtr(n_val, 1);
|
|
|
|
ret_val = xmlXPathNodeSetAdd(cur, val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_cur, cur, 0);
|
|
des_xmlNodePtr(n_val, val, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeSetAdd",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeSetAddNs(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodeSetPtr cur; /* the initial node set */
|
|
int n_cur;
|
|
xmlNodePtr node; /* the hosting node */
|
|
int n_node;
|
|
xmlNsPtr ns; /* a the namespace node */
|
|
int n_ns;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodeSetPtr(n_cur, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
ns = gen_xmlNsPtr(n_ns, 2);
|
|
|
|
ret_val = xmlXPathNodeSetAddNs(cur, node, ns);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_cur, cur, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
des_xmlNsPtr(n_ns, ns, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeSetAddNs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_node);
|
|
printf(" %d", n_ns);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeSetAddUnique(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodeSetPtr cur; /* the initial node set */
|
|
int n_cur;
|
|
xmlNodePtr val; /* a new xmlNodePtr */
|
|
int n_val;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
|
|
for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodeSetPtr(n_cur, 0);
|
|
val = gen_xmlNodePtr(n_val, 1);
|
|
|
|
ret_val = xmlXPathNodeSetAddUnique(cur, val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_cur, cur, 0);
|
|
des_xmlNodePtr(n_val, val, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeSetAddUnique",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeSetContains(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlNodeSetPtr cur; /* the node-set */
|
|
int n_cur;
|
|
xmlNodePtr val; /* the node */
|
|
int n_val;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
|
|
for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodeSetPtr(n_cur, 0);
|
|
val = gen_xmlNodePtr(n_val, 1);
|
|
|
|
ret_val = xmlXPathNodeSetContains(cur, val);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_cur, cur, 0);
|
|
des_xmlNodePtr(n_val, val, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeSetContains",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeSetDel(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr cur; /* the initial node set */
|
|
int n_cur;
|
|
xmlNodePtr val; /* an xmlNodePtr */
|
|
int n_val;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
|
|
for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodeSetPtr(n_cur, 0);
|
|
val = gen_xmlNodePtr(n_val, 1);
|
|
|
|
xmlXPathNodeSetDel(cur, val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_cur, cur, 0);
|
|
des_xmlNodePtr(n_val, val, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeSetDel",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeSetMerge(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr val1; /* the first NodeSet or NULL */
|
|
int n_val1;
|
|
xmlNodeSetPtr val2; /* the second NodeSet */
|
|
int n_val2;
|
|
|
|
for (n_val1 = 0;n_val1 < gen_nb_xmlNodeSetPtr;n_val1++) {
|
|
for (n_val2 = 0;n_val2 < gen_nb_xmlNodeSetPtr;n_val2++) {
|
|
mem_base = xmlMemBlocks();
|
|
val1 = gen_xmlNodeSetPtr(n_val1, 0);
|
|
val2 = gen_xmlNodeSetPtr(n_val2, 1);
|
|
|
|
ret_val = xmlXPathNodeSetMerge(val1, val2);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_val1, val1, 0);
|
|
des_xmlNodeSetPtr(n_val2, val2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeSetMerge",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val1);
|
|
printf(" %d", n_val2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeSetRemove(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr cur; /* the initial node set */
|
|
int n_cur;
|
|
int val; /* the index to remove */
|
|
int n_val;
|
|
|
|
for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
|
|
for (n_val = 0;n_val < gen_nb_int;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
cur = gen_xmlNodeSetPtr(n_cur, 0);
|
|
val = gen_int(n_val, 1);
|
|
|
|
xmlXPathNodeSetRemove(cur, val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_cur, cur, 0);
|
|
des_int(n_val, val, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeSetRemove",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_cur);
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeSetSort(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr set; /* the node set */
|
|
int n_set;
|
|
|
|
for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) {
|
|
mem_base = xmlMemBlocks();
|
|
set = gen_xmlNodeSetPtr(n_set, 0);
|
|
|
|
xmlXPathNodeSetSort(set);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_set, set, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeSetSort",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_set);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeTrailing(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr nodes; /* a node-set */
|
|
int n_nodes;
|
|
xmlNodePtr node; /* a node */
|
|
int n_node;
|
|
|
|
for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes = gen_xmlNodeSetPtr(n_nodes, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
|
|
ret_val = xmlXPathNodeTrailing(nodes, node);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes, nodes, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeTrailing",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes);
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNodeTrailingSorted(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
|
|
int n_nodes;
|
|
xmlNodePtr node; /* a node */
|
|
int n_node;
|
|
|
|
for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
|
|
for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes = gen_xmlNodeSetPtr(n_nodes, 0);
|
|
node = gen_xmlNodePtr(n_node, 1);
|
|
|
|
ret_val = xmlXPathNodeTrailingSorted(nodes, node);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes, nodes, 0);
|
|
des_xmlNodePtr(n_node, node, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNodeTrailingSorted",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes);
|
|
printf(" %d", n_node);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNormalizeFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathNormalizeFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNormalizeFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNotEqualValues(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlXPathNotEqualValues(ctxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNotEqualValues",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNotFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathNotFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNotFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNsLookup(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
const xmlChar * ret_val;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
const xmlChar * prefix; /* the namespace prefix value */
|
|
int n_prefix;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 1);
|
|
|
|
ret_val = xmlXPathNsLookup(ctxt, prefix);
|
|
desret_const_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNsLookup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_prefix);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathNumberFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathNumberFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathNumberFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathParseNCName(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlXPathParseNCName(ctxt);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathParseNCName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathParseName(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlXPathParseName(ctxt);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathParseName",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathPopBoolean(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* an XPath parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlXPathPopBoolean(ctxt);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathPopBoolean",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathPopExternal(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
void * ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* an XPath parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlXPathPopExternal(ctxt);
|
|
desret_void_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathPopExternal",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathPopNodeSet(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* an XPath parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlXPathPopNodeSet(ctxt);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathPopNodeSet",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathPopNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
double ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* an XPath parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlXPathPopNumber(ctxt);
|
|
desret_double(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathPopNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathPopString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlChar * ret_val;
|
|
xmlXPathParserContextPtr ctxt; /* an XPath parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
ret_val = xmlXPathPopString(ctxt);
|
|
desret_xmlChar_ptr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathPopString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathPositionFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathPositionFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathPositionFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRegisterAllFunctions(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPathRegisterAllFunctions(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathRegisterAllFunctions",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRegisterFunc(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRegisterFuncLookup(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRegisterFuncNS(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRegisterNs(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
const xmlChar * prefix; /* the namespace prefix cannot be NULL or empty string */
|
|
int n_prefix;
|
|
const xmlChar * ns_uri; /* the namespace name */
|
|
int n_ns_uri;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
|
|
for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
|
|
prefix = gen_const_xmlChar_ptr(n_prefix, 1);
|
|
ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
|
|
|
|
ret_val = xmlXPathRegisterNs(ctxt, prefix, ns_uri);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_prefix, prefix, 1);
|
|
des_const_xmlChar_ptr(n_ns_uri, ns_uri, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathRegisterNs",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_prefix);
|
|
printf(" %d", n_ns_uri);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRegisterVariable(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
const xmlChar * name; /* the variable name */
|
|
int n_name;
|
|
xmlXPathObjectPtr value; /* the variable value or NULL */
|
|
int n_value;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
value = gen_xmlXPathObjectPtr(n_value, 2);
|
|
|
|
ret_val = xmlXPathRegisterVariable(ctxt, name, value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_xmlXPathObjectPtr(n_value, value, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathRegisterVariable",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRegisterVariableLookup(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRegisterVariableNS(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
int ret_val;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
const xmlChar * name; /* the variable name */
|
|
int n_name;
|
|
const xmlChar * ns_uri; /* the variable namespace URI */
|
|
int n_ns_uri;
|
|
xmlXPathObjectPtr value; /* the variable value or NULL */
|
|
int n_value;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
|
|
for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
|
|
value = gen_xmlXPathObjectPtr(n_value, 3);
|
|
|
|
ret_val = xmlXPathRegisterVariableNS(ctxt, name, ns_uri, value);
|
|
desret_int(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_ns_uri, ns_uri, 2);
|
|
des_xmlXPathObjectPtr(n_value, value, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathRegisterVariableNS",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_ns_uri);
|
|
printf(" %d", n_value);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRegisteredFuncsCleanup(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPathRegisteredFuncsCleanup(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathRegisteredFuncsCleanup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRegisteredNsCleanup(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPathRegisteredNsCleanup(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathRegisteredNsCleanup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRegisteredVariablesCleanup(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPathRegisteredVariablesCleanup(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathRegisteredVariablesCleanup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRoot(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPathRoot(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathRoot",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathRoundFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathRoundFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathRoundFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathStartsWithFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathStartsWithFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathStartsWithFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathStringEvalNumber(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
double ret_val;
|
|
const xmlChar * str; /* A string to scan */
|
|
int n_str;
|
|
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
mem_base = xmlMemBlocks();
|
|
str = gen_const_xmlChar_ptr(n_str, 0);
|
|
|
|
ret_val = xmlXPathStringEvalNumber(str);
|
|
desret_double(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str, str, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathStringEvalNumber",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathStringFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathStringFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathStringFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathStringLengthFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathStringLengthFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathStringLengthFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathSubValues(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPathSubValues(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathSubValues",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathSubstringAfterFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathSubstringAfterFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathSubstringAfterFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathSubstringBeforeFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathSubstringBeforeFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathSubstringBeforeFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathSubstringFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathSubstringFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathSubstringFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathSumFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathSumFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathSumFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathTrailing(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr nodes1; /* a node-set */
|
|
int n_nodes1;
|
|
xmlNodeSetPtr nodes2; /* a node-set */
|
|
int n_nodes2;
|
|
|
|
for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
|
|
for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
|
|
nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
|
|
|
|
ret_val = xmlXPathTrailing(nodes1, nodes2);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
|
|
des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathTrailing",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes1);
|
|
printf(" %d", n_nodes2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathTrailingSorted(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlNodeSetPtr ret_val;
|
|
xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */
|
|
int n_nodes1;
|
|
xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */
|
|
int n_nodes2;
|
|
|
|
for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
|
|
for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
|
|
mem_base = xmlMemBlocks();
|
|
nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
|
|
nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
|
|
|
|
ret_val = xmlXPathTrailingSorted(nodes1, nodes2);
|
|
desret_xmlNodeSetPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
|
|
des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathTrailingSorted",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_nodes1);
|
|
printf(" %d", n_nodes2);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathTranslateFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathTranslateFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathTranslateFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathTrueFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of arguments */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPathTrueFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathTrueFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathValueFlipSign(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPathValueFlipSign(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathValueFlipSign",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathVariableLookup(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
const xmlChar * name; /* the variable name */
|
|
int n_name;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
|
|
ret_val = xmlXPathVariableLookup(ctxt, name);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathVariableLookup",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_name);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathVariableLookupNS(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlXPathContextPtr ctxt; /* the XPath context */
|
|
int n_ctxt;
|
|
const xmlChar * name; /* the variable name */
|
|
int n_name;
|
|
const xmlChar * ns_uri; /* the variable namespace URI */
|
|
int n_ns_uri;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
|
|
for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
|
|
for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
|
|
name = gen_const_xmlChar_ptr(n_name, 1);
|
|
ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
|
|
|
|
ret_val = xmlXPathVariableLookupNS(ctxt, name, ns_uri);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
|
|
des_const_xmlChar_ptr(n_name, name, 1);
|
|
des_const_xmlChar_ptr(n_ns_uri, ns_uri, 2);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathVariableLookupNS",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_name);
|
|
printf(" %d", n_ns_uri);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathWrapCString(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
char * val; /* the char * value */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_char_ptr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_char_ptr(n_val, 0);
|
|
|
|
ret_val = xmlXPathWrapCString(val);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_char_ptr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathWrapCString",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathWrapExternal(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
void * val; /* the user data */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_void_ptr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_void_ptr(n_val, 0);
|
|
|
|
ret_val = xmlXPathWrapExternal(val);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_void_ptr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathWrapExternal",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPathWrapNodeSet(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlNodeSetPtr val; /* the NodePtr value */
|
|
int n_val;
|
|
|
|
for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) {
|
|
mem_base = xmlMemBlocks();
|
|
val = gen_xmlNodeSetPtr(n_val, 0);
|
|
|
|
ret_val = xmlXPathWrapNodeSet(val);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_val, val, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPathWrapNodeSet",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_val);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPatherror(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPATH_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
|
|
int n_ctxt;
|
|
const char * file; /* the file name */
|
|
int n_file;
|
|
int line; /* the line number */
|
|
int n_line;
|
|
int no; /* the error number */
|
|
int n_no;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_file = 0;n_file < gen_nb_filepath;n_file++) {
|
|
for (n_line = 0;n_line < gen_nb_int;n_line++) {
|
|
for (n_no = 0;n_no < gen_nb_int;n_no++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
file = gen_filepath(n_file, 1);
|
|
line = gen_int(n_line, 2);
|
|
no = gen_int(n_no, 3);
|
|
|
|
xmlXPatherror(ctxt, file, line, no);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_filepath(n_file, file, 1);
|
|
des_int(n_line, line, 2);
|
|
des_int(n_no, no, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPatherror",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_file);
|
|
printf(" %d", n_line);
|
|
printf(" %d", n_no);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xpathInternals(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xpathInternals : 106 of 117 functions ...\n");
|
|
test_ret += test_valuePop();
|
|
test_ret += test_valuePush();
|
|
test_ret += test_xmlXPathAddValues();
|
|
test_ret += test_xmlXPathBooleanFunction();
|
|
test_ret += test_xmlXPathCeilingFunction();
|
|
test_ret += test_xmlXPathCompareValues();
|
|
test_ret += test_xmlXPathConcatFunction();
|
|
test_ret += test_xmlXPathContainsFunction();
|
|
test_ret += test_xmlXPathCountFunction();
|
|
test_ret += test_xmlXPathDebugDumpCompExpr();
|
|
test_ret += test_xmlXPathDebugDumpObject();
|
|
test_ret += test_xmlXPathDifference();
|
|
test_ret += test_xmlXPathDistinct();
|
|
test_ret += test_xmlXPathDistinctSorted();
|
|
test_ret += test_xmlXPathDivValues();
|
|
test_ret += test_xmlXPathEqualValues();
|
|
test_ret += test_xmlXPathErr();
|
|
test_ret += test_xmlXPathEvalExpr();
|
|
test_ret += test_xmlXPathEvaluatePredicateResult();
|
|
test_ret += test_xmlXPathFalseFunction();
|
|
test_ret += test_xmlXPathFloorFunction();
|
|
test_ret += test_xmlXPathFunctionLookup();
|
|
test_ret += test_xmlXPathFunctionLookupNS();
|
|
test_ret += test_xmlXPathHasSameNodes();
|
|
test_ret += test_xmlXPathIdFunction();
|
|
test_ret += test_xmlXPathIntersection();
|
|
test_ret += test_xmlXPathIsNodeType();
|
|
test_ret += test_xmlXPathLangFunction();
|
|
test_ret += test_xmlXPathLastFunction();
|
|
test_ret += test_xmlXPathLeading();
|
|
test_ret += test_xmlXPathLeadingSorted();
|
|
test_ret += test_xmlXPathLocalNameFunction();
|
|
test_ret += test_xmlXPathModValues();
|
|
test_ret += test_xmlXPathMultValues();
|
|
test_ret += test_xmlXPathNamespaceURIFunction();
|
|
test_ret += test_xmlXPathNewBoolean();
|
|
test_ret += test_xmlXPathNewCString();
|
|
test_ret += test_xmlXPathNewFloat();
|
|
test_ret += test_xmlXPathNewNodeSet();
|
|
test_ret += test_xmlXPathNewNodeSetList();
|
|
test_ret += test_xmlXPathNewParserContext();
|
|
test_ret += test_xmlXPathNewString();
|
|
test_ret += test_xmlXPathNextAncestor();
|
|
test_ret += test_xmlXPathNextAncestorOrSelf();
|
|
test_ret += test_xmlXPathNextAttribute();
|
|
test_ret += test_xmlXPathNextChild();
|
|
test_ret += test_xmlXPathNextDescendant();
|
|
test_ret += test_xmlXPathNextDescendantOrSelf();
|
|
test_ret += test_xmlXPathNextFollowing();
|
|
test_ret += test_xmlXPathNextFollowingSibling();
|
|
test_ret += test_xmlXPathNextNamespace();
|
|
test_ret += test_xmlXPathNextParent();
|
|
test_ret += test_xmlXPathNextPreceding();
|
|
test_ret += test_xmlXPathNextPrecedingSibling();
|
|
test_ret += test_xmlXPathNextSelf();
|
|
test_ret += test_xmlXPathNodeLeading();
|
|
test_ret += test_xmlXPathNodeLeadingSorted();
|
|
test_ret += test_xmlXPathNodeSetAdd();
|
|
test_ret += test_xmlXPathNodeSetAddNs();
|
|
test_ret += test_xmlXPathNodeSetAddUnique();
|
|
test_ret += test_xmlXPathNodeSetContains();
|
|
test_ret += test_xmlXPathNodeSetDel();
|
|
test_ret += test_xmlXPathNodeSetMerge();
|
|
test_ret += test_xmlXPathNodeSetRemove();
|
|
test_ret += test_xmlXPathNodeSetSort();
|
|
test_ret += test_xmlXPathNodeTrailing();
|
|
test_ret += test_xmlXPathNodeTrailingSorted();
|
|
test_ret += test_xmlXPathNormalizeFunction();
|
|
test_ret += test_xmlXPathNotEqualValues();
|
|
test_ret += test_xmlXPathNotFunction();
|
|
test_ret += test_xmlXPathNsLookup();
|
|
test_ret += test_xmlXPathNumberFunction();
|
|
test_ret += test_xmlXPathParseNCName();
|
|
test_ret += test_xmlXPathParseName();
|
|
test_ret += test_xmlXPathPopBoolean();
|
|
test_ret += test_xmlXPathPopExternal();
|
|
test_ret += test_xmlXPathPopNodeSet();
|
|
test_ret += test_xmlXPathPopNumber();
|
|
test_ret += test_xmlXPathPopString();
|
|
test_ret += test_xmlXPathPositionFunction();
|
|
test_ret += test_xmlXPathRegisterAllFunctions();
|
|
test_ret += test_xmlXPathRegisterFunc();
|
|
test_ret += test_xmlXPathRegisterFuncLookup();
|
|
test_ret += test_xmlXPathRegisterFuncNS();
|
|
test_ret += test_xmlXPathRegisterNs();
|
|
test_ret += test_xmlXPathRegisterVariable();
|
|
test_ret += test_xmlXPathRegisterVariableLookup();
|
|
test_ret += test_xmlXPathRegisterVariableNS();
|
|
test_ret += test_xmlXPathRegisteredFuncsCleanup();
|
|
test_ret += test_xmlXPathRegisteredNsCleanup();
|
|
test_ret += test_xmlXPathRegisteredVariablesCleanup();
|
|
test_ret += test_xmlXPathRoot();
|
|
test_ret += test_xmlXPathRoundFunction();
|
|
test_ret += test_xmlXPathStartsWithFunction();
|
|
test_ret += test_xmlXPathStringEvalNumber();
|
|
test_ret += test_xmlXPathStringFunction();
|
|
test_ret += test_xmlXPathStringLengthFunction();
|
|
test_ret += test_xmlXPathSubValues();
|
|
test_ret += test_xmlXPathSubstringAfterFunction();
|
|
test_ret += test_xmlXPathSubstringBeforeFunction();
|
|
test_ret += test_xmlXPathSubstringFunction();
|
|
test_ret += test_xmlXPathSumFunction();
|
|
test_ret += test_xmlXPathTrailing();
|
|
test_ret += test_xmlXPathTrailingSorted();
|
|
test_ret += test_xmlXPathTranslateFunction();
|
|
test_ret += test_xmlXPathTrueFunction();
|
|
test_ret += test_xmlXPathValueFlipSign();
|
|
test_ret += test_xmlXPathVariableLookup();
|
|
test_ret += test_xmlXPathVariableLookupNS();
|
|
test_ret += test_xmlXPathWrapCString();
|
|
test_ret += test_xmlXPathWrapExternal();
|
|
test_ret += test_xmlXPathWrapNodeSet();
|
|
test_ret += test_xmlXPatherror();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xpathInternals: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xmlXPtrBuildNodeList(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED) && defined(LIBXML_XPTR_LOCS_ENABLED)
|
|
int mem_base;
|
|
xmlNodePtr ret_val;
|
|
xmlXPathObjectPtr obj; /* the XPointer result from the evaluation. */
|
|
int n_obj;
|
|
|
|
for (n_obj = 0;n_obj < gen_nb_xmlXPathObjectPtr;n_obj++) {
|
|
mem_base = xmlMemBlocks();
|
|
obj = gen_xmlXPathObjectPtr(n_obj, 0);
|
|
|
|
ret_val = xmlXPtrBuildNodeList(obj);
|
|
desret_xmlNodePtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathObjectPtr(n_obj, obj, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrBuildNodeList",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_obj);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrEval(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
const xmlChar * str; /* the XPointer expression */
|
|
int n_str;
|
|
xmlXPathContextPtr ctx; /* the XPointer context */
|
|
int n_ctx;
|
|
|
|
for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
|
|
for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
|
|
mem_base = xmlMemBlocks();
|
|
str = gen_const_xmlChar_ptr(n_str, 0);
|
|
ctx = gen_xmlXPathContextPtr(n_ctx, 1);
|
|
|
|
ret_val = xmlXPtrEval(str, ctx);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_const_xmlChar_ptr(n_str, str, 0);
|
|
des_xmlXPathContextPtr(n_ctx, ctx, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrEval",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_str);
|
|
printf(" %d", n_ctx);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrEvalRangePredicate(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED) && defined(LIBXML_XPTR_LOCS_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */
|
|
int n_ctxt;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
|
|
xmlXPtrEvalRangePredicate(ctxt);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrEvalRangePredicate",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrNewCollapsedRange(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED) && defined(LIBXML_XPTR_LOCS_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlNodePtr start; /* the starting and ending node */
|
|
int n_start;
|
|
|
|
for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
|
|
mem_base = xmlMemBlocks();
|
|
start = gen_xmlNodePtr(n_start, 0);
|
|
|
|
ret_val = xmlXPtrNewCollapsedRange(start);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_start, start, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrNewCollapsedRange",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_start);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrNewContext(void) {
|
|
int test_ret = 0;
|
|
|
|
|
|
/* missing type support */
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrNewLocationSetNodeSet(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED) && defined(LIBXML_XPTR_LOCS_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlNodeSetPtr set; /* a node set */
|
|
int n_set;
|
|
|
|
for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) {
|
|
mem_base = xmlMemBlocks();
|
|
set = gen_xmlNodeSetPtr(n_set, 0);
|
|
|
|
ret_val = xmlXPtrNewLocationSetNodeSet(set);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodeSetPtr(n_set, set, 0);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodeSet",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_set);
|
|
printf("\n");
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrNewLocationSetNodes(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED) && defined(LIBXML_XPTR_LOCS_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlNodePtr start; /* the start NodePtr value */
|
|
int n_start;
|
|
xmlNodePtr end; /* the end NodePtr value or NULL */
|
|
int n_end;
|
|
|
|
for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
|
|
for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
|
|
mem_base = xmlMemBlocks();
|
|
start = gen_xmlNodePtr(n_start, 0);
|
|
end = gen_xmlNodePtr(n_end, 1);
|
|
|
|
ret_val = xmlXPtrNewLocationSetNodes(start, end);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_start, start, 0);
|
|
des_xmlNodePtr(n_end, end, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodes",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_start);
|
|
printf(" %d", n_end);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrNewRange(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED) && defined(LIBXML_XPTR_LOCS_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlNodePtr start; /* the starting node */
|
|
int n_start;
|
|
int startindex; /* the start index */
|
|
int n_startindex;
|
|
xmlNodePtr end; /* the ending point */
|
|
int n_end;
|
|
int endindex; /* the ending index */
|
|
int n_endindex;
|
|
|
|
for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
|
|
for (n_startindex = 0;n_startindex < gen_nb_int;n_startindex++) {
|
|
for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
|
|
for (n_endindex = 0;n_endindex < gen_nb_int;n_endindex++) {
|
|
mem_base = xmlMemBlocks();
|
|
start = gen_xmlNodePtr(n_start, 0);
|
|
startindex = gen_int(n_startindex, 1);
|
|
end = gen_xmlNodePtr(n_end, 2);
|
|
endindex = gen_int(n_endindex, 3);
|
|
|
|
ret_val = xmlXPtrNewRange(start, startindex, end, endindex);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_start, start, 0);
|
|
des_int(n_startindex, startindex, 1);
|
|
des_xmlNodePtr(n_end, end, 2);
|
|
des_int(n_endindex, endindex, 3);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrNewRange",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_start);
|
|
printf(" %d", n_startindex);
|
|
printf(" %d", n_end);
|
|
printf(" %d", n_endindex);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrNewRangeNodeObject(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED) && defined(LIBXML_XPTR_LOCS_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlNodePtr start; /* the starting node */
|
|
int n_start;
|
|
xmlXPathObjectPtr end; /* the ending object */
|
|
int n_end;
|
|
|
|
for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
|
|
for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
|
|
mem_base = xmlMemBlocks();
|
|
start = gen_xmlNodePtr(n_start, 0);
|
|
end = gen_xmlXPathObjectPtr(n_end, 1);
|
|
|
|
ret_val = xmlXPtrNewRangeNodeObject(start, end);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_start, start, 0);
|
|
des_xmlXPathObjectPtr(n_end, end, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrNewRangeNodeObject",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_start);
|
|
printf(" %d", n_end);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrNewRangeNodePoint(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED) && defined(LIBXML_XPTR_LOCS_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlNodePtr start; /* the starting node */
|
|
int n_start;
|
|
xmlXPathObjectPtr end; /* the ending point */
|
|
int n_end;
|
|
|
|
for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
|
|
for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
|
|
mem_base = xmlMemBlocks();
|
|
start = gen_xmlNodePtr(n_start, 0);
|
|
end = gen_xmlXPathObjectPtr(n_end, 1);
|
|
|
|
ret_val = xmlXPtrNewRangeNodePoint(start, end);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_start, start, 0);
|
|
des_xmlXPathObjectPtr(n_end, end, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrNewRangeNodePoint",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_start);
|
|
printf(" %d", n_end);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrNewRangeNodes(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED) && defined(LIBXML_XPTR_LOCS_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlNodePtr start; /* the starting node */
|
|
int n_start;
|
|
xmlNodePtr end; /* the ending node */
|
|
int n_end;
|
|
|
|
for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
|
|
for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
|
|
mem_base = xmlMemBlocks();
|
|
start = gen_xmlNodePtr(n_start, 0);
|
|
end = gen_xmlNodePtr(n_end, 1);
|
|
|
|
ret_val = xmlXPtrNewRangeNodes(start, end);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlNodePtr(n_start, start, 0);
|
|
des_xmlNodePtr(n_end, end, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrNewRangeNodes",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_start);
|
|
printf(" %d", n_end);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrNewRangePointNode(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED) && defined(LIBXML_XPTR_LOCS_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlXPathObjectPtr start; /* the starting point */
|
|
int n_start;
|
|
xmlNodePtr end; /* the ending node */
|
|
int n_end;
|
|
|
|
for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) {
|
|
for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
|
|
mem_base = xmlMemBlocks();
|
|
start = gen_xmlXPathObjectPtr(n_start, 0);
|
|
end = gen_xmlNodePtr(n_end, 1);
|
|
|
|
ret_val = xmlXPtrNewRangePointNode(start, end);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathObjectPtr(n_start, start, 0);
|
|
des_xmlNodePtr(n_end, end, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrNewRangePointNode",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_start);
|
|
printf(" %d", n_end);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrNewRangePoints(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED) && defined(LIBXML_XPTR_LOCS_ENABLED)
|
|
int mem_base;
|
|
xmlXPathObjectPtr ret_val;
|
|
xmlXPathObjectPtr start; /* the starting point */
|
|
int n_start;
|
|
xmlXPathObjectPtr end; /* the ending point */
|
|
int n_end;
|
|
|
|
for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) {
|
|
for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
|
|
mem_base = xmlMemBlocks();
|
|
start = gen_xmlXPathObjectPtr(n_start, 0);
|
|
end = gen_xmlXPathObjectPtr(n_end, 1);
|
|
|
|
ret_val = xmlXPtrNewRangePoints(start, end);
|
|
desret_xmlXPathObjectPtr(ret_val);
|
|
call_tests++;
|
|
des_xmlXPathObjectPtr(n_start, start, 0);
|
|
des_xmlXPathObjectPtr(n_end, end, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrNewRangePoints",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_start);
|
|
printf(" %d", n_end);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
|
|
static int
|
|
test_xmlXPtrRangeToFunction(void) {
|
|
int test_ret = 0;
|
|
|
|
#if defined(LIBXML_XPTR_ENABLED) && defined(LIBXML_XPTR_LOCS_ENABLED)
|
|
int mem_base;
|
|
xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */
|
|
int n_ctxt;
|
|
int nargs; /* the number of args */
|
|
int n_nargs;
|
|
|
|
for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
|
|
for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
|
|
mem_base = xmlMemBlocks();
|
|
ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
|
|
nargs = gen_int(n_nargs, 1);
|
|
|
|
xmlXPtrRangeToFunction(ctxt, nargs);
|
|
call_tests++;
|
|
des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
|
|
des_int(n_nargs, nargs, 1);
|
|
xmlResetLastError();
|
|
if (mem_base != xmlMemBlocks()) {
|
|
printf("Leak of %d blocks found in xmlXPtrRangeToFunction",
|
|
xmlMemBlocks() - mem_base);
|
|
test_ret++;
|
|
printf(" %d", n_ctxt);
|
|
printf(" %d", n_nargs);
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
function_tests++;
|
|
#endif
|
|
|
|
return(test_ret);
|
|
}
|
|
|
|
static int
|
|
test_xpointer(void) {
|
|
int test_ret = 0;
|
|
|
|
if (quiet == 0) printf("Testing xpointer : 13 of 21 functions ...\n");
|
|
test_ret += test_xmlXPtrBuildNodeList();
|
|
test_ret += test_xmlXPtrEval();
|
|
test_ret += test_xmlXPtrEvalRangePredicate();
|
|
test_ret += test_xmlXPtrNewCollapsedRange();
|
|
test_ret += test_xmlXPtrNewContext();
|
|
test_ret += test_xmlXPtrNewLocationSetNodeSet();
|
|
test_ret += test_xmlXPtrNewLocationSetNodes();
|
|
test_ret += test_xmlXPtrNewRange();
|
|
test_ret += test_xmlXPtrNewRangeNodeObject();
|
|
test_ret += test_xmlXPtrNewRangeNodePoint();
|
|
test_ret += test_xmlXPtrNewRangeNodes();
|
|
test_ret += test_xmlXPtrNewRangePointNode();
|
|
test_ret += test_xmlXPtrNewRangePoints();
|
|
test_ret += test_xmlXPtrRangeToFunction();
|
|
|
|
if (test_ret != 0)
|
|
printf("Module xpointer: %d errors\n", test_ret);
|
|
return(test_ret);
|
|
}
|
|
static int
|
|
test_module(const char *module) {
|
|
if (!strcmp(module, "HTMLparser")) return(test_HTMLparser());
|
|
if (!strcmp(module, "HTMLtree")) return(test_HTMLtree());
|
|
if (!strcmp(module, "SAX2")) return(test_SAX2());
|
|
if (!strcmp(module, "c14n")) return(test_c14n());
|
|
if (!strcmp(module, "catalog")) return(test_catalog());
|
|
if (!strcmp(module, "chvalid")) return(test_chvalid());
|
|
if (!strcmp(module, "debugXML")) return(test_debugXML());
|
|
if (!strcmp(module, "dict")) return(test_dict());
|
|
if (!strcmp(module, "encoding")) return(test_encoding());
|
|
if (!strcmp(module, "entities")) return(test_entities());
|
|
if (!strcmp(module, "hash")) return(test_hash());
|
|
if (!strcmp(module, "list")) return(test_list());
|
|
if (!strcmp(module, "nanohttp")) return(test_nanohttp());
|
|
if (!strcmp(module, "parser")) return(test_parser());
|
|
if (!strcmp(module, "parserInternals")) return(test_parserInternals());
|
|
if (!strcmp(module, "pattern")) return(test_pattern());
|
|
if (!strcmp(module, "relaxng")) return(test_relaxng());
|
|
if (!strcmp(module, "schemasInternals")) return(test_schemasInternals());
|
|
if (!strcmp(module, "schematron")) return(test_schematron());
|
|
if (!strcmp(module, "tree")) return(test_tree());
|
|
if (!strcmp(module, "uri")) return(test_uri());
|
|
if (!strcmp(module, "valid")) return(test_valid());
|
|
if (!strcmp(module, "xinclude")) return(test_xinclude());
|
|
if (!strcmp(module, "xmlIO")) return(test_xmlIO());
|
|
if (!strcmp(module, "xmlautomata")) return(test_xmlautomata());
|
|
if (!strcmp(module, "xmlerror")) return(test_xmlerror());
|
|
if (!strcmp(module, "xmlmodule")) return(test_xmlmodule());
|
|
if (!strcmp(module, "xmlreader")) return(test_xmlreader());
|
|
if (!strcmp(module, "xmlregexp")) return(test_xmlregexp());
|
|
if (!strcmp(module, "xmlsave")) return(test_xmlsave());
|
|
if (!strcmp(module, "xmlschemas")) return(test_xmlschemas());
|
|
if (!strcmp(module, "xmlschemastypes")) return(test_xmlschemastypes());
|
|
if (!strcmp(module, "xmlstring")) return(test_xmlstring());
|
|
if (!strcmp(module, "xmlunicode")) return(test_xmlunicode());
|
|
if (!strcmp(module, "xmlwriter")) return(test_xmlwriter());
|
|
if (!strcmp(module, "xpath")) return(test_xpath());
|
|
if (!strcmp(module, "xpathInternals")) return(test_xpathInternals());
|
|
if (!strcmp(module, "xpointer")) return(test_xpointer());
|
|
return(0);
|
|
}
|