testapi.c

/*
 * 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
 */

#include <stdio.h>
#include <libxml/xmlerror.h>

static int testlibxml2(void);

static int generic_errors = 0;
static int call_tests = 0;

static xmlChar chartab[1024] = "  chartab\n";

static void
structured_errors(void *userData ATTRIBUTE_UNUSED,
                  xmlErrorPtr error ATTRIBUTE_UNUSED) {
    generic_errors++;
}

int main(void) {
    int ret;
    int blocks, mem;

    xmlInitParser();
    xmlRelaxNGInitTypes();

    LIBXML_TEST_VERSION

    xmlSetStructuredErrorFunc(NULL, structured_errors);

    ret = testlibxml2();

    xmlCleanupParser();
    blocks = xmlMemBlocks();
    mem = xmlMemUsed();
    if ((blocks != 0) || (mem != 0)) {
        printf("testapi leaked %d bytes in %d blocks\n", mem, blocks);
    }
    xmlMemoryDump();

    return (ret != 0);
}

#include <libxml/HTMLparser.h>
#include <libxml/HTMLtree.h>
#include <libxml/c14n.h>
#include <libxml/catalog.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/pattern.h>
#include <libxml/relaxng.h>
#include <libxml/schemasInternals.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>
static int test_HTMLparser(void);
static int test_HTMLtree(void);
static int test_c14n(void);
static int test_catalog(void);
static int test_chvalid(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_nanoftp(void);
static int test_nanohttp(void);
static int test_parser(void);
static int test_pattern(void);
static int test_relaxng(void);
static int test_schemasInternals(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_xmlerror(void);
static int test_xmlreader(void);
static int test_xmlsave(void);
static int test_xmlschemas(void);
static int test_xmlschemastypes(void);
static int test_xmlstring(void);
static int test_xmlwriter(void);
static int test_xpath(void);
static int test_xpointer(void);

#define gen_nb_userdata 3

static void *gen_userdata(int no) {
    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) {
}


#define gen_nb_int 4

static int gen_int(int no) {
    if (no == 0) return(0);
    if (no == 1) return(1);
    if (no == 2) return(122);
    return(-1);
}

static void des_int(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED) {
}

#define gen_nb_const_char_ptr 4

static const char *gen_const_char_ptr(int no) {
    if (no == 0) return("foo");
    if (no == 1) return("<foo/>");
    if (no == 2) return("test/ent2");
    return(NULL);
}
static void des_const_char_ptr(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED) {
}

#define gen_nb_xmlChar_ptr 2

static xmlChar *gen_xmlChar_ptr(int no) {
    if (no == 0) return(&chartab[0]);
    return(NULL);
}
static void des_xmlChar_ptr(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED) {
}

#define gen_nb_const_xmlChar_ptr 5

static const xmlChar *gen_const_xmlChar_ptr(int no) {
    if (no == 0) return((const xmlChar *) "foo");
    if (no == 1) return((const xmlChar *) "<foo/>");
    if (no == 2) return((const xmlChar *) "nøne");
    if (no == 3) return((const xmlChar *) " 2ab ");
    return(NULL);
}
static void des_const_xmlChar_ptr(int no ATTRIBUTE_UNUSED, const xmlChar *val ATTRIBUTE_UNUSED) {
}

#define gen_nb_filepath 8

static const char *gen_filepath(int no) {
    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/xhtml1-strict.dtd");
    if (no == 5) return("http://missing.example.org/");
    if (no == 6) return("http://missing. example.org/");
    return(NULL);
}
static void des_filepath(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED) {
}

#define gen_nb_fileoutput 6

static const char *gen_fileoutput(int no) {
    if (no == 0) return("/missing.xml");
    if (no == 1) return("<foo/>");
    if (no == 2) return("ftp://missing.example.org/foo");
    if (no == 3) return("http://missing.example.org/");
    if (no == 4) return("http://missing. example.org/");
    return(NULL);
}
static void des_fileoutput(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED) {
}

#define gen_nb_xmlParserCtxtPtr 2
static xmlParserCtxtPtr gen_xmlParserCtxtPtr(int no) {
    if (no == 0) return(xmlNewParserCtxt());
    return(NULL);
}
static void des_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlParserCtxtPtr val) {
    if (val != NULL)
        xmlFreeParserCtxt(val);
}

#define gen_nb_xmlValidCtxtPtr 2
static xmlValidCtxtPtr gen_xmlValidCtxtPtr(int no) {
    if (no == 0) return(xmlNewValidCtxt());
    return(NULL);
}
static void des_xmlValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlValidCtxtPtr val) {
    if (val != NULL)
        xmlFreeValidCtxt(val);
}

#define gen_nb_xmlDocPtr 3
static xmlDocPtr gen_xmlDocPtr(int no) {
    if (no == 0) return(xmlNewDoc(BAD_CAST "1.0"));
    if (no == 1) return(xmlReadMemory("<foo/>", 6, "test", NULL, 0));
    return(NULL);
}
static void des_xmlDocPtr(int no ATTRIBUTE_UNUSED, xmlDocPtr val) {
    if (val != NULL)
        xmlFreeDoc(val);
}

#define gen_nb_xmlNodePtr 2
static xmlNodePtr gen_xmlNodePtr(int no) {
    if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL));
    return(NULL);
}
static void des_xmlNodePtr(int no ATTRIBUTE_UNUSED, xmlNodePtr val) {
    if (val != NULL) {
        xmlUnlinkNode(val);
        xmlFreeNode(val);
    }
}

#define gen_nb_xmlNodePtr_in 3
static xmlNodePtr gen_xmlNodePtr_in(int no) {
    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) {
}

#define gen_nb_xmlTextWriterPtr 2
static xmlTextWriterPtr gen_xmlTextWriterPtr(int no) {
    if (no == 0) return(xmlNewTextWriterFilename("test.out", 0));
    return(NULL);
}
static void des_xmlTextWriterPtr(int no ATTRIBUTE_UNUSED, xmlTextWriterPtr val) {
    if (val != NULL) xmlFreeTextWriter(val);
}

#define gen_nb_xmlTextReaderPtr 4
static xmlTextReaderPtr gen_xmlTextReaderPtr(int no) {
    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) {
    if (val != NULL) xmlFreeTextReader(val);
}

#define gen_nb_xmlBufferPtr 2
static xmlBufferPtr gen_xmlBufferPtr(int no) {
    if (no == 0) return(xmlBufferCreate());
    return(NULL);
}
static void des_xmlBufferPtr(int no ATTRIBUTE_UNUSED, xmlBufferPtr val) {
    if (val != NULL) {
        xmlBufferFree(val);
    }
}

#define gen_nb_xmlListPtr 2
static xmlListPtr gen_xmlListPtr(int no) {
    if (no == 0) return(xmlListCreate(NULL, NULL));
    return(NULL);
}
static void des_xmlListPtr(int no ATTRIBUTE_UNUSED, xmlListPtr val) {
    if (val != NULL) {
        xmlListDelete(val);
    }
}

#define gen_nb_xmlHashTablePtr 2
static xmlHashTablePtr gen_xmlHashTablePtr(int no) {
    if (no == 0) return(xmlHashCreate(10));
    return(NULL);
}
static void des_xmlHashTablePtr(int no ATTRIBUTE_UNUSED, xmlHashTablePtr val) {
    if (val != NULL) {
        xmlHashFree(val, NULL);
    }
}

#include <libxml/xpathInternals.h>

#define gen_nb_xmlXPathObjectPtr 5
static xmlXPathObjectPtr gen_xmlXPathObjectPtr(int no) {
    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) {
    if (val != NULL) {
        xmlXPathFreeObject(val);
    }
}


static void desret_int(int 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) {
    xmlFreeDoc(val);
}
static void desret_xmlNodePtr(xmlNodePtr val) {
    xmlUnlinkNode(val);
    xmlFreeNode(val);
}

/**
 * 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 ret = 0;

    ret += test_HTMLparser();
    ret += test_HTMLtree();
    ret += test_c14n();
    ret += test_catalog();
    ret += test_chvalid();
    ret += test_dict();
    ret += test_encoding();
    ret += test_entities();
    ret += test_hash();
    ret += test_list();
    ret += test_nanoftp();
    ret += test_nanohttp();
    ret += test_parser();
    ret += test_pattern();
    ret += test_relaxng();
    ret += test_schemasInternals();
    ret += test_tree();
    ret += test_uri();
    ret += test_valid();
    ret += test_xinclude();
    ret += test_xmlIO();
    ret += test_xmlerror();
    ret += test_xmlreader();
    ret += test_xmlsave();
    ret += test_xmlschemas();
    ret += test_xmlschemastypes();
    ret += test_xmlstring();
    ret += test_xmlwriter();
    ret += test_xpath();
    ret += test_xpointer();

    printf("Total: %d tests, %d errors\n", call_tests, ret);
    return(ret);
}


static int
test_UTF8ToHtml(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlAttrAllowed(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlAutoCloseTag(void) {
    int ret = 0;

#ifdef 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_xmlDocPtr;n_doc++) {
    for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
    for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
        mem_base = xmlMemBlocks();
        doc = gen_xmlDocPtr(n_doc);
        name = gen_const_xmlChar_ptr(n_name);
        elem = gen_xmlNodePtr(n_elem);

        ret_val = htmlAutoCloseTag(doc, name, elem);
        desret_int(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_name, name);
        des_xmlNodePtr(n_elem, elem);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlAutoCloseTag",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_name);
            printf(" %d", n_elem);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_htmlCreateMemoryParserCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlCreatePushParserCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlCtxtReadDoc(void) {
    int ret = 0;

#ifdef LIBXML_HTML_ENABLED
    int mem_base;
    htmlDocPtr ret_val;
    htmlParserCtxtPtr ctxt; /* an HTML parser context */
    int n_ctxt;
    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_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
    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();
        ctxt = gen_xmlParserCtxtPtr(n_ctxt);
        cur = gen_const_xmlChar_ptr(n_cur);
        URL = gen_filepath(n_URL);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = htmlCtxtReadDoc(ctxt, cur, URL, encoding, options);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        des_const_xmlChar_ptr(n_cur, cur);
        des_filepath(n_URL, URL);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlCtxtReadDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_cur);
            printf(" %d", n_URL);
            printf(" %d", n_encoding);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_htmlCtxtReadFile(void) {
    int ret = 0;

#ifdef LIBXML_HTML_ENABLED
    int mem_base;
    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_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_int;n_options++) {
        mem_base = xmlMemBlocks();
        ctxt = gen_xmlParserCtxtPtr(n_ctxt);
        filename = gen_filepath(n_filename);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = htmlCtxtReadFile(ctxt, filename, encoding, options);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        des_filepath(n_filename, filename);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlCtxtReadFile",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_filename);
            printf(" %d", n_encoding);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_htmlCtxtReadIO(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlCtxtReadMemory(void) {
    int ret = 0;

#ifdef 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_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_int;n_options++) {
        mem_base = xmlMemBlocks();
        ctxt = gen_xmlParserCtxtPtr(n_ctxt);
        buffer = gen_const_char_ptr(n_buffer);
        size = gen_int(n_size);
        URL = gen_filepath(n_URL);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = htmlCtxtReadMemory(ctxt, buffer, size, URL, encoding, options);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        des_const_char_ptr(n_buffer, buffer);
        des_int(n_size, size);
        des_filepath(n_URL, URL);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlCtxtReadMemory",
	           xmlMemBlocks() - mem_base);
	    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");
        }
    }
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_htmlCtxtReset(void) {
    int ret = 0;

#ifdef LIBXML_HTML_ENABLED
    int mem_base;
    htmlParserCtxtPtr ctxt; /* an HTML parser context */
    int n_ctxt;

    for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
        mem_base = xmlMemBlocks();
        ctxt = gen_xmlParserCtxtPtr(n_ctxt);

        htmlCtxtReset(ctxt);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlCtxtReset",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_htmlCtxtUseOptions(void) {
    int ret = 0;

#ifdef 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_xmlParserCtxtPtr;n_ctxt++) {
    for (n_options = 0;n_options < gen_nb_int;n_options++) {
        mem_base = xmlMemBlocks();
        ctxt = gen_xmlParserCtxtPtr(n_ctxt);
        options = gen_int(n_options);

        ret_val = htmlCtxtUseOptions(ctxt, options);
        desret_int(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlCtxtUseOptions",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_htmlElementAllowedHere(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlElementStatusHere(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlEncodeEntities(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlEntityLookup(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlEntityValueLookup(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlHandleOmittedElem(void) {
    int ret = 0;

#ifdef 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);

        ret_val = htmlHandleOmittedElem(val);
        desret_int(ret_val);
        call_tests++;
        des_int(n_val, val);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlHandleOmittedElem",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_val);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_htmlIsAutoClosed(void) {
    int ret = 0;

#ifdef 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_xmlDocPtr;n_doc++) {
    for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
        mem_base = xmlMemBlocks();
        doc = gen_xmlDocPtr(n_doc);
        elem = gen_xmlNodePtr(n_elem);

        ret_val = htmlIsAutoClosed(doc, elem);
        desret_int(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_elem, elem);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlIsAutoClosed",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_elem);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_htmlIsScriptAttribute(void) {
    int ret = 0;

#ifdef 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);

        ret_val = htmlIsScriptAttribute(name);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlIsScriptAttribute",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_name);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_htmlNodeStatus(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlParseCharRef(void) {
    int ret = 0;

#ifdef 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_xmlParserCtxtPtr;n_ctxt++) {
        mem_base = xmlMemBlocks();
        ctxt = gen_xmlParserCtxtPtr(n_ctxt);

        ret_val = htmlParseCharRef(ctxt);
        desret_int(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlParseCharRef",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_htmlParseChunk(void) {
    int ret = 0;

#ifdef LIBXML_HTML_ENABLED
#ifdef 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_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);
        chunk = gen_const_char_ptr(n_chunk);
        size = gen_int(n_size);
        terminate = gen_int(n_terminate);

        ret_val = htmlParseChunk(ctxt, chunk, size, terminate);
        desret_int(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        des_const_char_ptr(n_chunk, chunk);
        des_int(n_size, size);
        des_int(n_terminate, terminate);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlParseChunk",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_chunk);
            printf(" %d", n_size);
            printf(" %d", n_terminate);
            printf("\n");
        }
    }
    }
    }
    }
#endif
#endif

    return(ret);
}


static int
test_htmlParseDoc(void) {
    int ret = 0;

#ifdef LIBXML_HTML_ENABLED
    int mem_base;
    htmlDocPtr ret_val;
    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_xmlChar_ptr;n_cur++) {
    for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
        mem_base = xmlMemBlocks();
        cur = gen_xmlChar_ptr(n_cur);
        encoding = gen_const_char_ptr(n_encoding);

        ret_val = htmlParseDoc(cur, encoding);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_xmlChar_ptr(n_cur, cur);
        des_const_char_ptr(n_encoding, encoding);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlParseDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_encoding);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_htmlParseDocument(void) {
    int ret = 0;

#ifdef 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_xmlParserCtxtPtr;n_ctxt++) {
        mem_base = xmlMemBlocks();
        ctxt = gen_xmlParserCtxtPtr(n_ctxt);

        ret_val = htmlParseDocument(ctxt);
        desret_int(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlParseDocument",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_htmlParseElement(void) {
    int ret = 0;

#ifdef LIBXML_HTML_ENABLED
    int mem_base;
    htmlParserCtxtPtr ctxt; /* an HTML parser context */
    int n_ctxt;

    for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
        mem_base = xmlMemBlocks();
        ctxt = gen_xmlParserCtxtPtr(n_ctxt);

        htmlParseElement(ctxt);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlParseElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_htmlParseEntityRef(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlParseFile(void) {
    int ret = 0;

#ifdef 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);
        encoding = gen_const_char_ptr(n_encoding);

        ret_val = htmlParseFile(filename, encoding);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_filepath(n_filename, filename);
        des_const_char_ptr(n_encoding, encoding);
        xmlResetLastError();
    }
    }
#endif

    return(ret);
}


static int
test_htmlReadDoc(void) {
    int ret = 0;

#ifdef 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);
        URL = gen_filepath(n_URL);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = htmlReadDoc(cur, URL, encoding, options);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_cur, cur);
        des_filepath(n_URL, URL);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlReadDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_URL);
            printf(" %d", n_encoding);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_htmlReadFile(void) {
    int ret = 0;

#ifdef 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);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = htmlReadFile(filename, encoding, options);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_filepath(n_filename, filename);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlReadFile",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf(" %d", n_encoding);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_htmlReadIO(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlReadMemory(void) {
    int ret = 0;

#ifdef 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);
        size = gen_int(n_size);
        URL = gen_filepath(n_URL);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = htmlReadMemory(buffer, size, URL, encoding, options);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_const_char_ptr(n_buffer, buffer);
        des_int(n_size, size);
        des_filepath(n_URL, URL);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlReadMemory",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buffer);
            printf(" %d", n_size);
            printf(" %d", n_URL);
            printf(" %d", n_encoding);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_htmlSAXParseDoc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlSAXParseFile(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlTagLookup(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_HTMLparser(void) {
    int ret = 0;

    printf("Testing HTMLparser ...\n");
    ret += test_UTF8ToHtml();
    ret += test_htmlAttrAllowed();
    ret += test_htmlAutoCloseTag();
    ret += test_htmlCreateMemoryParserCtxt();
    ret += test_htmlCreatePushParserCtxt();
    ret += test_htmlCtxtReadDoc();
    ret += test_htmlCtxtReadFile();
    ret += test_htmlCtxtReadIO();
    ret += test_htmlCtxtReadMemory();
    ret += test_htmlCtxtReset();
    ret += test_htmlCtxtUseOptions();
    ret += test_htmlElementAllowedHere();
    ret += test_htmlElementStatusHere();
    ret += test_htmlEncodeEntities();
    ret += test_htmlEntityLookup();
    ret += test_htmlEntityValueLookup();
    ret += test_htmlHandleOmittedElem();
    ret += test_htmlIsAutoClosed();
    ret += test_htmlIsScriptAttribute();
    ret += test_htmlNodeStatus();
    ret += test_htmlParseCharRef();
    ret += test_htmlParseChunk();
    ret += test_htmlParseDoc();
    ret += test_htmlParseDocument();
    ret += test_htmlParseElement();
    ret += test_htmlParseEntityRef();
    ret += test_htmlParseFile();
    ret += test_htmlReadDoc();
    ret += test_htmlReadFile();
    ret += test_htmlReadIO();
    ret += test_htmlReadMemory();
    ret += test_htmlSAXParseDoc();
    ret += test_htmlSAXParseFile();
    ret += test_htmlTagLookup();

    if (ret != 0)
	printf("Module HTMLparser: %d errors\n", ret);
    return(ret);
}

static int
test_htmlDocContentDumpFormatOutput(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlDocContentDumpOutput(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlDocDump(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlDocDumpMemory(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlGetMetaEncoding(void) {
    int ret = 0;

#ifdef 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_xmlDocPtr;n_doc++) {
        mem_base = xmlMemBlocks();
        doc = gen_xmlDocPtr(n_doc);

        ret_val = htmlGetMetaEncoding(doc);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlGetMetaEncoding",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_htmlIsBooleanAttr(void) {
    int ret = 0;

#ifdef 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);

        ret_val = htmlIsBooleanAttr(name);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlIsBooleanAttr",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_name);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_htmlNewDoc(void) {
    int ret = 0;

#ifdef 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);
        ExternalID = gen_const_xmlChar_ptr(n_ExternalID);

        ret_val = htmlNewDoc(URI, ExternalID);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_URI, URI);
        des_const_xmlChar_ptr(n_ExternalID, ExternalID);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlNewDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_URI);
            printf(" %d", n_ExternalID);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_htmlNewDocNoDtD(void) {
    int ret = 0;

#ifdef 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);
        ExternalID = gen_const_xmlChar_ptr(n_ExternalID);

        ret_val = htmlNewDocNoDtD(URI, ExternalID);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_URI, URI);
        des_const_xmlChar_ptr(n_ExternalID, ExternalID);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlNewDocNoDtD",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_URI);
            printf(" %d", n_ExternalID);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_htmlNodeDump(void) {
    int ret = 0;

#ifdef LIBXML_HTML_ENABLED
#ifdef 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);
        doc = gen_xmlDocPtr(n_doc);
        cur = gen_xmlNodePtr(n_cur);

        ret_val = htmlNodeDump(buf, doc, cur);
        desret_int(ret_val);
        call_tests++;
        des_xmlBufferPtr(n_buf, buf);
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlNodeDump",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buf);
            printf(" %d", n_doc);
            printf(" %d", n_cur);
            printf("\n");
        }
    }
    }
    }
#endif
#endif

    return(ret);
}


static int
test_htmlNodeDumpFile(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlNodeDumpFileFormat(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlNodeDumpFormatOutput(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlNodeDumpOutput(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_htmlSaveFile(void) {
    int ret = 0;

#ifdef LIBXML_HTML_ENABLED
#ifdef 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);
        cur = gen_xmlDocPtr(n_cur);

        ret_val = htmlSaveFile(filename, cur);
        desret_int(ret_val);
        call_tests++;
        des_fileoutput(n_filename, filename);
        des_xmlDocPtr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlSaveFile",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf(" %d", n_cur);
            printf("\n");
        }
    }
    }
#endif
#endif

    return(ret);
}


static int
test_htmlSaveFileEnc(void) {
    int ret = 0;

#ifdef LIBXML_HTML_ENABLED
#ifdef 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);
        cur = gen_xmlDocPtr(n_cur);
        encoding = gen_const_char_ptr(n_encoding);

        ret_val = htmlSaveFileEnc(filename, cur, encoding);
        desret_int(ret_val);
        call_tests++;
        des_fileoutput(n_filename, filename);
        des_xmlDocPtr(n_cur, cur);
        des_const_char_ptr(n_encoding, encoding);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlSaveFileEnc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf(" %d", n_cur);
            printf(" %d", n_encoding);
            printf("\n");
        }
    }
    }
    }
#endif
#endif

    return(ret);
}


static int
test_htmlSaveFileFormat(void) {
    int ret = 0;

#ifdef LIBXML_HTML_ENABLED
#ifdef 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);
        cur = gen_xmlDocPtr(n_cur);
        encoding = gen_const_char_ptr(n_encoding);
        format = gen_int(n_format);

        ret_val = htmlSaveFileFormat(filename, cur, encoding, format);
        desret_int(ret_val);
        call_tests++;
        des_fileoutput(n_filename, filename);
        des_xmlDocPtr(n_cur, cur);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_format, format);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlSaveFileFormat",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf(" %d", n_cur);
            printf(" %d", n_encoding);
            printf(" %d", n_format);
            printf("\n");
        }
    }
    }
    }
    }
#endif
#endif

    return(ret);
}


static int
test_htmlSetMetaEncoding(void) {
    int ret = 0;

#ifdef 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_xmlDocPtr;n_doc++) {
    for (n_encoding = 0;n_encoding < gen_nb_const_xmlChar_ptr;n_encoding++) {
        mem_base = xmlMemBlocks();
        doc = gen_xmlDocPtr(n_doc);
        encoding = gen_const_xmlChar_ptr(n_encoding);

        ret_val = htmlSetMetaEncoding(doc, encoding);
        desret_int(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_encoding, encoding);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in htmlSetMetaEncoding",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_encoding);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}

static int
test_HTMLtree(void) {
    int ret = 0;

    printf("Testing HTMLtree ...\n");
    ret += test_htmlDocContentDumpFormatOutput();
    ret += test_htmlDocContentDumpOutput();
    ret += test_htmlDocDump();
    ret += test_htmlDocDumpMemory();
    ret += test_htmlGetMetaEncoding();
    ret += test_htmlIsBooleanAttr();
    ret += test_htmlNewDoc();
    ret += test_htmlNewDocNoDtD();
    ret += test_htmlNodeDump();
    ret += test_htmlNodeDumpFile();
    ret += test_htmlNodeDumpFileFormat();
    ret += test_htmlNodeDumpFormatOutput();
    ret += test_htmlNodeDumpOutput();
    ret += test_htmlSaveFile();
    ret += test_htmlSaveFileEnc();
    ret += test_htmlSaveFileFormat();
    ret += test_htmlSetMetaEncoding();

    if (ret != 0)
	printf("Module HTMLtree: %d errors\n", ret);
    return(ret);
}

static int
test_xmlC14NDocDumpMemory(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlC14NDocSave(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlC14NDocSaveTo(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlC14NExecute(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_c14n(void) {
    int ret = 0;

    printf("Testing c14n ...\n");
    ret += test_xmlC14NDocDumpMemory();
    ret += test_xmlC14NDocSave();
    ret += test_xmlC14NDocSaveTo();
    ret += test_xmlC14NExecute();

    if (ret != 0)
	printf("Module c14n: %d errors\n", ret);
    return(ret);
}

static int
test_xmlACatalogAdd(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlACatalogDump(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlACatalogRemove(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlACatalogResolve(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlACatalogResolvePublic(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlACatalogResolveSystem(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlACatalogResolveURI(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCatalogAdd(void) {
    int ret = 0;

#ifdef 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);
        orig = gen_const_xmlChar_ptr(n_orig);
        replace = gen_const_xmlChar_ptr(n_replace);

        ret_val = xmlCatalogAdd(type, orig, replace);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_type, type);
        des_const_xmlChar_ptr(n_orig, orig);
        des_const_xmlChar_ptr(n_replace, replace);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCatalogAdd",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_type);
            printf(" %d", n_orig);
            printf(" %d", n_replace);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlCatalogAddLocal(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCatalogCleanup(void) {
    int ret = 0;

#ifdef LIBXML_CATALOG_ENABLED


        xmlCatalogCleanup();
        call_tests++;
        xmlResetLastError();
#endif

    return(ret);
}


static int
test_xmlCatalogConvert(void) {
    int ret = 0;

#ifdef LIBXML_CATALOG_ENABLED
    int ret_val;


        ret_val = xmlCatalogConvert();
        desret_int(ret_val);
        call_tests++;
        xmlResetLastError();
#endif

    return(ret);
}


static int
test_xmlCatalogDump(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCatalogGetDefaults(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCatalogIsEmpty(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCatalogLocalResolve(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCatalogLocalResolveURI(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCatalogRemove(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlCatalogRemove(value);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_value, value);
        xmlResetLastError();
    }
#endif

    return(ret);
}


static int
test_xmlCatalogResolve(void) {
    int ret = 0;

#ifdef LIBXML_CATALOG_ENABLED
    int mem_base;
    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++) {
        mem_base = xmlMemBlocks();
        pubID = gen_const_xmlChar_ptr(n_pubID);
        sysID = gen_const_xmlChar_ptr(n_sysID);

        ret_val = xmlCatalogResolve(pubID, sysID);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_pubID, pubID);
        des_const_xmlChar_ptr(n_sysID, sysID);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCatalogResolve",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_pubID);
            printf(" %d", n_sysID);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlCatalogResolvePublic(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlCatalogResolvePublic(pubID);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_pubID, pubID);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCatalogResolvePublic",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_pubID);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlCatalogResolveSystem(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlCatalogResolveSystem(sysID);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_sysID, sysID);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCatalogResolveSystem",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_sysID);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlCatalogResolveURI(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlCatalogResolveURI(URI);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_URI, URI);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCatalogResolveURI",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_URI);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlCatalogSetDebug(void) {
    int ret = 0;

#ifdef LIBXML_CATALOG_ENABLED
    int mem_base;
    int ret_val;
    int level; /* the debug level of catalogs required */
    int n_level;

    for (n_level = 0;n_level < gen_nb_int;n_level++) {
        mem_base = xmlMemBlocks();
        level = gen_int(n_level);

        ret_val = xmlCatalogSetDebug(level);
        desret_int(ret_val);
        call_tests++;
        des_int(n_level, level);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCatalogSetDebug",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_level);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlCatalogSetDefaultPrefer(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCatalogSetDefaults(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlConvertSGMLCatalog(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlInitializeCatalog(void) {
    int ret = 0;

#ifdef 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);
	    ret++;
            printf("\n");
        }
#endif

    return(ret);
}


static int
test_xmlLoadACatalog(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlLoadCatalog(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlLoadCatalog(filename);
        desret_int(ret_val);
        call_tests++;
        des_filepath(n_filename, filename);
        xmlResetLastError();
    }
#endif

    return(ret);
}


static int
test_xmlLoadCatalogs(void) {
    int ret = 0;

#ifdef 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);

        xmlLoadCatalogs(pathss);
        call_tests++;
        des_const_char_ptr(n_pathss, pathss);
        xmlResetLastError();
    }
#endif

    return(ret);
}


static int
test_xmlLoadSGMLSuperCatalog(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewCatalog(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParseCatalogFile(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlParseCatalogFile(filename);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_filepath(n_filename, filename);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlParseCatalogFile",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf("\n");
        }
    }
#endif

    return(ret);
}

static int
test_catalog(void) {
    int ret = 0;

    printf("Testing catalog ...\n");
    ret += test_xmlACatalogAdd();
    ret += test_xmlACatalogDump();
    ret += test_xmlACatalogRemove();
    ret += test_xmlACatalogResolve();
    ret += test_xmlACatalogResolvePublic();
    ret += test_xmlACatalogResolveSystem();
    ret += test_xmlACatalogResolveURI();
    ret += test_xmlCatalogAdd();
    ret += test_xmlCatalogAddLocal();
    ret += test_xmlCatalogCleanup();
    ret += test_xmlCatalogConvert();
    ret += test_xmlCatalogDump();
    ret += test_xmlCatalogGetDefaults();
    ret += test_xmlCatalogIsEmpty();
    ret += test_xmlCatalogLocalResolve();
    ret += test_xmlCatalogLocalResolveURI();
    ret += test_xmlCatalogRemove();
    ret += test_xmlCatalogResolve();
    ret += test_xmlCatalogResolvePublic();
    ret += test_xmlCatalogResolveSystem();
    ret += test_xmlCatalogResolveURI();
    ret += test_xmlCatalogSetDebug();
    ret += test_xmlCatalogSetDefaultPrefer();
    ret += test_xmlCatalogSetDefaults();
    ret += test_xmlConvertSGMLCatalog();
    ret += test_xmlInitializeCatalog();
    ret += test_xmlLoadACatalog();
    ret += test_xmlLoadCatalog();
    ret += test_xmlLoadCatalogs();
    ret += test_xmlLoadSGMLSuperCatalog();
    ret += test_xmlNewCatalog();
    ret += test_xmlParseCatalogFile();

    if (ret != 0)
	printf("Module catalog: %d errors\n", ret);
    return(ret);
}

static int
test_xmlCharInRange(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIsBaseChar(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIsBlank(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIsChar(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIsCombining(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIsDigit(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIsExtender(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIsIdeographic(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIsPubidChar(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_chvalid(void) {
    int ret = 0;

    printf("Testing chvalid ...\n");
    ret += test_xmlCharInRange();
    ret += test_xmlIsBaseChar();
    ret += test_xmlIsBlank();
    ret += test_xmlIsChar();
    ret += test_xmlIsCombining();
    ret += test_xmlIsDigit();
    ret += test_xmlIsExtender();
    ret += test_xmlIsIdeographic();
    ret += test_xmlIsPubidChar();

    if (ret != 0)
	printf("Module chvalid: %d errors\n", ret);
    return(ret);
}

static int
test_xmlDictCreate(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDictCreateSub(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDictLookup(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDictOwns(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDictQLookup(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDictReference(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDictSize(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_dict(void) {
    int ret = 0;

    printf("Testing dict ...\n");
    ret += test_xmlDictCreate();
    ret += test_xmlDictCreateSub();
    ret += test_xmlDictLookup();
    ret += test_xmlDictOwns();
    ret += test_xmlDictQLookup();
    ret += test_xmlDictReference();
    ret += test_xmlDictSize();

    if (ret != 0)
	printf("Module dict: %d errors\n", ret);
    return(ret);
}

static int
test_UTF8Toisolat1(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_isolat1ToUTF8(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlAddEncodingAlias(void) {
    int 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);
        alias = gen_const_char_ptr(n_alias);

        ret_val = xmlAddEncodingAlias(name, alias);
        desret_int(ret_val);
        call_tests++;
        des_const_char_ptr(n_name, name);
        des_const_char_ptr(n_alias, alias);
        xmlResetLastError();
    }
    }

    return(ret);
}


static int
test_xmlCharEncCloseFunc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCharEncFirstLine(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCharEncInFunc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCharEncOutFunc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCleanupCharEncodingHandlers(void) {
    int ret = 0;



        xmlCleanupCharEncodingHandlers();
        call_tests++;
        xmlResetLastError();

    return(ret);
}


static int
test_xmlCleanupEncodingAliases(void) {
    int 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);
	    ret++;
            printf("\n");
        }

    return(ret);
}


static int
test_xmlDelEncodingAlias(void) {
    int 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);

        ret_val = xmlDelEncodingAlias(alias);
        desret_int(ret_val);
        call_tests++;
        des_const_char_ptr(n_alias, alias);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlDelEncodingAlias",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_alias);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlDetectCharEncoding(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlFindCharEncodingHandler(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetCharEncodingHandler(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetCharEncodingName(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetEncodingAlias(void) {
    int 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);

        ret_val = xmlGetEncodingAlias(alias);
        desret_const_char_ptr(ret_val);
        call_tests++;
        des_const_char_ptr(n_alias, alias);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlGetEncodingAlias",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_alias);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlInitCharEncodingHandlers(void) {
    int ret = 0;



        xmlInitCharEncodingHandlers();
        call_tests++;
        xmlResetLastError();

    return(ret);
}


static int
test_xmlNewCharEncodingHandler(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParseCharEncoding(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRegisterCharEncodingHandler(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_encoding(void) {
    int ret = 0;

    printf("Testing encoding ...\n");
    ret += test_UTF8Toisolat1();
    ret += test_isolat1ToUTF8();
    ret += test_xmlAddEncodingAlias();
    ret += test_xmlCharEncCloseFunc();
    ret += test_xmlCharEncFirstLine();
    ret += test_xmlCharEncInFunc();
    ret += test_xmlCharEncOutFunc();
    ret += test_xmlCleanupCharEncodingHandlers();
    ret += test_xmlCleanupEncodingAliases();
    ret += test_xmlDelEncodingAlias();
    ret += test_xmlDetectCharEncoding();
    ret += test_xmlFindCharEncodingHandler();
    ret += test_xmlGetCharEncodingHandler();
    ret += test_xmlGetCharEncodingName();
    ret += test_xmlGetEncodingAlias();
    ret += test_xmlInitCharEncodingHandlers();
    ret += test_xmlNewCharEncodingHandler();
    ret += test_xmlParseCharEncoding();
    ret += test_xmlRegisterCharEncodingHandler();

    if (ret != 0)
	printf("Module encoding: %d errors\n", ret);
    return(ret);
}

static int
test_xmlAddDocEntity(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlAddDtdEntity(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCleanupPredefinedEntities(void) {
    int ret = 0;

    int mem_base;

        mem_base = xmlMemBlocks();

        xmlCleanupPredefinedEntities();
        call_tests++;
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCleanupPredefinedEntities",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf("\n");
        }

    return(ret);
}


static int
test_xmlCopyEntitiesTable(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCreateEntitiesTable(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDumpEntitiesTable(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDumpEntityDecl(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlEncodeEntitiesReentrant(void) {
    int 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);
        input = gen_const_xmlChar_ptr(n_input);

        ret_val = xmlEncodeEntitiesReentrant(doc, input);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_input, input);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlEncodeEntitiesReentrant",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_input);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlEncodeSpecialChars(void) {
    int 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);
        input = gen_const_xmlChar_ptr(n_input);

        ret_val = xmlEncodeSpecialChars(doc, input);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_input, input);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlEncodeSpecialChars",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_input);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlGetDocEntity(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetDtdEntity(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetParameterEntity(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetPredefinedEntity(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlInitializePredefinedEntities(void) {
    int ret = 0;

    int mem_base;

        mem_base = xmlMemBlocks();

        xmlInitializePredefinedEntities();
        call_tests++;
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlInitializePredefinedEntities",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf("\n");
        }

    return(ret);
}

static int
test_entities(void) {
    int ret = 0;

    printf("Testing entities ...\n");
    ret += test_xmlAddDocEntity();
    ret += test_xmlAddDtdEntity();
    ret += test_xmlCleanupPredefinedEntities();
    ret += test_xmlCopyEntitiesTable();
    ret += test_xmlCreateEntitiesTable();
    ret += test_xmlDumpEntitiesTable();
    ret += test_xmlDumpEntityDecl();
    ret += test_xmlEncodeEntitiesReentrant();
    ret += test_xmlEncodeSpecialChars();
    ret += test_xmlGetDocEntity();
    ret += test_xmlGetDtdEntity();
    ret += test_xmlGetParameterEntity();
    ret += test_xmlGetPredefinedEntity();
    ret += test_xmlInitializePredefinedEntities();

    if (ret != 0)
	printf("Module entities: %d errors\n", ret);
    return(ret);
}

static int
test_xmlHashAddEntry(void) {
    int ret = 0;

    int mem_base;
    int ret_val;
    xmlHashTablePtr table; /* the hash table */
    int n_table;
    const xmlChar * name; /* the name of the userdata */
    int n_name;
    void * userdata; /* a pointer to the userdata */
    int n_userdata;

    for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
    for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
    for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
        mem_base = xmlMemBlocks();
        table = gen_xmlHashTablePtr(n_table);
        name = gen_const_xmlChar_ptr(n_name);
        userdata = gen_userdata(n_userdata);

        ret_val = xmlHashAddEntry(table, name, userdata);
        desret_int(ret_val);
        call_tests++;
        des_xmlHashTablePtr(n_table, table);
        des_const_xmlChar_ptr(n_name, name);
        des_userdata(n_userdata, userdata);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlHashAddEntry",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_table);
            printf(" %d", n_name);
            printf(" %d", n_userdata);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlHashAddEntry2(void) {
    int ret = 0;

    int mem_base;
    int ret_val;
    xmlHashTablePtr table; /* the hash table */
    int n_table;
    const xmlChar * name; /* the name of the userdata */
    int n_name;
    const xmlChar * name2; /* a second name of the userdata */
    int n_name2;
    void * userdata; /* a pointer to the userdata */
    int n_userdata;

    for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
    for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
    for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
    for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
        mem_base = xmlMemBlocks();
        table = gen_xmlHashTablePtr(n_table);
        name = gen_const_xmlChar_ptr(n_name);
        name2 = gen_const_xmlChar_ptr(n_name2);
        userdata = gen_userdata(n_userdata);

        ret_val = xmlHashAddEntry2(table, name, name2, userdata);
        desret_int(ret_val);
        call_tests++;
        des_xmlHashTablePtr(n_table, table);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_name2, name2);
        des_userdata(n_userdata, userdata);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlHashAddEntry2",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_table);
            printf(" %d", n_name);
            printf(" %d", n_name2);
            printf(" %d", n_userdata);
            printf("\n");
        }
    }
    }
    }
    }

    return(ret);
}


static int
test_xmlHashAddEntry3(void) {
    int ret = 0;

    int mem_base;
    int ret_val;
    xmlHashTablePtr table; /* the hash table */
    int n_table;
    const xmlChar * name; /* the name of the userdata */
    int n_name;
    const xmlChar * name2; /* a second name of the userdata */
    int n_name2;
    const xmlChar * name3; /* a third name of the userdata */
    int n_name3;
    void * userdata; /* a pointer to the userdata */
    int n_userdata;

    for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
    for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
    for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
    for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
    for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
        mem_base = xmlMemBlocks();
        table = gen_xmlHashTablePtr(n_table);
        name = gen_const_xmlChar_ptr(n_name);
        name2 = gen_const_xmlChar_ptr(n_name2);
        name3 = gen_const_xmlChar_ptr(n_name3);
        userdata = gen_userdata(n_userdata);

        ret_val = xmlHashAddEntry3(table, name, name2, name3, userdata);
        desret_int(ret_val);
        call_tests++;
        des_xmlHashTablePtr(n_table, table);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_name2, name2);
        des_const_xmlChar_ptr(n_name3, name3);
        des_userdata(n_userdata, userdata);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlHashAddEntry3",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_table);
            printf(" %d", n_name);
            printf(" %d", n_name2);
            printf(" %d", n_name3);
            printf(" %d", n_userdata);
            printf("\n");
        }
    }
    }
    }
    }
    }

    return(ret);
}


static int
test_xmlHashCopy(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashCreate(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashLookup(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashLookup2(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashLookup3(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashQLookup(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashQLookup2(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashQLookup3(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashRemoveEntry(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashRemoveEntry2(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashRemoveEntry3(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashScan(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashScan3(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashScanFull(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashScanFull3(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashSize(void) {
    int ret = 0;

    int mem_base;
    int ret_val;
    xmlHashTablePtr table; /* the hash table */
    int n_table;

    for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
        mem_base = xmlMemBlocks();
        table = gen_xmlHashTablePtr(n_table);

        ret_val = xmlHashSize(table);
        desret_int(ret_val);
        call_tests++;
        des_xmlHashTablePtr(n_table, table);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlHashSize",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_table);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlHashUpdateEntry(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashUpdateEntry2(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHashUpdateEntry3(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_hash(void) {
    int ret = 0;

    printf("Testing hash ...\n");
    ret += test_xmlHashAddEntry();
    ret += test_xmlHashAddEntry2();
    ret += test_xmlHashAddEntry3();
    ret += test_xmlHashCopy();
    ret += test_xmlHashCreate();
    ret += test_xmlHashLookup();
    ret += test_xmlHashLookup2();
    ret += test_xmlHashLookup3();
    ret += test_xmlHashQLookup();
    ret += test_xmlHashQLookup2();
    ret += test_xmlHashQLookup3();
    ret += test_xmlHashRemoveEntry();
    ret += test_xmlHashRemoveEntry2();
    ret += test_xmlHashRemoveEntry3();
    ret += test_xmlHashScan();
    ret += test_xmlHashScan3();
    ret += test_xmlHashScanFull();
    ret += test_xmlHashScanFull3();
    ret += test_xmlHashSize();
    ret += test_xmlHashUpdateEntry();
    ret += test_xmlHashUpdateEntry2();
    ret += test_xmlHashUpdateEntry3();

    if (ret != 0)
	printf("Module hash: %d errors\n", ret);
    return(ret);
}

static int
test_xmlLinkGetData(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlListAppend(void) {
    int 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);
        data = gen_userdata(n_data);

        ret_val = xmlListAppend(l, data);
        desret_int(ret_val);
        call_tests++;
        des_xmlListPtr(n_l, l);
        des_userdata(n_data, data);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListAppend",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf(" %d", n_data);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlListClear(void) {
    int 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);

        xmlListClear(l);
        call_tests++;
        des_xmlListPtr(n_l, l);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListClear",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlListCopy(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlListCreate(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlListDup(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlListEmpty(void) {
    int 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);

        ret_val = xmlListEmpty(l);
        desret_int(ret_val);
        call_tests++;
        des_xmlListPtr(n_l, l);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListEmpty",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlListEnd(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlListFront(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlListInsert(void) {
    int 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);
        data = gen_userdata(n_data);

        ret_val = xmlListInsert(l, data);
        desret_int(ret_val);
        call_tests++;
        des_xmlListPtr(n_l, l);
        des_userdata(n_data, data);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListInsert",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf(" %d", n_data);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlListMerge(void) {
    int 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);
        l2 = gen_xmlListPtr(n_l2);

        xmlListMerge(l1, l2);
        call_tests++;
        des_xmlListPtr(n_l1, l1);
        des_xmlListPtr(n_l2, l2);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListMerge",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l1);
            printf(" %d", n_l2);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlListPopBack(void) {
    int 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);

        xmlListPopBack(l);
        call_tests++;
        des_xmlListPtr(n_l, l);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListPopBack",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlListPopFront(void) {
    int 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);

        xmlListPopFront(l);
        call_tests++;
        des_xmlListPtr(n_l, l);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListPopFront",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlListPushBack(void) {
    int 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);
        data = gen_userdata(n_data);

        ret_val = xmlListPushBack(l, data);
        desret_int(ret_val);
        call_tests++;
        des_xmlListPtr(n_l, l);
        des_userdata(n_data, data);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListPushBack",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf(" %d", n_data);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlListPushFront(void) {
    int 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);
        data = gen_userdata(n_data);

        ret_val = xmlListPushFront(l, data);
        desret_int(ret_val);
        call_tests++;
        des_xmlListPtr(n_l, l);
        des_userdata(n_data, data);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListPushFront",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf(" %d", n_data);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlListRemoveAll(void) {
    int 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);
        data = gen_userdata(n_data);

        ret_val = xmlListRemoveAll(l, data);
        desret_int(ret_val);
        call_tests++;
        des_xmlListPtr(n_l, l);
        des_userdata(n_data, data);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListRemoveAll",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf(" %d", n_data);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlListRemoveFirst(void) {
    int 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);
        data = gen_userdata(n_data);

        ret_val = xmlListRemoveFirst(l, data);
        desret_int(ret_val);
        call_tests++;
        des_xmlListPtr(n_l, l);
        des_userdata(n_data, data);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListRemoveFirst",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf(" %d", n_data);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlListRemoveLast(void) {
    int 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);
        data = gen_userdata(n_data);

        ret_val = xmlListRemoveLast(l, data);
        desret_int(ret_val);
        call_tests++;
        des_xmlListPtr(n_l, l);
        des_userdata(n_data, data);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListRemoveLast",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf(" %d", n_data);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlListReverse(void) {
    int 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);

        xmlListReverse(l);
        call_tests++;
        des_xmlListPtr(n_l, l);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListReverse",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlListReverseSearch(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlListReverseWalk(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlListSearch(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlListSize(void) {
    int 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);

        ret_val = xmlListSize(l);
        desret_int(ret_val);
        call_tests++;
        des_xmlListPtr(n_l, l);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListSize",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlListSort(void) {
    int 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);

        xmlListSort(l);
        call_tests++;
        des_xmlListPtr(n_l, l);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlListSort",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_l);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlListWalk(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_list(void) {
    int ret = 0;

    printf("Testing list ...\n");
    ret += test_xmlLinkGetData();
    ret += test_xmlListAppend();
    ret += test_xmlListClear();
    ret += test_xmlListCopy();
    ret += test_xmlListCreate();
    ret += test_xmlListDup();
    ret += test_xmlListEmpty();
    ret += test_xmlListEnd();
    ret += test_xmlListFront();
    ret += test_xmlListInsert();
    ret += test_xmlListMerge();
    ret += test_xmlListPopBack();
    ret += test_xmlListPopFront();
    ret += test_xmlListPushBack();
    ret += test_xmlListPushFront();
    ret += test_xmlListRemoveAll();
    ret += test_xmlListRemoveFirst();
    ret += test_xmlListRemoveLast();
    ret += test_xmlListReverse();
    ret += test_xmlListReverseSearch();
    ret += test_xmlListReverseWalk();
    ret += test_xmlListSearch();
    ret += test_xmlListSize();
    ret += test_xmlListSort();
    ret += test_xmlListWalk();

    if (ret != 0)
	printf("Module list: %d errors\n", ret);
    return(ret);
}

static int
test_xmlNanoFTPCheckResponse(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPCleanup(void) {
    int ret = 0;

#ifdef LIBXML_FTP_ENABLED
    int mem_base;

        mem_base = xmlMemBlocks();

        xmlNanoFTPCleanup();
        call_tests++;
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNanoFTPCleanup",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf("\n");
        }
#endif

    return(ret);
}


static int
test_xmlNanoFTPClose(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPCloseConnection(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPConnect(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPConnectTo(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPCwd(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPDele(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPGet(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPGetConnection(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPGetResponse(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPGetSocket(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPInit(void) {
    int ret = 0;

#ifdef LIBXML_FTP_ENABLED
    int mem_base;

        mem_base = xmlMemBlocks();

        xmlNanoFTPInit();
        call_tests++;
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNanoFTPInit",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf("\n");
        }
#endif

    return(ret);
}


static int
test_xmlNanoFTPList(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPNewCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPOpen(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPProxy(void) {
    int ret = 0;

#ifdef LIBXML_FTP_ENABLED
    const char * host; /* the proxy host name */
    int n_host;
    int port; /* the proxy port */
    int n_port;
    const char * user; /* the proxy user name */
    int n_user;
    const char * passwd; /* the proxy password */
    int n_passwd;
    int type; /* the type of proxy 1 for using SITE, 2 for USER a@b */
    int n_type;

    for (n_host = 0;n_host < gen_nb_const_char_ptr;n_host++) {
    for (n_port = 0;n_port < gen_nb_int;n_port++) {
    for (n_user = 0;n_user < gen_nb_const_char_ptr;n_user++) {
    for (n_passwd = 0;n_passwd < gen_nb_const_char_ptr;n_passwd++) {
    for (n_type = 0;n_type < gen_nb_int;n_type++) {
        host = gen_const_char_ptr(n_host);
        port = gen_int(n_port);
        user = gen_const_char_ptr(n_user);
        passwd = gen_const_char_ptr(n_passwd);
        type = gen_int(n_type);

        xmlNanoFTPProxy(host, port, user, passwd, type);
        call_tests++;
        des_const_char_ptr(n_host, host);
        des_int(n_port, port);
        des_const_char_ptr(n_user, user);
        des_const_char_ptr(n_passwd, passwd);
        des_int(n_type, type);
        xmlResetLastError();
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlNanoFTPQuit(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPRead(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoFTPScanProxy(void) {
    int ret = 0;

#ifdef LIBXML_FTP_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);

        xmlNanoFTPScanProxy(URL);
        call_tests++;
        des_filepath(n_URL, URL);
        xmlResetLastError();
    }
#endif

    return(ret);
}


static int
test_xmlNanoFTPUpdateURL(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_nanoftp(void) {
    int ret = 0;

    printf("Testing nanoftp ...\n");
    ret += test_xmlNanoFTPCheckResponse();
    ret += test_xmlNanoFTPCleanup();
    ret += test_xmlNanoFTPClose();
    ret += test_xmlNanoFTPCloseConnection();
    ret += test_xmlNanoFTPConnect();
    ret += test_xmlNanoFTPConnectTo();
    ret += test_xmlNanoFTPCwd();
    ret += test_xmlNanoFTPDele();
    ret += test_xmlNanoFTPGet();
    ret += test_xmlNanoFTPGetConnection();
    ret += test_xmlNanoFTPGetResponse();
    ret += test_xmlNanoFTPGetSocket();
    ret += test_xmlNanoFTPInit();
    ret += test_xmlNanoFTPList();
    ret += test_xmlNanoFTPNewCtxt();
    ret += test_xmlNanoFTPOpen();
    ret += test_xmlNanoFTPProxy();
    ret += test_xmlNanoFTPQuit();
    ret += test_xmlNanoFTPRead();
    ret += test_xmlNanoFTPScanProxy();
    ret += test_xmlNanoFTPUpdateURL();

    if (ret != 0)
	printf("Module nanoftp: %d errors\n", ret);
    return(ret);
}

static int
test_xmlNanoHTTPAuthHeader(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPCleanup(void) {
    int ret = 0;

#ifdef 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);
	    ret++;
            printf("\n");
        }
#endif

    return(ret);
}


static int
test_xmlNanoHTTPClose(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPContentLength(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPEncoding(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPFetch(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPInit(void) {
    int ret = 0;

#ifdef 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);
	    ret++;
            printf("\n");
        }
#endif

    return(ret);
}


static int
test_xmlNanoHTTPMethod(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPMethodRedir(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPMimeType(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPOpen(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPOpenRedir(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPRead(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPRedir(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPReturnCode(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPSave(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNanoHTTPScanProxy(void) {
    int ret = 0;

#ifdef 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);

        xmlNanoHTTPScanProxy(URL);
        call_tests++;
        des_filepath(n_URL, URL);
        xmlResetLastError();
    }
#endif

    return(ret);
}

static int
test_nanohttp(void) {
    int ret = 0;

    printf("Testing nanohttp ...\n");
    ret += test_xmlNanoHTTPAuthHeader();
    ret += test_xmlNanoHTTPCleanup();
    ret += test_xmlNanoHTTPClose();
    ret += test_xmlNanoHTTPContentLength();
    ret += test_xmlNanoHTTPEncoding();
    ret += test_xmlNanoHTTPFetch();
    ret += test_xmlNanoHTTPInit();
    ret += test_xmlNanoHTTPMethod();
    ret += test_xmlNanoHTTPMethodRedir();
    ret += test_xmlNanoHTTPMimeType();
    ret += test_xmlNanoHTTPOpen();
    ret += test_xmlNanoHTTPOpenRedir();
    ret += test_xmlNanoHTTPRead();
    ret += test_xmlNanoHTTPRedir();
    ret += test_xmlNanoHTTPReturnCode();
    ret += test_xmlNanoHTTPSave();
    ret += test_xmlNanoHTTPScanProxy();

    if (ret != 0)
	printf("Module nanohttp: %d errors\n", ret);
    return(ret);
}

static int
test_xmlByteConsumed(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlClearNodeInfoSeq(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlClearParserCtxt(void) {
    int 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);

        xmlClearParserCtxt(ctxt);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlClearParserCtxt",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlCreateDocParserCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCreateIOParserCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCreatePushParserCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCtxtReadDoc(void) {
    int ret = 0;

    int mem_base;
    xmlDocPtr ret_val;
    xmlParserCtxtPtr ctxt; /* an XML parser context */
    int n_ctxt;
    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_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
    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();
        ctxt = gen_xmlParserCtxtPtr(n_ctxt);
        cur = gen_const_xmlChar_ptr(n_cur);
        URL = gen_filepath(n_URL);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = xmlCtxtReadDoc(ctxt, cur, URL, encoding, options);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        des_const_xmlChar_ptr(n_cur, cur);
        des_filepath(n_URL, URL);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCtxtReadDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_cur);
            printf(" %d", n_URL);
            printf(" %d", n_encoding);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
    }
    }
    }

    return(ret);
}


static int
test_xmlCtxtReadFile(void) {
    int 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_int;n_options++) {
        mem_base = xmlMemBlocks();
        ctxt = gen_xmlParserCtxtPtr(n_ctxt);
        filename = gen_filepath(n_filename);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = xmlCtxtReadFile(ctxt, filename, encoding, options);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        des_filepath(n_filename, filename);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCtxtReadFile",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_filename);
            printf(" %d", n_encoding);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
    }
    }

    return(ret);
}


static int
test_xmlCtxtReadIO(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCtxtReadMemory(void) {
    int 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_int;n_options++) {
        mem_base = xmlMemBlocks();
        ctxt = gen_xmlParserCtxtPtr(n_ctxt);
        buffer = gen_const_char_ptr(n_buffer);
        size = gen_int(n_size);
        URL = gen_filepath(n_URL);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = xmlCtxtReadMemory(ctxt, buffer, size, URL, encoding, options);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        des_const_char_ptr(n_buffer, buffer);
        des_int(n_size, size);
        des_filepath(n_URL, URL);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCtxtReadMemory",
	           xmlMemBlocks() - mem_base);
	    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");
        }
    }
    }
    }
    }
    }
    }

    return(ret);
}


static int
test_xmlCtxtReset(void) {
    int 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);

        xmlCtxtReset(ctxt);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCtxtReset",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlCtxtResetPush(void) {
    int 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);
        chunk = gen_const_char_ptr(n_chunk);
        size = gen_int(n_size);
        filename = gen_filepath(n_filename);
        encoding = gen_const_char_ptr(n_encoding);

        ret_val = xmlCtxtResetPush(ctxt, chunk, size, filename, encoding);
        desret_int(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        des_const_char_ptr(n_chunk, chunk);
        des_int(n_size, size);
        des_filepath(n_filename, filename);
        des_const_char_ptr(n_encoding, encoding);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCtxtResetPush",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_chunk);
            printf(" %d", n_size);
            printf(" %d", n_filename);
            printf(" %d", n_encoding);
            printf("\n");
        }
    }
    }
    }
    }
    }

    return(ret);
}


static int
test_xmlCtxtUseOptions(void) {
    int 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_int;n_options++) {
        mem_base = xmlMemBlocks();
        ctxt = gen_xmlParserCtxtPtr(n_ctxt);
        options = gen_int(n_options);

        ret_val = xmlCtxtUseOptions(ctxt, options);
        desret_int(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCtxtUseOptions",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlGetExternalEntityLoader(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetFeature(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetFeaturesList(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIOParseDTD(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlInitNodeInfoSeq(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlInitParser(void) {
    int 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);
	    ret++;
            printf("\n");
        }

    return(ret);
}


static int
test_xmlInitParserCtxt(void) {
    int 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);

        ret_val = xmlInitParserCtxt(ctxt);
        desret_int(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlInitParserCtxt",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlKeepBlanksDefault(void) {
    int 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);

        ret_val = xmlKeepBlanksDefault(val);
        desret_int(ret_val);
        call_tests++;
        des_int(n_val, val);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlKeepBlanksDefault",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_val);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlLineNumbersDefault(void) {
    int 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);

        ret_val = xmlLineNumbersDefault(val);
        desret_int(ret_val);
        call_tests++;
        des_int(n_val, val);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlLineNumbersDefault",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_val);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlLoadExternalEntity(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewIOInputStream(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewParserCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParseBalancedChunkMemory(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParseBalancedChunkMemoryRecover(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParseChunk(void) {
    int ret = 0;

#ifdef 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);
        chunk = gen_const_char_ptr(n_chunk);
        size = gen_int(n_size);
        terminate = gen_int(n_terminate);

        ret_val = xmlParseChunk(ctxt, chunk, size, terminate);
        desret_int(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        des_const_char_ptr(n_chunk, chunk);
        des_int(n_size, size);
        des_int(n_terminate, terminate);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlParseChunk",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_chunk);
            printf(" %d", n_size);
            printf(" %d", n_terminate);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlParseCtxtExternalEntity(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParseDTD(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParseDoc(void) {
    int ret = 0;

    int mem_base;
    xmlDocPtr ret_val;
    xmlChar * cur; /* a pointer to an array of xmlChar */
    int n_cur;

    for (n_cur = 0;n_cur < gen_nb_xmlChar_ptr;n_cur++) {
        mem_base = xmlMemBlocks();
        cur = gen_xmlChar_ptr(n_cur);

        ret_val = xmlParseDoc(cur);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_xmlChar_ptr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlParseDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlParseDocument(void) {
    int 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);

        ret_val = xmlParseDocument(ctxt);
        desret_int(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlParseDocument",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlParseEntity(void) {
    int ret = 0;

    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);

        ret_val = xmlParseEntity(filename);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_filepath(n_filename, filename);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlParseEntity",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlParseExtParsedEnt(void) {
    int 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);

        ret_val = xmlParseExtParsedEnt(ctxt);
        desret_int(ret_val);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlParseExtParsedEnt",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlParseExternalEntity(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParseFile(void) {
    int ret = 0;

    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);

        ret_val = xmlParseFile(filename);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_filepath(n_filename, filename);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlParseFile",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlParseInNodeContext(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParseMemory(void) {
    int ret = 0;

    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);
        size = gen_int(n_size);

        ret_val = xmlParseMemory(buffer, size);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_const_char_ptr(n_buffer, buffer);
        des_int(n_size, size);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlParseMemory",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buffer);
            printf(" %d", n_size);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlParserAddNodeInfo(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserFindNodeInfo(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserFindNodeInfoIndex(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserInputGrow(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserInputRead(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlPedanticParserDefault(void) {
    int 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);

        ret_val = xmlPedanticParserDefault(val);
        desret_int(ret_val);
        call_tests++;
        des_int(n_val, val);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlPedanticParserDefault",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_val);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlReadDoc(void) {
    int 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_int;n_options++) {
        mem_base = xmlMemBlocks();
        cur = gen_const_xmlChar_ptr(n_cur);
        URL = gen_filepath(n_URL);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = xmlReadDoc(cur, URL, encoding, options);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_cur, cur);
        des_filepath(n_URL, URL);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlReadDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_URL);
            printf(" %d", n_encoding);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
    }
    }

    return(ret);
}


static int
test_xmlReadFile(void) {
    int 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_int;n_options++) {
        mem_base = xmlMemBlocks();
        filename = gen_filepath(n_filename);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = xmlReadFile(filename, encoding, options);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_filepath(n_filename, filename);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlReadFile",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf(" %d", n_encoding);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlReadIO(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlReadMemory(void) {
    int 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_int;n_options++) {
        mem_base = xmlMemBlocks();
        buffer = gen_const_char_ptr(n_buffer);
        size = gen_int(n_size);
        URL = gen_filepath(n_URL);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = xmlReadMemory(buffer, size, URL, encoding, options);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_const_char_ptr(n_buffer, buffer);
        des_int(n_size, size);
        des_filepath(n_URL, URL);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlReadMemory",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buffer);
            printf(" %d", n_size);
            printf(" %d", n_URL);
            printf(" %d", n_encoding);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
    }
    }
    }

    return(ret);
}


static int
test_xmlRecoverDoc(void) {
    int ret = 0;

    int mem_base;
    xmlDocPtr ret_val;
    xmlChar * cur; /* a pointer to an array of xmlChar */
    int n_cur;

    for (n_cur = 0;n_cur < gen_nb_xmlChar_ptr;n_cur++) {
        mem_base = xmlMemBlocks();
        cur = gen_xmlChar_ptr(n_cur);

        ret_val = xmlRecoverDoc(cur);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_xmlChar_ptr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlRecoverDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlRecoverFile(void) {
    int ret = 0;

    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);

        ret_val = xmlRecoverFile(filename);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_filepath(n_filename, filename);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlRecoverFile",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlRecoverMemory(void) {
    int ret = 0;

    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);
        size = gen_int(n_size);

        ret_val = xmlRecoverMemory(buffer, size);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_const_char_ptr(n_buffer, buffer);
        des_int(n_size, size);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlRecoverMemory",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buffer);
            printf(" %d", n_size);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlSAXParseDTD(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSAXParseDoc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSAXParseEntity(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSAXParseFile(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSAXParseFileWithData(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSAXParseMemory(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSAXParseMemoryWithData(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSAXUserParseFile(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSAXUserParseMemory(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSetExternalEntityLoader(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSetFeature(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSetupParserForBuffer(void) {
    int ret = 0;

    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);
        buffer = gen_const_xmlChar_ptr(n_buffer);
        filename = gen_filepath(n_filename);

        xmlSetupParserForBuffer(ctxt, buffer, filename);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        des_const_xmlChar_ptr(n_buffer, buffer);
        des_filepath(n_filename, filename);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlSetupParserForBuffer",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_buffer);
            printf(" %d", n_filename);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlStopParser(void) {
    int 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);

        xmlStopParser(ctxt);
        call_tests++;
        des_xmlParserCtxtPtr(n_ctxt, ctxt);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStopParser",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlSubstituteEntitiesDefault(void) {
    int 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);

        ret_val = xmlSubstituteEntitiesDefault(val);
        desret_int(ret_val);
        call_tests++;
        des_int(n_val, val);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlSubstituteEntitiesDefault",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_val);
            printf("\n");
        }
    }

    return(ret);
}

static int
test_parser(void) {
    int ret = 0;

    printf("Testing parser ...\n");
    ret += test_xmlByteConsumed();
    ret += test_xmlClearNodeInfoSeq();
    ret += test_xmlClearParserCtxt();
    ret += test_xmlCreateDocParserCtxt();
    ret += test_xmlCreateIOParserCtxt();
    ret += test_xmlCreatePushParserCtxt();
    ret += test_xmlCtxtReadDoc();
    ret += test_xmlCtxtReadFile();
    ret += test_xmlCtxtReadIO();
    ret += test_xmlCtxtReadMemory();
    ret += test_xmlCtxtReset();
    ret += test_xmlCtxtResetPush();
    ret += test_xmlCtxtUseOptions();
    ret += test_xmlGetExternalEntityLoader();
    ret += test_xmlGetFeature();
    ret += test_xmlGetFeaturesList();
    ret += test_xmlIOParseDTD();
    ret += test_xmlInitNodeInfoSeq();
    ret += test_xmlInitParser();
    ret += test_xmlInitParserCtxt();
    ret += test_xmlKeepBlanksDefault();
    ret += test_xmlLineNumbersDefault();
    ret += test_xmlLoadExternalEntity();
    ret += test_xmlNewIOInputStream();
    ret += test_xmlNewParserCtxt();
    ret += test_xmlParseBalancedChunkMemory();
    ret += test_xmlParseBalancedChunkMemoryRecover();
    ret += test_xmlParseChunk();
    ret += test_xmlParseCtxtExternalEntity();
    ret += test_xmlParseDTD();
    ret += test_xmlParseDoc();
    ret += test_xmlParseDocument();
    ret += test_xmlParseEntity();
    ret += test_xmlParseExtParsedEnt();
    ret += test_xmlParseExternalEntity();
    ret += test_xmlParseFile();
    ret += test_xmlParseInNodeContext();
    ret += test_xmlParseMemory();
    ret += test_xmlParserAddNodeInfo();
    ret += test_xmlParserFindNodeInfo();
    ret += test_xmlParserFindNodeInfoIndex();
    ret += test_xmlParserInputGrow();
    ret += test_xmlParserInputRead();
    ret += test_xmlPedanticParserDefault();
    ret += test_xmlReadDoc();
    ret += test_xmlReadFile();
    ret += test_xmlReadIO();
    ret += test_xmlReadMemory();
    ret += test_xmlRecoverDoc();
    ret += test_xmlRecoverFile();
    ret += test_xmlRecoverMemory();
    ret += test_xmlSAXParseDTD();
    ret += test_xmlSAXParseDoc();
    ret += test_xmlSAXParseEntity();
    ret += test_xmlSAXParseFile();
    ret += test_xmlSAXParseFileWithData();
    ret += test_xmlSAXParseMemory();
    ret += test_xmlSAXParseMemoryWithData();
    ret += test_xmlSAXUserParseFile();
    ret += test_xmlSAXUserParseMemory();
    ret += test_xmlSetExternalEntityLoader();
    ret += test_xmlSetFeature();
    ret += test_xmlSetupParserForBuffer();
    ret += test_xmlStopParser();
    ret += test_xmlSubstituteEntitiesDefault();

    if (ret != 0)
	printf("Module parser: %d errors\n", ret);
    return(ret);
}

static int
test_xmlPatternMatch(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlPatterncompile(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_pattern(void) {
    int ret = 0;

    printf("Testing pattern ...\n");
    ret += test_xmlPatternMatch();
    ret += test_xmlPatterncompile();

    if (ret != 0)
	printf("Module pattern: %d errors\n", ret);
    return(ret);
}

static int
test_xmlRelaxNGDump(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGDumpTree(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGGetParserErrors(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGGetValidErrors(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGNewDocParserCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGNewMemParserCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGNewParserCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGNewValidCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGParse(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGSetParserErrors(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGSetValidErrors(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGValidateDoc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGValidateFullElement(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGValidatePopElement(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGValidatePushCData(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxNGValidatePushElement(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRelaxParserSetFlag(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_relaxng(void) {
    int ret = 0;

    printf("Testing relaxng ...\n");
    ret += test_xmlRelaxNGDump();
    ret += test_xmlRelaxNGDumpTree();
    ret += test_xmlRelaxNGGetParserErrors();
    ret += test_xmlRelaxNGGetValidErrors();
    ret += test_xmlRelaxNGNewDocParserCtxt();
    ret += test_xmlRelaxNGNewMemParserCtxt();
    ret += test_xmlRelaxNGNewParserCtxt();
    ret += test_xmlRelaxNGNewValidCtxt();
    ret += test_xmlRelaxNGParse();
    ret += test_xmlRelaxNGSetParserErrors();
    ret += test_xmlRelaxNGSetValidErrors();
    ret += test_xmlRelaxNGValidateDoc();
    ret += test_xmlRelaxNGValidateFullElement();
    ret += test_xmlRelaxNGValidatePopElement();
    ret += test_xmlRelaxNGValidatePushCData();
    ret += test_xmlRelaxNGValidatePushElement();
    ret += test_xmlRelaxParserSetFlag();

    if (ret != 0)
	printf("Module relaxng: %d errors\n", ret);
    return(ret);
}
static int
test_schemasInternals(void) {
    int ret = 0;

    printf("Testing schemasInternals ...\n");

    if (ret != 0)
	printf("Module schemasInternals: %d errors\n", ret);
    return(ret);
}

static int
test_xmlAddChild(void) {
    int 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);
        cur = gen_xmlNodePtr_in(n_cur);

        ret_val = xmlAddChild(parent, cur);
        if (ret_val == NULL) { xmlFreeNode(cur) ; cur = NULL ; }
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_parent, parent);
        des_xmlNodePtr_in(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlAddChild",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_parent);
            printf(" %d", n_cur);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlAddChildList(void) {
    int 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);
        cur = gen_xmlNodePtr_in(n_cur);

        ret_val = xmlAddChildList(parent, cur);
        if (ret_val == NULL) { xmlFreeNodeList(cur) ; cur = NULL ; }
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_parent, parent);
        des_xmlNodePtr_in(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlAddChildList",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_parent);
            printf(" %d", n_cur);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlAddNextSibling(void) {
    int 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);
        elem = gen_xmlNodePtr_in(n_elem);

        ret_val = xmlAddNextSibling(cur, elem);
        if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        des_xmlNodePtr_in(n_elem, elem);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlAddNextSibling",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_elem);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlAddPrevSibling(void) {
    int ret = 0;

#ifdef LIBXML_TREE_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);
        elem = gen_xmlNodePtr_in(n_elem);

        ret_val = xmlAddPrevSibling(cur, elem);
        if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        des_xmlNodePtr_in(n_elem, elem);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlAddPrevSibling",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_elem);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlAddSibling(void) {
    int 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);
        elem = gen_xmlNodePtr_in(n_elem);

        ret_val = xmlAddSibling(cur, elem);
        if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        des_xmlNodePtr_in(n_elem, elem);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlAddSibling",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_elem);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlAttrSerializeTxtContent(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlBufferAdd(void) {
    int 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);
        str = gen_const_xmlChar_ptr(n_str);
        len = gen_int(n_len);

        ret_val = xmlBufferAdd(buf, str, len);
        desret_int(ret_val);
        call_tests++;
        des_xmlBufferPtr(n_buf, buf);
        des_const_xmlChar_ptr(n_str, str);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlBufferAdd",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buf);
            printf(" %d", n_str);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlBufferAddHead(void) {
    int 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);
        str = gen_const_xmlChar_ptr(n_str);
        len = gen_int(n_len);

        ret_val = xmlBufferAddHead(buf, str, len);
        desret_int(ret_val);
        call_tests++;
        des_xmlBufferPtr(n_buf, buf);
        des_const_xmlChar_ptr(n_str, str);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlBufferAddHead",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buf);
            printf(" %d", n_str);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlBufferCCat(void) {
    int 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);
        str = gen_const_char_ptr(n_str);

        ret_val = xmlBufferCCat(buf, str);
        desret_int(ret_val);
        call_tests++;
        des_xmlBufferPtr(n_buf, buf);
        des_const_char_ptr(n_str, str);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlBufferCCat",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buf);
            printf(" %d", n_str);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlBufferCat(void) {
    int 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);
        str = gen_const_xmlChar_ptr(n_str);

        ret_val = xmlBufferCat(buf, str);
        desret_int(ret_val);
        call_tests++;
        des_xmlBufferPtr(n_buf, buf);
        des_const_xmlChar_ptr(n_str, str);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlBufferCat",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buf);
            printf(" %d", n_str);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlBufferContent(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlBufferCreate(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlBufferCreateSize(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlBufferCreateStatic(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlBufferDump(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlBufferEmpty(void) {
    int 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);

        xmlBufferEmpty(buf);
        call_tests++;
        des_xmlBufferPtr(n_buf, buf);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlBufferEmpty",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buf);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlBufferGrow(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlBufferLength(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlBufferResize(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlBufferSetAllocationScheme(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlBufferShrink(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlBufferWriteCHAR(void) {
    int 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);
        string = gen_const_xmlChar_ptr(n_string);

        xmlBufferWriteCHAR(buf, string);
        call_tests++;
        des_xmlBufferPtr(n_buf, buf);
        des_const_xmlChar_ptr(n_string, string);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlBufferWriteCHAR",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buf);
            printf(" %d", n_string);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlBufferWriteChar(void) {
    int 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);
        string = gen_const_char_ptr(n_string);

        xmlBufferWriteChar(buf, string);
        call_tests++;
        des_xmlBufferPtr(n_buf, buf);
        des_const_char_ptr(n_string, string);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlBufferWriteChar",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buf);
            printf(" %d", n_string);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlBufferWriteQuotedString(void) {
    int 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);
        string = gen_const_xmlChar_ptr(n_string);

        xmlBufferWriteQuotedString(buf, string);
        call_tests++;
        des_xmlBufferPtr(n_buf, buf);
        des_const_xmlChar_ptr(n_string, string);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlBufferWriteQuotedString",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buf);
            printf(" %d", n_string);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlBuildQName(void) {
    int 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);
        prefix = gen_const_xmlChar_ptr(n_prefix);
        memory = gen_xmlChar_ptr(n_memory);
        len = gen_int(n_len);

        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);
        des_const_xmlChar_ptr(n_prefix, prefix);
        des_xmlChar_ptr(n_memory, memory);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlBuildQName",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ncname);
            printf(" %d", n_prefix);
            printf(" %d", n_memory);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }
    }

    return(ret);
}


static int
test_xmlCopyDoc(void) {
    int ret = 0;

#ifdef LIBXML_TREE_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);
        recursive = gen_int(n_recursive);

        ret_val = xmlCopyDoc(doc, recursive);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_int(n_recursive, recursive);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCopyDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_recursive);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlCopyDtd(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCopyNamespace(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCopyNamespaceList(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCopyNode(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCopyNodeList(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCopyProp(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCopyPropList(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCreateIntSubset(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDocCopyNode(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDocCopyNodeList(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDocDump(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDocDumpFormatMemory(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDocDumpFormatMemoryEnc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDocDumpMemory(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDocDumpMemoryEnc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDocFormatDump(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDocGetRootElement(void) {
    int ret = 0;

    int mem_base;
    xmlNodePtr ret_val;
    xmlDocPtr doc; /* the document */
    int n_doc;

    for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
        mem_base = xmlMemBlocks();
        doc = gen_xmlDocPtr(n_doc);

        ret_val = xmlDocGetRootElement(doc);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlDocGetRootElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlDocSetRootElement(void) {
    int ret = 0;

#ifdef LIBXML_TREE_ENABLED
    int mem_base;
    xmlNodePtr ret_val;
    xmlDocPtr doc; /* the document */
    int n_doc;
    xmlNodePtr root; /* the new document root element */
    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);
        root = gen_xmlNodePtr_in(n_root);

        ret_val = xmlDocSetRootElement(doc, root);
        if (doc == NULL) { xmlFreeNode(root) ; root = NULL ; }
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr_in(n_root, root);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlDocSetRootElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_root);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlElemDump(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetBufferAllocationScheme(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetCompressMode(void) {
    int 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);
	    ret++;
            printf("\n");
        }

    return(ret);
}


static int
test_xmlGetDocCompressMode(void) {
    int ret = 0;

    int mem_base;
    int ret_val;
    xmlDocPtr doc; /* the document */
    int n_doc;

    for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
        mem_base = xmlMemBlocks();
        doc = gen_xmlDocPtr(n_doc);

        ret_val = xmlGetDocCompressMode(doc);
        desret_int(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlGetDocCompressMode",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlGetIntSubset(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetLastChild(void) {
    int ret = 0;

    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);

        ret_val = xmlGetLastChild(parent);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_parent, parent);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlGetLastChild",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_parent);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlGetLineNo(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetNoNsProp(void) {
    int ret = 0;

    int mem_base;
    xmlChar * 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);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlGetNoNsProp(node, name);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_node, node);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlGetNoNsProp",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_node);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlGetNodePath(void) {
    int ret = 0;

#ifdef LIBXML_TREE_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);

        ret_val = xmlGetNodePath(node);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_node, node);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlGetNodePath",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_node);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlGetNsList(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetNsProp(void) {
    int ret = 0;

    int mem_base;
    xmlChar * ret_val;
    xmlNodePtr 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_xmlNodePtr;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_xmlNodePtr(n_node);
        name = gen_const_xmlChar_ptr(n_name);
        nameSpace = gen_const_xmlChar_ptr(n_nameSpace);

        ret_val = xmlGetNsProp(node, name, nameSpace);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_node, node);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_nameSpace, nameSpace);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlGetNsProp",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_node);
            printf(" %d", n_name);
            printf(" %d", n_nameSpace);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlGetProp(void) {
    int ret = 0;

    int mem_base;
    xmlChar * 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);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlGetProp(node, name);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_node, node);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlGetProp",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_node);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlHasNsProp(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlHasProp(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIsBlankNode(void) {
    int ret = 0;

    int mem_base;
    int ret_val;
    xmlNodePtr node; /* the node */
    int n_node;

    for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
        mem_base = xmlMemBlocks();
        node = gen_xmlNodePtr(n_node);

        ret_val = xmlIsBlankNode(node);
        desret_int(ret_val);
        call_tests++;
        des_xmlNodePtr(n_node, node);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlIsBlankNode",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_node);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlIsXHTML(void) {
    int 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);
        publicID = gen_const_xmlChar_ptr(n_publicID);

        ret_val = xmlIsXHTML(systemID, publicID);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_systemID, systemID);
        des_const_xmlChar_ptr(n_publicID, publicID);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlIsXHTML",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_systemID);
            printf(" %d", n_publicID);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlNewCDataBlock(void) {
    int 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);
        content = gen_const_xmlChar_ptr(n_content);
        len = gen_int(n_len);

        ret_val = xmlNewCDataBlock(doc, content, len);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_content, content);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewCDataBlock",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_content);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlNewCharRef(void) {
    int 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);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlNewCharRef(doc, name);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewCharRef",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlNewChild(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewComment(void) {
    int 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);

        ret_val = xmlNewComment(content);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewComment",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_content);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlNewDoc(void) {
    int 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);

        ret_val = xmlNewDoc(version);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_version, version);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_version);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlNewDocComment(void) {
    int 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);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlNewDocComment(doc, content);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewDocComment",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlNewDocFragment(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlNewDocFragment(doc);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewDocFragment",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlNewDocNode(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewDocNodeEatName(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewDocPI(void) {
    int 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);
        name = gen_const_xmlChar_ptr(n_name);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlNewDocPI(doc, name, content);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewDocPI",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_name);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlNewDocProp(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewDocRawNode(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewDocText(void) {
    int ret = 0;

    int mem_base;
    xmlNodePtr ret_val;
    xmlDocPtr doc; /* the document */
    int n_doc;
    const xmlChar * content; /* the text 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);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlNewDocText(doc, content);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewDocText",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlNewDocTextLen(void) {
    int 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);
        content = gen_const_xmlChar_ptr(n_content);
        len = gen_int(n_len);

        ret_val = xmlNewDocTextLen(doc, content, len);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_content, content);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewDocTextLen",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_content);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlNewDtd(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewGlobalNs(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewNode(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewNodeEatName(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewNs(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewNsProp(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewNsPropEatName(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewPI(void) {
    int 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);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlNewPI(name, content);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewPI",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_name);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlNewProp(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewReference(void) {
    int ret = 0;

    int mem_base;
    xmlNodePtr ret_val;
    xmlDocPtr 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_xmlDocPtr;n_doc++) {
    for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
        mem_base = xmlMemBlocks();
        doc = gen_xmlDocPtr(n_doc);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlNewReference(doc, name);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewReference",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlNewText(void) {
    int 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);

        ret_val = xmlNewText(content);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewText",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_content);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlNewTextChild(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewTextLen(void) {
    int 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);
        len = gen_int(n_len);

        ret_val = xmlNewTextLen(content, len);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_content, content);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNewTextLen",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_content);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlNodeAddContent(void) {
    int 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);
        content = gen_const_xmlChar_ptr(n_content);

        xmlNodeAddContent(cur, content);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeAddContent",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlNodeAddContentLen(void) {
    int 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);
        content = gen_const_xmlChar_ptr(n_content);
        len = gen_int(n_len);

        xmlNodeAddContentLen(cur, content, len);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        des_const_xmlChar_ptr(n_content, content);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeAddContentLen",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_content);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlNodeBufGetContent(void) {
    int ret = 0;

    int mem_base;
    int ret_val;
    xmlBufferPtr buffer; /* a buffer */
    int n_buffer;
    xmlNodePtr 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_xmlNodePtr;n_cur++) {
        mem_base = xmlMemBlocks();
        buffer = gen_xmlBufferPtr(n_buffer);
        cur = gen_xmlNodePtr(n_cur);

        ret_val = xmlNodeBufGetContent(buffer, cur);
        desret_int(ret_val);
        call_tests++;
        des_xmlBufferPtr(n_buffer, buffer);
        des_xmlNodePtr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeBufGetContent",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buffer);
            printf(" %d", n_cur);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlNodeDump(void) {
    int ret = 0;

#ifdef 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);
        doc = gen_xmlDocPtr(n_doc);
        cur = gen_xmlNodePtr(n_cur);
        level = gen_int(n_level);
        format = gen_int(n_format);

        ret_val = xmlNodeDump(buf, doc, cur, level, format);
        desret_int(ret_val);
        call_tests++;
        des_xmlBufferPtr(n_buf, buf);
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_cur, cur);
        des_int(n_level, level);
        des_int(n_format, format);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeDump",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_buf);
            printf(" %d", n_doc);
            printf(" %d", n_cur);
            printf(" %d", n_level);
            printf(" %d", n_format);
            printf("\n");
        }
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlNodeDumpOutput(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNodeGetBase(void) {
    int ret = 0;

    int mem_base;
    xmlChar * ret_val;
    xmlDocPtr doc; /* the document the node pertains to */
    int n_doc;
    xmlNodePtr cur; /* the node being checked */
    int n_cur;

    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();
        doc = gen_xmlDocPtr(n_doc);
        cur = gen_xmlNodePtr(n_cur);

        ret_val = xmlNodeGetBase(doc, cur);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeGetBase",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_cur);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlNodeGetContent(void) {
    int ret = 0;

    int mem_base;
    xmlChar * ret_val;
    xmlNodePtr cur; /* the node being read */
    int n_cur;

    for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
        mem_base = xmlMemBlocks();
        cur = gen_xmlNodePtr(n_cur);

        ret_val = xmlNodeGetContent(cur);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeGetContent",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlNodeGetLang(void) {
    int ret = 0;

    int mem_base;
    xmlChar * ret_val;
    xmlNodePtr cur; /* the node being checked */
    int n_cur;

    for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
        mem_base = xmlMemBlocks();
        cur = gen_xmlNodePtr(n_cur);

        ret_val = xmlNodeGetLang(cur);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeGetLang",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlNodeGetSpacePreserve(void) {
    int ret = 0;

    int mem_base;
    int ret_val;
    xmlNodePtr cur; /* the node being checked */
    int n_cur;

    for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
        mem_base = xmlMemBlocks();
        cur = gen_xmlNodePtr(n_cur);

        ret_val = xmlNodeGetSpacePreserve(cur);
        desret_int(ret_val);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeGetSpacePreserve",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlNodeIsText(void) {
    int ret = 0;

    int mem_base;
    int ret_val;
    xmlNodePtr node; /* the node */
    int n_node;

    for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
        mem_base = xmlMemBlocks();
        node = gen_xmlNodePtr(n_node);

        ret_val = xmlNodeIsText(node);
        desret_int(ret_val);
        call_tests++;
        des_xmlNodePtr(n_node, node);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeIsText",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_node);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlNodeListGetRawString(void) {
    int ret = 0;

#ifdef LIBXML_TREE_ENABLED
    int mem_base;
    xmlChar * ret_val;
    xmlDocPtr doc; /* the document */
    int n_doc;
    xmlNodePtr 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_xmlNodePtr;n_list++) {
    for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
        mem_base = xmlMemBlocks();
        doc = gen_xmlDocPtr(n_doc);
        list = gen_xmlNodePtr(n_list);
        inLine = gen_int(n_inLine);

        ret_val = xmlNodeListGetRawString(doc, list, inLine);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_list, list);
        des_int(n_inLine, inLine);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeListGetRawString",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_list);
            printf(" %d", n_inLine);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlNodeListGetString(void) {
    int ret = 0;

    int mem_base;
    xmlChar * ret_val;
    xmlDocPtr doc; /* the document */
    int n_doc;
    xmlNodePtr 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_xmlNodePtr;n_list++) {
    for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
        mem_base = xmlMemBlocks();
        doc = gen_xmlDocPtr(n_doc);
        list = gen_xmlNodePtr(n_list);
        inLine = gen_int(n_inLine);

        ret_val = xmlNodeListGetString(doc, list, inLine);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_list, list);
        des_int(n_inLine, inLine);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeListGetString",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_list);
            printf(" %d", n_inLine);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlNodeSetBase(void) {
    int ret = 0;

#ifdef LIBXML_TREE_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);
        uri = gen_const_xmlChar_ptr(n_uri);

        xmlNodeSetBase(cur, uri);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        des_const_xmlChar_ptr(n_uri, uri);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeSetBase",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_uri);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlNodeSetContent(void) {
    int 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);
        content = gen_const_xmlChar_ptr(n_content);

        xmlNodeSetContent(cur, content);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeSetContent",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlNodeSetContentLen(void) {
    int ret = 0;

#ifdef 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);
        content = gen_const_xmlChar_ptr(n_content);
        len = gen_int(n_len);

        xmlNodeSetContentLen(cur, content, len);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        des_const_xmlChar_ptr(n_content, content);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeSetContentLen",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_content);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlNodeSetLang(void) {
    int ret = 0;

#ifdef 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);
        lang = gen_const_xmlChar_ptr(n_lang);

        xmlNodeSetLang(cur, lang);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        des_const_xmlChar_ptr(n_lang, lang);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeSetLang",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_lang);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlNodeSetName(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);

        xmlNodeSetName(cur, name);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeSetName",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlNodeSetSpacePreserve(void) {
    int ret = 0;

#ifdef 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);
        val = gen_int(n_val);

        xmlNodeSetSpacePreserve(cur, val);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        des_int(n_val, val);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNodeSetSpacePreserve",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_val);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlReconciliateNs(void) {
    int ret = 0;

    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);
        tree = gen_xmlNodePtr(n_tree);

        ret_val = xmlReconciliateNs(doc, tree);
        desret_int(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_tree, tree);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlReconciliateNs",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_tree);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlRemoveProp(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlReplaceNode(void) {
    int ret = 0;

#ifdef LIBXML_TREE_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);
        cur = gen_xmlNodePtr_in(n_cur);

        ret_val = xmlReplaceNode(old, cur);
        if ((old == NULL) || (old->parent == NULL)) {
              xmlFreeNode(cur) ; cur = NULL ; }
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_old, old);
        des_xmlNodePtr_in(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlReplaceNode",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_old);
            printf(" %d", n_cur);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlSaveFile(void) {
    int ret = 0;

#ifdef 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);
        cur = gen_xmlDocPtr(n_cur);

        ret_val = xmlSaveFile(filename, cur);
        desret_int(ret_val);
        call_tests++;
        des_fileoutput(n_filename, filename);
        des_xmlDocPtr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlSaveFile",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf(" %d", n_cur);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlSaveFileEnc(void) {
    int ret = 0;

#ifdef 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);
        cur = gen_xmlDocPtr(n_cur);
        encoding = gen_const_char_ptr(n_encoding);

        ret_val = xmlSaveFileEnc(filename, cur, encoding);
        desret_int(ret_val);
        call_tests++;
        des_fileoutput(n_filename, filename);
        des_xmlDocPtr(n_cur, cur);
        des_const_char_ptr(n_encoding, encoding);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlSaveFileEnc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf(" %d", n_cur);
            printf(" %d", n_encoding);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlSaveFileTo(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSaveFormatFile(void) {
    int ret = 0;

#ifdef 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);
        cur = gen_xmlDocPtr(n_cur);
        format = gen_int(n_format);

        ret_val = xmlSaveFormatFile(filename, cur, format);
        desret_int(ret_val);
        call_tests++;
        des_fileoutput(n_filename, filename);
        des_xmlDocPtr(n_cur, cur);
        des_int(n_format, format);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlSaveFormatFile",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf(" %d", n_cur);
            printf(" %d", n_format);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlSaveFormatFileEnc(void) {
    int ret = 0;

#ifdef 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);
        cur = gen_xmlDocPtr(n_cur);
        encoding = gen_const_char_ptr(n_encoding);
        format = gen_int(n_format);

        ret_val = xmlSaveFormatFileEnc(filename, cur, encoding, format);
        desret_int(ret_val);
        call_tests++;
        des_fileoutput(n_filename, filename);
        des_xmlDocPtr(n_cur, cur);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_format, format);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlSaveFormatFileEnc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf(" %d", n_cur);
            printf(" %d", n_encoding);
            printf(" %d", n_format);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlSaveFormatFileTo(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSearchNs(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSearchNsByHref(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSetBufferAllocationScheme(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSetCompressMode(void) {
    int 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);

        xmlSetCompressMode(mode);
        call_tests++;
        des_int(n_mode, mode);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlSetCompressMode",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_mode);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlSetDocCompressMode(void) {
    int 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);
        mode = gen_int(n_mode);

        xmlSetDocCompressMode(doc, mode);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_int(n_mode, mode);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlSetDocCompressMode",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_mode);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlSetListDoc(void) {
    int ret = 0;

    int mem_base;
    xmlNodePtr list; /* the first element */
    int n_list;
    xmlDocPtr doc; /* the document */
    int n_doc;

    for (n_list = 0;n_list < gen_nb_xmlNodePtr;n_list++) {
    for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
        mem_base = xmlMemBlocks();
        list = gen_xmlNodePtr(n_list);
        doc = gen_xmlDocPtr(n_doc);

        xmlSetListDoc(list, doc);
        call_tests++;
        des_xmlNodePtr(n_list, list);
        des_xmlDocPtr(n_doc, doc);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlSetListDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_list);
            printf(" %d", n_doc);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlSetNs(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSetNsProp(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSetProp(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSetTreeDoc(void) {
    int ret = 0;

    int mem_base;
    xmlNodePtr tree; /* the top element */
    int n_tree;
    xmlDocPtr doc; /* the document */
    int n_doc;

    for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
    for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
        mem_base = xmlMemBlocks();
        tree = gen_xmlNodePtr(n_tree);
        doc = gen_xmlDocPtr(n_doc);

        xmlSetTreeDoc(tree, doc);
        call_tests++;
        des_xmlNodePtr(n_tree, tree);
        des_xmlDocPtr(n_doc, doc);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlSetTreeDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_tree);
            printf(" %d", n_doc);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlSplitQName2(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSplitQName3(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlStringGetNodeList(void) {
    int ret = 0;

    int mem_base;
    xmlNodePtr ret_val;
    xmlDocPtr 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_xmlDocPtr;n_doc++) {
    for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
        mem_base = xmlMemBlocks();
        doc = gen_xmlDocPtr(n_doc);
        value = gen_const_xmlChar_ptr(n_value);

        ret_val = xmlStringGetNodeList(doc, value);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_value, value);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStringGetNodeList",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_value);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlStringLenGetNodeList(void) {
    int ret = 0;

    int mem_base;
    xmlNodePtr ret_val;
    xmlDocPtr 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_xmlDocPtr;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_xmlDocPtr(n_doc);
        value = gen_const_xmlChar_ptr(n_value);
        len = gen_int(n_len);

        ret_val = xmlStringLenGetNodeList(doc, value, len);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_value, value);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStringLenGetNodeList",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_value);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlTextConcat(void) {
    int 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);
        content = gen_const_xmlChar_ptr(n_content);
        len = gen_int(n_len);

        ret_val = xmlTextConcat(node, content, len);
        desret_int(ret_val);
        call_tests++;
        des_xmlNodePtr(n_node, node);
        des_const_xmlChar_ptr(n_content, content);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextConcat",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_node);
            printf(" %d", n_content);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlTextMerge(void) {
    int 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);
        second = gen_xmlNodePtr_in(n_second);

        ret_val = xmlTextMerge(first, second);
        if ((first != NULL) && (first->type != XML_TEXT_NODE)) {
              xmlFreeNode(second) ; second = NULL ; }
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlNodePtr_in(n_first, first);
        des_xmlNodePtr_in(n_second, second);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextMerge",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_first);
            printf(" %d", n_second);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlUnlinkNode(void) {
    int ret = 0;

    int mem_base;
    xmlNodePtr cur; /* the node */
    int n_cur;

    for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
        mem_base = xmlMemBlocks();
        cur = gen_xmlNodePtr(n_cur);

        xmlUnlinkNode(cur);
        call_tests++;
        des_xmlNodePtr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlUnlinkNode",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlUnsetNsProp(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlUnsetProp(void) {
    int ret = 0;

#ifdef LIBXML_TREE_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);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlUnsetProp(node, name);
        desret_int(ret_val);
        call_tests++;
        des_xmlNodePtr(n_node, node);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlUnsetProp",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_node);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlValidateNCName(void) {
    int ret = 0;

    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);
        space = gen_int(n_space);

        ret_val = xmlValidateNCName(value, space);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_value, value);
        des_int(n_space, space);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateNCName",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_value);
            printf(" %d", n_space);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlValidateNMToken(void) {
    int ret = 0;

    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);
        space = gen_int(n_space);

        ret_val = xmlValidateNMToken(value, space);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_value, value);
        des_int(n_space, space);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateNMToken",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_value);
            printf(" %d", n_space);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlValidateName(void) {
    int ret = 0;

    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);
        space = gen_int(n_space);

        ret_val = xmlValidateName(value, space);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_value, value);
        des_int(n_space, space);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateName",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_value);
            printf(" %d", n_space);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlValidateQName(void) {
    int ret = 0;

    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);
        space = gen_int(n_space);

        ret_val = xmlValidateQName(value, space);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_value, value);
        des_int(n_space, space);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateQName",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_value);
            printf(" %d", n_space);
            printf("\n");
        }
    }
    }

    return(ret);
}

static int
test_tree(void) {
    int ret = 0;

    printf("Testing tree ...\n");
    ret += test_xmlAddChild();
    ret += test_xmlAddChildList();
    ret += test_xmlAddNextSibling();
    ret += test_xmlAddPrevSibling();
    ret += test_xmlAddSibling();
    ret += test_xmlAttrSerializeTxtContent();
    ret += test_xmlBufferAdd();
    ret += test_xmlBufferAddHead();
    ret += test_xmlBufferCCat();
    ret += test_xmlBufferCat();
    ret += test_xmlBufferContent();
    ret += test_xmlBufferCreate();
    ret += test_xmlBufferCreateSize();
    ret += test_xmlBufferCreateStatic();
    ret += test_xmlBufferDump();
    ret += test_xmlBufferEmpty();
    ret += test_xmlBufferGrow();
    ret += test_xmlBufferLength();
    ret += test_xmlBufferResize();
    ret += test_xmlBufferSetAllocationScheme();
    ret += test_xmlBufferShrink();
    ret += test_xmlBufferWriteCHAR();
    ret += test_xmlBufferWriteChar();
    ret += test_xmlBufferWriteQuotedString();
    ret += test_xmlBuildQName();
    ret += test_xmlCopyDoc();
    ret += test_xmlCopyDtd();
    ret += test_xmlCopyNamespace();
    ret += test_xmlCopyNamespaceList();
    ret += test_xmlCopyNode();
    ret += test_xmlCopyNodeList();
    ret += test_xmlCopyProp();
    ret += test_xmlCopyPropList();
    ret += test_xmlCreateIntSubset();
    ret += test_xmlDocCopyNode();
    ret += test_xmlDocCopyNodeList();
    ret += test_xmlDocDump();
    ret += test_xmlDocDumpFormatMemory();
    ret += test_xmlDocDumpFormatMemoryEnc();
    ret += test_xmlDocDumpMemory();
    ret += test_xmlDocDumpMemoryEnc();
    ret += test_xmlDocFormatDump();
    ret += test_xmlDocGetRootElement();
    ret += test_xmlDocSetRootElement();
    ret += test_xmlElemDump();
    ret += test_xmlGetBufferAllocationScheme();
    ret += test_xmlGetCompressMode();
    ret += test_xmlGetDocCompressMode();
    ret += test_xmlGetIntSubset();
    ret += test_xmlGetLastChild();
    ret += test_xmlGetLineNo();
    ret += test_xmlGetNoNsProp();
    ret += test_xmlGetNodePath();
    ret += test_xmlGetNsList();
    ret += test_xmlGetNsProp();
    ret += test_xmlGetProp();
    ret += test_xmlHasNsProp();
    ret += test_xmlHasProp();
    ret += test_xmlIsBlankNode();
    ret += test_xmlIsXHTML();
    ret += test_xmlNewCDataBlock();
    ret += test_xmlNewCharRef();
    ret += test_xmlNewChild();
    ret += test_xmlNewComment();
    ret += test_xmlNewDoc();
    ret += test_xmlNewDocComment();
    ret += test_xmlNewDocFragment();
    ret += test_xmlNewDocNode();
    ret += test_xmlNewDocNodeEatName();
    ret += test_xmlNewDocPI();
    ret += test_xmlNewDocProp();
    ret += test_xmlNewDocRawNode();
    ret += test_xmlNewDocText();
    ret += test_xmlNewDocTextLen();
    ret += test_xmlNewDtd();
    ret += test_xmlNewGlobalNs();
    ret += test_xmlNewNode();
    ret += test_xmlNewNodeEatName();
    ret += test_xmlNewNs();
    ret += test_xmlNewNsProp();
    ret += test_xmlNewNsPropEatName();
    ret += test_xmlNewPI();
    ret += test_xmlNewProp();
    ret += test_xmlNewReference();
    ret += test_xmlNewText();
    ret += test_xmlNewTextChild();
    ret += test_xmlNewTextLen();
    ret += test_xmlNodeAddContent();
    ret += test_xmlNodeAddContentLen();
    ret += test_xmlNodeBufGetContent();
    ret += test_xmlNodeDump();
    ret += test_xmlNodeDumpOutput();
    ret += test_xmlNodeGetBase();
    ret += test_xmlNodeGetContent();
    ret += test_xmlNodeGetLang();
    ret += test_xmlNodeGetSpacePreserve();
    ret += test_xmlNodeIsText();
    ret += test_xmlNodeListGetRawString();
    ret += test_xmlNodeListGetString();
    ret += test_xmlNodeSetBase();
    ret += test_xmlNodeSetContent();
    ret += test_xmlNodeSetContentLen();
    ret += test_xmlNodeSetLang();
    ret += test_xmlNodeSetName();
    ret += test_xmlNodeSetSpacePreserve();
    ret += test_xmlReconciliateNs();
    ret += test_xmlRemoveProp();
    ret += test_xmlReplaceNode();
    ret += test_xmlSaveFile();
    ret += test_xmlSaveFileEnc();
    ret += test_xmlSaveFileTo();
    ret += test_xmlSaveFormatFile();
    ret += test_xmlSaveFormatFileEnc();
    ret += test_xmlSaveFormatFileTo();
    ret += test_xmlSearchNs();
    ret += test_xmlSearchNsByHref();
    ret += test_xmlSetBufferAllocationScheme();
    ret += test_xmlSetCompressMode();
    ret += test_xmlSetDocCompressMode();
    ret += test_xmlSetListDoc();
    ret += test_xmlSetNs();
    ret += test_xmlSetNsProp();
    ret += test_xmlSetProp();
    ret += test_xmlSetTreeDoc();
    ret += test_xmlSplitQName2();
    ret += test_xmlSplitQName3();
    ret += test_xmlStringGetNodeList();
    ret += test_xmlStringLenGetNodeList();
    ret += test_xmlTextConcat();
    ret += test_xmlTextMerge();
    ret += test_xmlUnlinkNode();
    ret += test_xmlUnsetNsProp();
    ret += test_xmlUnsetProp();
    ret += test_xmlValidateNCName();
    ret += test_xmlValidateNMToken();
    ret += test_xmlValidateName();
    ret += test_xmlValidateQName();

    if (ret != 0)
	printf("Module tree: %d errors\n", ret);
    return(ret);
}

static int
test_xmlBuildRelativeURI(void) {
    int 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);
        base = gen_const_xmlChar_ptr(n_base);

        ret_val = xmlBuildRelativeURI(URI, base);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_URI, URI);
        des_const_xmlChar_ptr(n_base, base);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlBuildRelativeURI",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_URI);
            printf(" %d", n_base);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlBuildURI(void) {
    int 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);
        base = gen_const_xmlChar_ptr(n_base);

        ret_val = xmlBuildURI(URI, base);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_URI, URI);
        des_const_xmlChar_ptr(n_base, base);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlBuildURI",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_URI);
            printf(" %d", n_base);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlCanonicPath(void) {
    int 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);

        ret_val = xmlCanonicPath(path);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_path, path);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCanonicPath",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_path);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlCreateURI(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNormalizeURIPath(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParseURI(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParseURIReference(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlPrintURI(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSaveUri(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlURIEscape(void) {
    int 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);

        ret_val = xmlURIEscape(str);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_str, str);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlURIEscape",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_str);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlURIEscapeStr(void) {
    int 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);
        list = gen_const_xmlChar_ptr(n_list);

        ret_val = xmlURIEscapeStr(str, list);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_str, str);
        des_const_xmlChar_ptr(n_list, list);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlURIEscapeStr",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_str);
            printf(" %d", n_list);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlURIUnescapeString(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_uri(void) {
    int ret = 0;

    printf("Testing uri ...\n");
    ret += test_xmlBuildRelativeURI();
    ret += test_xmlBuildURI();
    ret += test_xmlCanonicPath();
    ret += test_xmlCreateURI();
    ret += test_xmlNormalizeURIPath();
    ret += test_xmlParseURI();
    ret += test_xmlParseURIReference();
    ret += test_xmlPrintURI();
    ret += test_xmlSaveUri();
    ret += test_xmlURIEscape();
    ret += test_xmlURIEscapeStr();
    ret += test_xmlURIUnescapeString();

    if (ret != 0)
	printf("Module uri: %d errors\n", ret);
    return(ret);
}

static int
test_xmlAddAttributeDecl(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlAddElementDecl(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlAddID(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlAddNotationDecl(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlAddRef(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCopyAttributeTable(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCopyElementContent(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCopyElementTable(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCopyEnumeration(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCopyNotationTable(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCreateEnumeration(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDumpAttributeDecl(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDumpAttributeTable(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDumpElementDecl(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDumpElementTable(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDumpNotationDecl(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlDumpNotationTable(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetDtdAttrDesc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetDtdElementDesc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetDtdNotationDesc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetDtdQAttrDesc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetDtdQElementDesc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetID(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetRefs(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIsID(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIsMixedElement(void) {
    int 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);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlIsMixedElement(doc, name);
        desret_int(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlIsMixedElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlIsRef(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewElementContent(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewValidCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRemoveID(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRemoveRef(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSnprintfElementContent(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSprintfElementContent(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlValidBuildContentModel(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlValidCtxtNormalizeAttributeValue(void) {
    int ret = 0;

#ifdef 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);
        doc = gen_xmlDocPtr(n_doc);
        elem = gen_xmlNodePtr(n_elem);
        name = gen_const_xmlChar_ptr(n_name);
        value = gen_const_xmlChar_ptr(n_value);

        ret_val = xmlValidCtxtNormalizeAttributeValue(ctxt, doc, elem, name, value);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlValidCtxtPtr(n_ctxt, ctxt);
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_elem, elem);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_value, value);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidCtxtNormalizeAttributeValue",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_doc);
            printf(" %d", n_elem);
            printf(" %d", n_name);
            printf(" %d", n_value);
            printf("\n");
        }
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlValidGetPotentialChildren(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlValidGetValidElements(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlValidNormalizeAttributeValue(void) {
    int ret = 0;

#ifdef 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);
        elem = gen_xmlNodePtr(n_elem);
        name = gen_const_xmlChar_ptr(n_name);
        value = gen_const_xmlChar_ptr(n_value);

        ret_val = xmlValidNormalizeAttributeValue(doc, elem, name, value);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_elem, elem);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_value, value);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidNormalizeAttributeValue",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_elem);
            printf(" %d", n_name);
            printf(" %d", n_value);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlValidateAttributeDecl(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlValidateAttributeValue(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlValidateDocument(void) {
    int ret = 0;

#ifdef 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);
        doc = gen_xmlDocPtr(n_doc);

        ret_val = xmlValidateDocument(ctxt, doc);
        desret_int(ret_val);
        call_tests++;
        des_xmlValidCtxtPtr(n_ctxt, ctxt);
        des_xmlDocPtr(n_doc, doc);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateDocument",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_doc);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlValidateDocumentFinal(void) {
    int ret = 0;

#ifdef 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);
        doc = gen_xmlDocPtr(n_doc);

        ret_val = xmlValidateDocumentFinal(ctxt, doc);
        desret_int(ret_val);
        call_tests++;
        des_xmlValidCtxtPtr(n_ctxt, ctxt);
        des_xmlDocPtr(n_doc, doc);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateDocumentFinal",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_doc);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlValidateDtd(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlValidateDtdFinal(void) {
    int ret = 0;

#ifdef 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);
        doc = gen_xmlDocPtr(n_doc);

        ret_val = xmlValidateDtdFinal(ctxt, doc);
        desret_int(ret_val);
        call_tests++;
        des_xmlValidCtxtPtr(n_ctxt, ctxt);
        des_xmlDocPtr(n_doc, doc);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateDtdFinal",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_doc);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlValidateElement(void) {
    int ret = 0;

#ifdef 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);
        doc = gen_xmlDocPtr(n_doc);
        elem = gen_xmlNodePtr(n_elem);

        ret_val = xmlValidateElement(ctxt, doc, elem);
        desret_int(ret_val);
        call_tests++;
        des_xmlValidCtxtPtr(n_ctxt, ctxt);
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_elem, elem);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_doc);
            printf(" %d", n_elem);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlValidateElementDecl(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlValidateNameValue(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlValidateNameValue(value);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_value, value);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateNameValue",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_value);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlValidateNamesValue(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlValidateNamesValue(value);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_value, value);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateNamesValue",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_value);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlValidateNmtokenValue(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlValidateNmtokenValue(value);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_value, value);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateNmtokenValue",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_value);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlValidateNmtokensValue(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlValidateNmtokensValue(value);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_value, value);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateNmtokensValue",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_value);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlValidateNotationDecl(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlValidateNotationUse(void) {
    int ret = 0;

#ifdef LIBXML_VALID_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);
        doc = gen_xmlDocPtr(n_doc);
        notationName = gen_const_xmlChar_ptr(n_notationName);

        ret_val = xmlValidateNotationUse(ctxt, doc, notationName);
        desret_int(ret_val);
        call_tests++;
        des_xmlValidCtxtPtr(n_ctxt, ctxt);
        des_xmlDocPtr(n_doc, doc);
        des_const_xmlChar_ptr(n_notationName, notationName);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateNotationUse",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_doc);
            printf(" %d", n_notationName);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlValidateOneAttribute(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlValidateOneElement(void) {
    int ret = 0;

#ifdef 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);
        doc = gen_xmlDocPtr(n_doc);
        elem = gen_xmlNodePtr(n_elem);

        ret_val = xmlValidateOneElement(ctxt, doc, elem);
        desret_int(ret_val);
        call_tests++;
        des_xmlValidCtxtPtr(n_ctxt, ctxt);
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_elem, elem);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateOneElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_doc);
            printf(" %d", n_elem);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlValidateOneNamespace(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlValidatePopElement(void) {
    int ret = 0;

#ifdef 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);
        doc = gen_xmlDocPtr(n_doc);
        elem = gen_xmlNodePtr(n_elem);
        qname = gen_const_xmlChar_ptr(n_qname);

        ret_val = xmlValidatePopElement(ctxt, doc, elem, qname);
        desret_int(ret_val);
        call_tests++;
        des_xmlValidCtxtPtr(n_ctxt, ctxt);
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_elem, elem);
        des_const_xmlChar_ptr(n_qname, qname);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidatePopElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_doc);
            printf(" %d", n_elem);
            printf(" %d", n_qname);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlValidatePushCData(void) {
    int ret = 0;

#ifdef 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 lenght 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);
        data = gen_const_xmlChar_ptr(n_data);
        len = gen_int(n_len);

        ret_val = xmlValidatePushCData(ctxt, data, len);
        desret_int(ret_val);
        call_tests++;
        des_xmlValidCtxtPtr(n_ctxt, ctxt);
        des_const_xmlChar_ptr(n_data, data);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidatePushCData",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_data);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlValidatePushElement(void) {
    int ret = 0;

#ifdef 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);
        doc = gen_xmlDocPtr(n_doc);
        elem = gen_xmlNodePtr(n_elem);
        qname = gen_const_xmlChar_ptr(n_qname);

        ret_val = xmlValidatePushElement(ctxt, doc, elem, qname);
        desret_int(ret_val);
        call_tests++;
        des_xmlValidCtxtPtr(n_ctxt, ctxt);
        des_xmlDocPtr(n_doc, doc);
        des_xmlNodePtr(n_elem, elem);
        des_const_xmlChar_ptr(n_qname, qname);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidatePushElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_doc);
            printf(" %d", n_elem);
            printf(" %d", n_qname);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlValidateRoot(void) {
    int ret = 0;

#ifdef 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);
        doc = gen_xmlDocPtr(n_doc);

        ret_val = xmlValidateRoot(ctxt, doc);
        desret_int(ret_val);
        call_tests++;
        des_xmlValidCtxtPtr(n_ctxt, ctxt);
        des_xmlDocPtr(n_doc, doc);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlValidateRoot",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_ctxt);
            printf(" %d", n_doc);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}

static int
test_valid(void) {
    int ret = 0;

    printf("Testing valid ...\n");
    ret += test_xmlAddAttributeDecl();
    ret += test_xmlAddElementDecl();
    ret += test_xmlAddID();
    ret += test_xmlAddNotationDecl();
    ret += test_xmlAddRef();
    ret += test_xmlCopyAttributeTable();
    ret += test_xmlCopyElementContent();
    ret += test_xmlCopyElementTable();
    ret += test_xmlCopyEnumeration();
    ret += test_xmlCopyNotationTable();
    ret += test_xmlCreateEnumeration();
    ret += test_xmlDumpAttributeDecl();
    ret += test_xmlDumpAttributeTable();
    ret += test_xmlDumpElementDecl();
    ret += test_xmlDumpElementTable();
    ret += test_xmlDumpNotationDecl();
    ret += test_xmlDumpNotationTable();
    ret += test_xmlGetDtdAttrDesc();
    ret += test_xmlGetDtdElementDesc();
    ret += test_xmlGetDtdNotationDesc();
    ret += test_xmlGetDtdQAttrDesc();
    ret += test_xmlGetDtdQElementDesc();
    ret += test_xmlGetID();
    ret += test_xmlGetRefs();
    ret += test_xmlIsID();
    ret += test_xmlIsMixedElement();
    ret += test_xmlIsRef();
    ret += test_xmlNewElementContent();
    ret += test_xmlNewValidCtxt();
    ret += test_xmlRemoveID();
    ret += test_xmlRemoveRef();
    ret += test_xmlSnprintfElementContent();
    ret += test_xmlSprintfElementContent();
    ret += test_xmlValidBuildContentModel();
    ret += test_xmlValidCtxtNormalizeAttributeValue();
    ret += test_xmlValidGetPotentialChildren();
    ret += test_xmlValidGetValidElements();
    ret += test_xmlValidNormalizeAttributeValue();
    ret += test_xmlValidateAttributeDecl();
    ret += test_xmlValidateAttributeValue();
    ret += test_xmlValidateDocument();
    ret += test_xmlValidateDocumentFinal();
    ret += test_xmlValidateDtd();
    ret += test_xmlValidateDtdFinal();
    ret += test_xmlValidateElement();
    ret += test_xmlValidateElementDecl();
    ret += test_xmlValidateNameValue();
    ret += test_xmlValidateNamesValue();
    ret += test_xmlValidateNmtokenValue();
    ret += test_xmlValidateNmtokensValue();
    ret += test_xmlValidateNotationDecl();
    ret += test_xmlValidateNotationUse();
    ret += test_xmlValidateOneAttribute();
    ret += test_xmlValidateOneElement();
    ret += test_xmlValidateOneNamespace();
    ret += test_xmlValidatePopElement();
    ret += test_xmlValidatePushCData();
    ret += test_xmlValidatePushElement();
    ret += test_xmlValidateRoot();

    if (ret != 0)
	printf("Module valid: %d errors\n", ret);
    return(ret);
}

static int
test_xmlXIncludeNewContext(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXIncludeProcess(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlXIncludeProcess(doc);
        desret_int(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlXIncludeProcess",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlXIncludeProcessFlags(void) {
    int ret = 0;

#ifdef 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);
        flags = gen_int(n_flags);

        ret_val = xmlXIncludeProcessFlags(doc, flags);
        desret_int(ret_val);
        call_tests++;
        des_xmlDocPtr(n_doc, doc);
        des_int(n_flags, flags);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlXIncludeProcessFlags",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_doc);
            printf(" %d", n_flags);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlXIncludeProcessNode(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXIncludeProcessTree(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlXIncludeProcessTree(tree);
        desret_int(ret_val);
        call_tests++;
        des_xmlNodePtr(n_tree, tree);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlXIncludeProcessTree",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_tree);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlXIncludeProcessTreeFlags(void) {
    int ret = 0;

#ifdef 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);
        flags = gen_int(n_flags);

        ret_val = xmlXIncludeProcessTreeFlags(tree, flags);
        desret_int(ret_val);
        call_tests++;
        des_xmlNodePtr(n_tree, tree);
        des_int(n_flags, flags);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlags",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_tree);
            printf(" %d", n_flags);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlXIncludeSetFlags(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_xinclude(void) {
    int ret = 0;

    printf("Testing xinclude ...\n");
    ret += test_xmlXIncludeNewContext();
    ret += test_xmlXIncludeProcess();
    ret += test_xmlXIncludeProcessFlags();
    ret += test_xmlXIncludeProcessNode();
    ret += test_xmlXIncludeProcessTree();
    ret += test_xmlXIncludeProcessTreeFlags();
    ret += test_xmlXIncludeSetFlags();

    if (ret != 0)
	printf("Module xinclude: %d errors\n", ret);
    return(ret);
}

static int
test_xmlAllocOutputBuffer(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlAllocParserInputBuffer(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCheckFilename(void) {
    int 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);

        ret_val = xmlCheckFilename(path);
        desret_int(ret_val);
        call_tests++;
        des_const_char_ptr(n_path, path);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCheckFilename",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_path);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlCheckHTTPInput(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCleanupInputCallbacks(void) {
    int 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);
	    ret++;
            printf("\n");
        }

    return(ret);
}


static int
test_xmlCleanupOutputCallbacks(void) {
    int ret = 0;

#ifdef 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);
	    ret++;
            printf("\n");
        }
#endif

    return(ret);
}


static int
test_xmlFileClose(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlFileMatch(void) {
    int 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);

        ret_val = xmlFileMatch(filename);
        desret_int(ret_val);
        call_tests++;
        des_filepath(n_filename, filename);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlFileMatch",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlFileOpen(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlFileRead(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIOFTPClose(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIOFTPMatch(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlIOFTPMatch(filename);
        desret_int(ret_val);
        call_tests++;
        des_filepath(n_filename, filename);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlIOFTPMatch",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlIOFTPOpen(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIOFTPRead(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIOHTTPClose(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIOHTTPMatch(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlIOHTTPMatch(filename);
        desret_int(ret_val);
        call_tests++;
        des_filepath(n_filename, filename);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlIOHTTPMatch",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_filename);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlIOHTTPOpen(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIOHTTPOpenW(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlIOHTTPRead(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNoNetExternalEntityLoader(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNormalizeWindowsPath(void) {
    int 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);

        ret_val = xmlNormalizeWindowsPath(path);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_path, path);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlNormalizeWindowsPath",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_path);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlOutputBufferClose(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlOutputBufferCreateFd(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlOutputBufferCreateFile(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlOutputBufferCreateFilename(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlOutputBufferCreateIO(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlOutputBufferFlush(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlOutputBufferWrite(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlOutputBufferWriteEscape(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlOutputBufferWriteString(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserGetDirectory(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserInputBufferCreateFd(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserInputBufferCreateFile(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserInputBufferCreateFilename(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserInputBufferCreateIO(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserInputBufferCreateMem(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserInputBufferCreateStatic(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserInputBufferGrow(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserInputBufferPush(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserInputBufferRead(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlPopInputCallbacks(void) {
    int 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);
	    ret++;
            printf("\n");
        }

    return(ret);
}


static int
test_xmlRegisterDefaultInputCallbacks(void) {
    int 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);
	    ret++;
            printf("\n");
        }

    return(ret);
}


static int
test_xmlRegisterDefaultOutputCallbacks(void) {
    int ret = 0;

#ifdef 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);
	    ret++;
            printf("\n");
        }
#endif

    return(ret);
}


static int
test_xmlRegisterHTTPPostCallbacks(void) {
    int ret = 0;

#ifdef 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);
	    ret++;
            printf("\n");
        }
#endif

    return(ret);
}


static int
test_xmlRegisterInputCallbacks(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlRegisterOutputCallbacks(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_xmlIO(void) {
    int ret = 0;

    printf("Testing xmlIO ...\n");
    ret += test_xmlAllocOutputBuffer();
    ret += test_xmlAllocParserInputBuffer();
    ret += test_xmlCheckFilename();
    ret += test_xmlCheckHTTPInput();
    ret += test_xmlCleanupInputCallbacks();
    ret += test_xmlCleanupOutputCallbacks();
    ret += test_xmlFileClose();
    ret += test_xmlFileMatch();
    ret += test_xmlFileOpen();
    ret += test_xmlFileRead();
    ret += test_xmlIOFTPClose();
    ret += test_xmlIOFTPMatch();
    ret += test_xmlIOFTPOpen();
    ret += test_xmlIOFTPRead();
    ret += test_xmlIOHTTPClose();
    ret += test_xmlIOHTTPMatch();
    ret += test_xmlIOHTTPOpen();
    ret += test_xmlIOHTTPOpenW();
    ret += test_xmlIOHTTPRead();
    ret += test_xmlNoNetExternalEntityLoader();
    ret += test_xmlNormalizeWindowsPath();
    ret += test_xmlOutputBufferClose();
    ret += test_xmlOutputBufferCreateFd();
    ret += test_xmlOutputBufferCreateFile();
    ret += test_xmlOutputBufferCreateFilename();
    ret += test_xmlOutputBufferCreateIO();
    ret += test_xmlOutputBufferFlush();
    ret += test_xmlOutputBufferWrite();
    ret += test_xmlOutputBufferWriteEscape();
    ret += test_xmlOutputBufferWriteString();
    ret += test_xmlParserGetDirectory();
    ret += test_xmlParserInputBufferCreateFd();
    ret += test_xmlParserInputBufferCreateFile();
    ret += test_xmlParserInputBufferCreateFilename();
    ret += test_xmlParserInputBufferCreateIO();
    ret += test_xmlParserInputBufferCreateMem();
    ret += test_xmlParserInputBufferCreateStatic();
    ret += test_xmlParserInputBufferGrow();
    ret += test_xmlParserInputBufferPush();
    ret += test_xmlParserInputBufferRead();
    ret += test_xmlPopInputCallbacks();
    ret += test_xmlRegisterDefaultInputCallbacks();
    ret += test_xmlRegisterDefaultOutputCallbacks();
    ret += test_xmlRegisterHTTPPostCallbacks();
    ret += test_xmlRegisterInputCallbacks();
    ret += test_xmlRegisterOutputCallbacks();

    if (ret != 0)
	printf("Module xmlIO: %d errors\n", ret);
    return(ret);
}

static int
test_initGenericErrorDefaultFunc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCopyError(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCtxtGetLastError(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlCtxtResetLastError(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetLastError(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserError(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserPrintFileContext(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserPrintFileInfo(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserValidityError(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserValidityWarning(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlParserWarning(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlResetError(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlResetLastError(void) {
    int ret = 0;



        xmlResetLastError();
        call_tests++;
        xmlResetLastError();

    return(ret);
}


static int
test_xmlSetGenericErrorFunc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSetStructuredErrorFunc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_xmlerror(void) {
    int ret = 0;

    printf("Testing xmlerror ...\n");
    ret += test_initGenericErrorDefaultFunc();
    ret += test_xmlCopyError();
    ret += test_xmlCtxtGetLastError();
    ret += test_xmlCtxtResetLastError();
    ret += test_xmlGetLastError();
    ret += test_xmlParserError();
    ret += test_xmlParserPrintFileContext();
    ret += test_xmlParserPrintFileInfo();
    ret += test_xmlParserValidityError();
    ret += test_xmlParserValidityWarning();
    ret += test_xmlParserWarning();
    ret += test_xmlResetError();
    ret += test_xmlResetLastError();
    ret += test_xmlSetGenericErrorFunc();
    ret += test_xmlSetStructuredErrorFunc();

    if (ret != 0)
	printf("Module xmlerror: %d errors\n", ret);
    return(ret);
}

static int
test_xmlNewTextReader(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewTextReaderFilename(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlReaderForDoc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlReaderForFd(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlReaderForFile(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlReaderForIO(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlReaderForMemory(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlReaderNewDoc(void) {
    int ret = 0;

#ifdef 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_int;n_options++) {
        mem_base = xmlMemBlocks();
        reader = gen_xmlTextReaderPtr(n_reader);
        cur = gen_const_xmlChar_ptr(n_cur);
        URL = gen_filepath(n_URL);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = xmlReaderNewDoc(reader, cur, URL, encoding, options);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_const_xmlChar_ptr(n_cur, cur);
        des_filepath(n_URL, URL);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlReaderNewDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_cur);
            printf(" %d", n_URL);
            printf(" %d", n_encoding);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlReaderNewFile(void) {
    int ret = 0;

#ifdef 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_int;n_options++) {
        mem_base = xmlMemBlocks();
        reader = gen_xmlTextReaderPtr(n_reader);
        filename = gen_filepath(n_filename);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = xmlReaderNewFile(reader, filename, encoding, options);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_filepath(n_filename, filename);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlReaderNewFile",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_filename);
            printf(" %d", n_encoding);
            printf(" %d", n_options);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlReaderNewIO(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlReaderNewMemory(void) {
    int ret = 0;

#ifdef 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_int;n_options++) {
        mem_base = xmlMemBlocks();
        reader = gen_xmlTextReaderPtr(n_reader);
        buffer = gen_const_char_ptr(n_buffer);
        size = gen_int(n_size);
        URL = gen_filepath(n_URL);
        encoding = gen_const_char_ptr(n_encoding);
        options = gen_int(n_options);

        ret_val = xmlReaderNewMemory(reader, buffer, size, URL, encoding, options);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_const_char_ptr(n_buffer, buffer);
        des_int(n_size, size);
        des_filepath(n_URL, URL);
        des_const_char_ptr(n_encoding, encoding);
        des_int(n_options, options);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlReaderNewMemory",
	           xmlMemBlocks() - mem_base);
	    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");
        }
    }
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlReaderNewWalker(void) {
    int ret = 0;

#ifdef 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);
        doc = gen_xmlDocPtr(n_doc);

        ret_val = xmlReaderNewWalker(reader, doc);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_xmlDocPtr(n_doc, doc);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlReaderNewWalker",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_doc);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlReaderWalker(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextReaderAttributeCount(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderAttributeCount(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderAttributeCount",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderBaseUri(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderBaseUri(reader);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderBaseUri",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderClose(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderClose(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderClose",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderConstBaseUri(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderConstBaseUri(reader);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderConstBaseUri",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderConstEncoding(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderConstEncoding(reader);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderConstEncoding",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderConstLocalName(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderConstLocalName(reader);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderConstLocalName",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderConstName(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderConstName(reader);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderConstName",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderConstNamespaceUri(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderConstNamespaceUri(reader);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderConstNamespaceUri",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderConstPrefix(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderConstPrefix(reader);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderConstPrefix",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderConstString(void) {
    int ret = 0;

#ifdef 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);
        str = gen_const_xmlChar_ptr(n_str);

        ret_val = xmlTextReaderConstString(reader, str);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_const_xmlChar_ptr(n_str, str);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderConstString",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_str);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderConstValue(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderConstValue(reader);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderConstValue",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderConstXmlLang(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderConstXmlLang(reader);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderConstXmlLang",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderConstXmlVersion(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderConstXmlVersion(reader);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderConstXmlVersion",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderCurrentDoc(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderCurrentDoc(reader);
        desret_xmlDocPtr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderCurrentDoc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderCurrentNode(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderCurrentNode(reader);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderCurrentNode",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderDepth(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderDepth(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderDepth",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderExpand(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderExpand(reader);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderExpand",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderGetAttribute(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlTextReaderGetAttribute(reader, name);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderGetAttribute",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderGetAttributeNo(void) {
    int ret = 0;

#ifdef 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);
        no = gen_int(n_no);

        ret_val = xmlTextReaderGetAttributeNo(reader, no);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_int(n_no, no);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderGetAttributeNo",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_no);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderGetAttributeNs(void) {
    int ret = 0;

#ifdef 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);
        localName = gen_const_xmlChar_ptr(n_localName);
        namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI);

        ret_val = xmlTextReaderGetAttributeNs(reader, localName, namespaceURI);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_const_xmlChar_ptr(n_localName, localName);
        des_const_xmlChar_ptr(n_namespaceURI, namespaceURI);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderGetAttributeNs",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_localName);
            printf(" %d", n_namespaceURI);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderGetErrorHandler(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextReaderGetParserProp(void) {
    int ret = 0;

#ifdef 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);
        prop = gen_int(n_prop);

        ret_val = xmlTextReaderGetParserProp(reader, prop);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_int(n_prop, prop);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderGetParserProp",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_prop);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderGetRemainder(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextReaderHasAttributes(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderHasAttributes(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderHasAttributes",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderHasValue(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderHasValue(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderHasValue",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderIsDefault(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderIsDefault(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderIsDefault",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderIsEmptyElement(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderIsEmptyElement(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderIsEmptyElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderIsNamespaceDecl(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderIsNamespaceDecl(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderIsNamespaceDecl",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderIsValid(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderIsValid(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderIsValid",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderLocalName(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderLocalName(reader);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderLocalName",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderLocatorBaseURI(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextReaderLocatorLineNumber(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextReaderLookupNamespace(void) {
    int ret = 0;

#ifdef 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);
        prefix = gen_const_xmlChar_ptr(n_prefix);

        ret_val = xmlTextReaderLookupNamespace(reader, prefix);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_const_xmlChar_ptr(n_prefix, prefix);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderLookupNamespace",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_prefix);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderMoveToAttribute(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlTextReaderMoveToAttribute(reader, name);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderMoveToAttribute",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderMoveToAttributeNo(void) {
    int ret = 0;

#ifdef 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);
        no = gen_int(n_no);

        ret_val = xmlTextReaderMoveToAttributeNo(reader, no);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_int(n_no, no);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNo",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_no);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderMoveToAttributeNs(void) {
    int ret = 0;

#ifdef 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);
        localName = gen_const_xmlChar_ptr(n_localName);
        namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI);

        ret_val = xmlTextReaderMoveToAttributeNs(reader, localName, namespaceURI);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_const_xmlChar_ptr(n_localName, localName);
        des_const_xmlChar_ptr(n_namespaceURI, namespaceURI);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNs",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_localName);
            printf(" %d", n_namespaceURI);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderMoveToElement(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderMoveToElement(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderMoveToElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderMoveToFirstAttribute(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderMoveToFirstAttribute(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderMoveToFirstAttribute",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderMoveToNextAttribute(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderMoveToNextAttribute(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderMoveToNextAttribute",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderName(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderName(reader);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderName",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderNamespaceUri(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderNamespaceUri(reader);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderNamespaceUri",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderNext(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderNext(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderNext",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderNextSibling(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderNextSibling(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderNextSibling",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderNodeType(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderNodeType(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderNodeType",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderNormalization(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderNormalization(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderNormalization",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderPrefix(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderPrefix(reader);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderPrefix",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderPreserve(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderPreserve(reader);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderPreserve",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderPreservePattern(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextReaderQuoteChar(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderQuoteChar(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderQuoteChar",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderRead(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderRead(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderRead",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderReadAttributeValue(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderReadAttributeValue(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderReadAttributeValue",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderReadState(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderReadState(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderReadState",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderRelaxNGSetSchema(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextReaderRelaxNGValidate(void) {
    int ret = 0;

#ifdef LIBXML_READER_ENABLED
#ifdef 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);
        rng = gen_const_char_ptr(n_rng);

        ret_val = xmlTextReaderRelaxNGValidate(reader, rng);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_const_char_ptr(n_rng, rng);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidate",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_rng);
            printf("\n");
        }
    }
    }
#endif
#endif

    return(ret);
}


static int
test_xmlTextReaderSetErrorHandler(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextReaderSetParserProp(void) {
    int ret = 0;

#ifdef 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);
        prop = gen_int(n_prop);
        value = gen_int(n_value);

        ret_val = xmlTextReaderSetParserProp(reader, prop, value);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        des_int(n_prop, prop);
        des_int(n_value, value);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderSetParserProp",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf(" %d", n_prop);
            printf(" %d", n_value);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderSetStructuredErrorHandler(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextReaderStandalone(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderStandalone(reader);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderStandalone",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderValue(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderValue(reader);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderValue",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextReaderXmlLang(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextReaderXmlLang(reader);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlTextReaderPtr(n_reader, reader);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextReaderXmlLang",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_reader);
            printf("\n");
        }
    }
#endif

    return(ret);
}

static int
test_xmlreader(void) {
    int ret = 0;

    printf("Testing xmlreader ...\n");
    ret += test_xmlNewTextReader();
    ret += test_xmlNewTextReaderFilename();
    ret += test_xmlReaderForDoc();
    ret += test_xmlReaderForFd();
    ret += test_xmlReaderForFile();
    ret += test_xmlReaderForIO();
    ret += test_xmlReaderForMemory();
    ret += test_xmlReaderNewDoc();
    ret += test_xmlReaderNewFile();
    ret += test_xmlReaderNewIO();
    ret += test_xmlReaderNewMemory();
    ret += test_xmlReaderNewWalker();
    ret += test_xmlReaderWalker();
    ret += test_xmlTextReaderAttributeCount();
    ret += test_xmlTextReaderBaseUri();
    ret += test_xmlTextReaderClose();
    ret += test_xmlTextReaderConstBaseUri();
    ret += test_xmlTextReaderConstEncoding();
    ret += test_xmlTextReaderConstLocalName();
    ret += test_xmlTextReaderConstName();
    ret += test_xmlTextReaderConstNamespaceUri();
    ret += test_xmlTextReaderConstPrefix();
    ret += test_xmlTextReaderConstString();
    ret += test_xmlTextReaderConstValue();
    ret += test_xmlTextReaderConstXmlLang();
    ret += test_xmlTextReaderConstXmlVersion();
    ret += test_xmlTextReaderCurrentDoc();
    ret += test_xmlTextReaderCurrentNode();
    ret += test_xmlTextReaderDepth();
    ret += test_xmlTextReaderExpand();
    ret += test_xmlTextReaderGetAttribute();
    ret += test_xmlTextReaderGetAttributeNo();
    ret += test_xmlTextReaderGetAttributeNs();
    ret += test_xmlTextReaderGetErrorHandler();
    ret += test_xmlTextReaderGetParserProp();
    ret += test_xmlTextReaderGetRemainder();
    ret += test_xmlTextReaderHasAttributes();
    ret += test_xmlTextReaderHasValue();
    ret += test_xmlTextReaderIsDefault();
    ret += test_xmlTextReaderIsEmptyElement();
    ret += test_xmlTextReaderIsNamespaceDecl();
    ret += test_xmlTextReaderIsValid();
    ret += test_xmlTextReaderLocalName();
    ret += test_xmlTextReaderLocatorBaseURI();
    ret += test_xmlTextReaderLocatorLineNumber();
    ret += test_xmlTextReaderLookupNamespace();
    ret += test_xmlTextReaderMoveToAttribute();
    ret += test_xmlTextReaderMoveToAttributeNo();
    ret += test_xmlTextReaderMoveToAttributeNs();
    ret += test_xmlTextReaderMoveToElement();
    ret += test_xmlTextReaderMoveToFirstAttribute();
    ret += test_xmlTextReaderMoveToNextAttribute();
    ret += test_xmlTextReaderName();
    ret += test_xmlTextReaderNamespaceUri();
    ret += test_xmlTextReaderNext();
    ret += test_xmlTextReaderNextSibling();
    ret += test_xmlTextReaderNodeType();
    ret += test_xmlTextReaderNormalization();
    ret += test_xmlTextReaderPrefix();
    ret += test_xmlTextReaderPreserve();
    ret += test_xmlTextReaderPreservePattern();
    ret += test_xmlTextReaderQuoteChar();
    ret += test_xmlTextReaderRead();
    ret += test_xmlTextReaderReadAttributeValue();
    ret += test_xmlTextReaderReadState();
    ret += test_xmlTextReaderRelaxNGSetSchema();
    ret += test_xmlTextReaderRelaxNGValidate();
    ret += test_xmlTextReaderSetErrorHandler();
    ret += test_xmlTextReaderSetParserProp();
    ret += test_xmlTextReaderSetStructuredErrorHandler();
    ret += test_xmlTextReaderStandalone();
    ret += test_xmlTextReaderValue();
    ret += test_xmlTextReaderXmlLang();

    if (ret != 0)
	printf("Module xmlreader: %d errors\n", ret);
    return(ret);
}

static int
test_xmlSaveClose(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSaveDoc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSaveFlush(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSaveSetAttrEscape(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSaveSetEscape(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSaveToFd(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSaveToFilename(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSaveToIO(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSaveTree(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_xmlsave(void) {
    int ret = 0;

    printf("Testing xmlsave ...\n");
    ret += test_xmlSaveClose();
    ret += test_xmlSaveDoc();
    ret += test_xmlSaveFlush();
    ret += test_xmlSaveSetAttrEscape();
    ret += test_xmlSaveSetEscape();
    ret += test_xmlSaveToFd();
    ret += test_xmlSaveToFilename();
    ret += test_xmlSaveToIO();
    ret += test_xmlSaveTree();

    if (ret != 0)
	printf("Module xmlsave: %d errors\n", ret);
    return(ret);
}

static int
test_xmlSchemaDump(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaGetParserErrors(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaGetValidErrors(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaNewDocParserCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaNewMemParserCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaNewParserCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaNewValidCtxt(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaParse(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaSetParserErrors(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaSetValidErrors(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaSetValidOptions(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaValidCtxtGetOptions(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaValidateDoc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaValidateOneElement(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaValidateStream(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_xmlschemas(void) {
    int ret = 0;

    printf("Testing xmlschemas ...\n");
    ret += test_xmlSchemaDump();
    ret += test_xmlSchemaGetParserErrors();
    ret += test_xmlSchemaGetValidErrors();
    ret += test_xmlSchemaNewDocParserCtxt();
    ret += test_xmlSchemaNewMemParserCtxt();
    ret += test_xmlSchemaNewParserCtxt();
    ret += test_xmlSchemaNewValidCtxt();
    ret += test_xmlSchemaParse();
    ret += test_xmlSchemaSetParserErrors();
    ret += test_xmlSchemaSetValidErrors();
    ret += test_xmlSchemaSetValidOptions();
    ret += test_xmlSchemaValidCtxtGetOptions();
    ret += test_xmlSchemaValidateDoc();
    ret += test_xmlSchemaValidateOneElement();
    ret += test_xmlSchemaValidateStream();

    if (ret != 0)
	printf("Module xmlschemas: %d errors\n", ret);
    return(ret);
}

static int
test_xmlSchemaCheckFacet(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaCleanupTypes(void) {
    int ret = 0;

#ifdef LIBXML_SCHEMAS_ENABLED
    int mem_base;

        mem_base = xmlMemBlocks();

        xmlSchemaCleanupTypes();
        call_tests++;
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlSchemaCleanupTypes",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf("\n");
        }
#endif

    return(ret);
}


static int
test_xmlSchemaCollapseString(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlSchemaCollapseString(value);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_value, value);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlSchemaCollapseString",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_value);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlSchemaCompareValues(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaGetBuiltInListSimpleTypeItemType(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaGetBuiltInType(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaGetFacetValueAsULong(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaGetPredefinedType(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaInitTypes(void) {
    int ret = 0;

#ifdef LIBXML_SCHEMAS_ENABLED


        xmlSchemaInitTypes();
        call_tests++;
        xmlResetLastError();
#endif

    return(ret);
}


static int
test_xmlSchemaIsBuiltInTypeFacet(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaNewFacet(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaValPredefTypeNode(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaValPredefTypeNodeNoNorm(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaValidateFacet(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaValidateLengthFacet(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaValidateListSimpleTypeFacet(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlSchemaValidatePredefinedType(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_xmlschemastypes(void) {
    int ret = 0;

    printf("Testing xmlschemastypes ...\n");
    ret += test_xmlSchemaCheckFacet();
    ret += test_xmlSchemaCleanupTypes();
    ret += test_xmlSchemaCollapseString();
    ret += test_xmlSchemaCompareValues();
    ret += test_xmlSchemaGetBuiltInListSimpleTypeItemType();
    ret += test_xmlSchemaGetBuiltInType();
    ret += test_xmlSchemaGetFacetValueAsULong();
    ret += test_xmlSchemaGetPredefinedType();
    ret += test_xmlSchemaInitTypes();
    ret += test_xmlSchemaIsBuiltInTypeFacet();
    ret += test_xmlSchemaNewFacet();
    ret += test_xmlSchemaValPredefTypeNode();
    ret += test_xmlSchemaValPredefTypeNodeNoNorm();
    ret += test_xmlSchemaValidateFacet();
    ret += test_xmlSchemaValidateLengthFacet();
    ret += test_xmlSchemaValidateListSimpleTypeFacet();
    ret += test_xmlSchemaValidatePredefinedType();

    if (ret != 0)
	printf("Module xmlschemastypes: %d errors\n", ret);
    return(ret);
}

static int
test_xmlCharStrdup(void) {
    int 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);

        ret_val = xmlCharStrdup(cur);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_char_ptr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCharStrdup",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlCharStrndup(void) {
    int 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);
        len = gen_int(n_len);

        ret_val = xmlCharStrndup(cur, len);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_char_ptr(n_cur, cur);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlCharStrndup",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlCheckUTF8(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlGetUTF8Char(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlStrEqual(void) {
    int 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);
        str2 = gen_const_xmlChar_ptr(n_str2);

        ret_val = xmlStrEqual(str1, str2);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_str1, str1);
        des_const_xmlChar_ptr(n_str2, str2);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrEqual",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_str1);
            printf(" %d", n_str2);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlStrPrintf(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlStrQEqual(void) {
    int 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);
        name = gen_const_xmlChar_ptr(n_name);
        str = gen_const_xmlChar_ptr(n_str);

        ret_val = xmlStrQEqual(pref, name, str);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_pref, pref);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_str, str);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrQEqual",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_pref);
            printf(" %d", n_name);
            printf(" %d", n_str);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlStrVPrintf(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlStrcasecmp(void) {
    int 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);
        str2 = gen_const_xmlChar_ptr(n_str2);

        ret_val = xmlStrcasecmp(str1, str2);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_str1, str1);
        des_const_xmlChar_ptr(n_str2, str2);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrcasecmp",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_str1);
            printf(" %d", n_str2);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlStrcasestr(void) {
    int ret = 0;

    int mem_base;
    const xmlChar * ret_val;
    const xmlChar * str; /* the xmlChar * array (haystack) */
    int n_str;
    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_xmlChar_ptr;n_val++) {
        mem_base = xmlMemBlocks();
        str = gen_const_xmlChar_ptr(n_str);
        val = gen_xmlChar_ptr(n_val);

        ret_val = xmlStrcasestr(str, val);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_str, str);
        des_xmlChar_ptr(n_val, val);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrcasestr",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_str);
            printf(" %d", n_val);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlStrchr(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlStrcmp(void) {
    int 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);
        str2 = gen_const_xmlChar_ptr(n_str2);

        ret_val = xmlStrcmp(str1, str2);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_str1, str1);
        des_const_xmlChar_ptr(n_str2, str2);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrcmp",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_str1);
            printf(" %d", n_str2);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlStrdup(void) {
    int 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);

        ret_val = xmlStrdup(cur);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_cur, cur);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrdup",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlStrlen(void) {
    int 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);

        ret_val = xmlStrlen(str);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_str, str);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrlen",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_str);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlStrncasecmp(void) {
    int 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);
        str2 = gen_const_xmlChar_ptr(n_str2);
        len = gen_int(n_len);

        ret_val = xmlStrncasecmp(str1, str2, len);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_str1, str1);
        des_const_xmlChar_ptr(n_str2, str2);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrncasecmp",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_str1);
            printf(" %d", n_str2);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlStrncatNew(void) {
    int 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 */
    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);
        str2 = gen_const_xmlChar_ptr(n_str2);
        len = gen_int(n_len);

        ret_val = xmlStrncatNew(str1, str2, len);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_str1, str1);
        des_const_xmlChar_ptr(n_str2, str2);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrncatNew",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_str1);
            printf(" %d", n_str2);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlStrncmp(void) {
    int 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);
        str2 = gen_const_xmlChar_ptr(n_str2);
        len = gen_int(n_len);

        ret_val = xmlStrncmp(str1, str2, len);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_str1, str1);
        des_const_xmlChar_ptr(n_str2, str2);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrncmp",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_str1);
            printf(" %d", n_str2);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlStrndup(void) {
    int 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);
        len = gen_int(n_len);

        ret_val = xmlStrndup(cur, len);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_cur, cur);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrndup",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_cur);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlStrstr(void) {
    int 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);
        val = gen_const_xmlChar_ptr(n_val);

        ret_val = xmlStrstr(str, val);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_str, str);
        des_const_xmlChar_ptr(n_val, val);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrstr",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_str);
            printf(" %d", n_val);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlStrsub(void) {
    int 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);
        start = gen_int(n_start);
        len = gen_int(n_len);

        ret_val = xmlStrsub(str, start, len);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_str, str);
        des_int(n_start, start);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlStrsub",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_str);
            printf(" %d", n_start);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}


static int
test_xmlUTF8Charcmp(void) {
    int 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);
        utf2 = gen_const_xmlChar_ptr(n_utf2);

        ret_val = xmlUTF8Charcmp(utf1, utf2);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_utf1, utf1);
        des_const_xmlChar_ptr(n_utf2, utf2);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlUTF8Charcmp",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_utf1);
            printf(" %d", n_utf2);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlUTF8Size(void) {
    int 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);

        ret_val = xmlUTF8Size(utf);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_utf, utf);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlUTF8Size",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_utf);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlUTF8Strlen(void) {
    int 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);

        ret_val = xmlUTF8Strlen(utf);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_utf, utf);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlUTF8Strlen",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_utf);
            printf("\n");
        }
    }

    return(ret);
}


static int
test_xmlUTF8Strloc(void) {
    int 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);
        utfchar = gen_const_xmlChar_ptr(n_utfchar);

        ret_val = xmlUTF8Strloc(utf, utfchar);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_utf, utf);
        des_const_xmlChar_ptr(n_utfchar, utfchar);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlUTF8Strloc",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_utf);
            printf(" %d", n_utfchar);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlUTF8Strndup(void) {
    int 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);
        len = gen_int(n_len);

        ret_val = xmlUTF8Strndup(utf, len);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_utf, utf);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlUTF8Strndup",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_utf);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlUTF8Strpos(void) {
    int 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);
        pos = gen_int(n_pos);

        ret_val = xmlUTF8Strpos(utf, pos);
        desret_const_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_utf, utf);
        des_int(n_pos, pos);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlUTF8Strpos",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_utf);
            printf(" %d", n_pos);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlUTF8Strsize(void) {
    int 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);
        len = gen_int(n_len);

        ret_val = xmlUTF8Strsize(utf, len);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_utf, utf);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlUTF8Strsize",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_utf);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }

    return(ret);
}


static int
test_xmlUTF8Strsub(void) {
    int 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);
        start = gen_int(n_start);
        len = gen_int(n_len);

        ret_val = xmlUTF8Strsub(utf, start, len);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_utf, utf);
        des_int(n_start, start);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlUTF8Strsub",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_utf);
            printf(" %d", n_start);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }

    return(ret);
}

static int
test_xmlstring(void) {
    int ret = 0;

    printf("Testing xmlstring ...\n");
    ret += test_xmlCharStrdup();
    ret += test_xmlCharStrndup();
    ret += test_xmlCheckUTF8();
    ret += test_xmlGetUTF8Char();
    ret += test_xmlStrEqual();
    ret += test_xmlStrPrintf();
    ret += test_xmlStrQEqual();
    ret += test_xmlStrVPrintf();
    ret += test_xmlStrcasecmp();
    ret += test_xmlStrcasestr();
    ret += test_xmlStrchr();
    ret += test_xmlStrcmp();
    ret += test_xmlStrdup();
    ret += test_xmlStrlen();
    ret += test_xmlStrncasecmp();
    ret += test_xmlStrncatNew();
    ret += test_xmlStrncmp();
    ret += test_xmlStrndup();
    ret += test_xmlStrstr();
    ret += test_xmlStrsub();
    ret += test_xmlUTF8Charcmp();
    ret += test_xmlUTF8Size();
    ret += test_xmlUTF8Strlen();
    ret += test_xmlUTF8Strloc();
    ret += test_xmlUTF8Strndup();
    ret += test_xmlUTF8Strpos();
    ret += test_xmlUTF8Strsize();
    ret += test_xmlUTF8Strsub();

    if (ret != 0)
	printf("Module xmlstring: %d errors\n", ret);
    return(ret);
}

static int
test_xmlNewTextWriter(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewTextWriterDoc(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewTextWriterFilename(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewTextWriterMemory(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewTextWriterPushParser(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlNewTextWriterTree(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterEndAttribute(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterEndAttribute(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterEndAttribute",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterEndCDATA(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterEndCDATA(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterEndCDATA",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterEndComment(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterEndComment(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterEndComment",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterEndDTD(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterEndDTD(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterEndDTD",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterEndDTDAttlist(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterEndDTDAttlist(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterEndDTDAttlist",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterEndDTDElement(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterEndDTDElement(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterEndDTDElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterEndDTDEntity(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterEndDTDEntity(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterEndDTDEntity",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterEndDocument(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterEndDocument(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterEndDocument",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterEndElement(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterEndElement(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterEndElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterEndPI(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterEndPI(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterEndPI",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterFlush(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterFlush(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterFlush",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterFullEndElement(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterFullEndElement(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterFullEndElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterSetIndent(void) {
    int ret = 0;

#ifdef 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);
        indent = gen_int(n_indent);

        ret_val = xmlTextWriterSetIndent(writer, indent);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_int(n_indent, indent);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterSetIndent",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_indent);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterSetIndentString(void) {
    int ret = 0;

#ifdef 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);
        str = gen_const_xmlChar_ptr(n_str);

        ret_val = xmlTextWriterSetIndentString(writer, str);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_str, str);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterSetIndentString",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_str);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterStartAttribute(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlTextWriterStartAttribute(writer, name);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterStartAttribute",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterStartAttributeNS(void) {
    int ret = 0;

#ifdef 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);
        prefix = gen_const_xmlChar_ptr(n_prefix);
        name = gen_const_xmlChar_ptr(n_name);
        namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI);

        ret_val = xmlTextWriterStartAttributeNS(writer, prefix, name, namespaceURI);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_prefix, prefix);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_namespaceURI, namespaceURI);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterStartAttributeNS",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_prefix);
            printf(" %d", n_name);
            printf(" %d", n_namespaceURI);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterStartCDATA(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterStartCDATA(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterStartCDATA",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterStartComment(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlTextWriterStartComment(writer);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterStartComment",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterStartDTD(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);
        pubid = gen_const_xmlChar_ptr(n_pubid);
        sysid = gen_const_xmlChar_ptr(n_sysid);

        ret_val = xmlTextWriterStartDTD(writer, name, pubid, sysid);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_pubid, pubid);
        des_const_xmlChar_ptr(n_sysid, sysid);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterStartDTD",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_name);
            printf(" %d", n_pubid);
            printf(" %d", n_sysid);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterStartDTDAttlist(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlTextWriterStartDTDAttlist(writer, name);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterStartDTDAttlist",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterStartDTDElement(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlTextWriterStartDTDElement(writer, name);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterStartDTDElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterStartDTDEntity(void) {
    int ret = 0;

#ifdef 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);
        pe = gen_int(n_pe);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlTextWriterStartDTDEntity(writer, pe, name);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_int(n_pe, pe);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterStartDTDEntity",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_pe);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterStartDocument(void) {
    int ret = 0;

#ifdef 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);
        version = gen_const_char_ptr(n_version);
        encoding = gen_const_char_ptr(n_encoding);
        standalone = gen_const_char_ptr(n_standalone);

        ret_val = xmlTextWriterStartDocument(writer, version, encoding, standalone);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_char_ptr(n_version, version);
        des_const_char_ptr(n_encoding, encoding);
        des_const_char_ptr(n_standalone, standalone);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterStartDocument",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_version);
            printf(" %d", n_encoding);
            printf(" %d", n_standalone);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterStartElement(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);

        ret_val = xmlTextWriterStartElement(writer, name);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_name, name);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterStartElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_name);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterStartElementNS(void) {
    int ret = 0;

#ifdef 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);
        prefix = gen_const_xmlChar_ptr(n_prefix);
        name = gen_const_xmlChar_ptr(n_name);
        namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI);

        ret_val = xmlTextWriterStartElementNS(writer, prefix, name, namespaceURI);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_prefix, prefix);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_namespaceURI, namespaceURI);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterStartElementNS",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_prefix);
            printf(" %d", n_name);
            printf(" %d", n_namespaceURI);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterStartPI(void) {
    int ret = 0;

#ifdef 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);
        target = gen_const_xmlChar_ptr(n_target);

        ret_val = xmlTextWriterStartPI(writer, target);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_target, target);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterStartPI",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_target);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteAttribute(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWriteAttribute(writer, name, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteAttribute",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_name);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteAttributeNS(void) {
    int ret = 0;

#ifdef 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);
        prefix = gen_const_xmlChar_ptr(n_prefix);
        name = gen_const_xmlChar_ptr(n_name);
        namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWriteAttributeNS(writer, prefix, name, namespaceURI, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_prefix, prefix);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_namespaceURI, namespaceURI);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteAttributeNS",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_prefix);
            printf(" %d", n_name);
            printf(" %d", n_namespaceURI);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteBase64(void) {
    int ret = 0;

#ifdef 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);
        data = gen_const_char_ptr(n_data);
        start = gen_int(n_start);
        len = gen_int(n_len);

        ret_val = xmlTextWriterWriteBase64(writer, data, start, len);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_char_ptr(n_data, data);
        des_int(n_start, start);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteBase64",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_data);
            printf(" %d", n_start);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteBinHex(void) {
    int ret = 0;

#ifdef 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);
        data = gen_const_char_ptr(n_data);
        start = gen_int(n_start);
        len = gen_int(n_len);

        ret_val = xmlTextWriterWriteBinHex(writer, data, start, len);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_char_ptr(n_data, data);
        des_int(n_start, start);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteBinHex",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_data);
            printf(" %d", n_start);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteCDATA(void) {
    int ret = 0;

#ifdef 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);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWriteCDATA(writer, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteCDATA",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteComment(void) {
    int ret = 0;

#ifdef 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);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWriteComment(writer, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteComment",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteDTD(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);
        pubid = gen_const_xmlChar_ptr(n_pubid);
        sysid = gen_const_xmlChar_ptr(n_sysid);
        subset = gen_const_xmlChar_ptr(n_subset);

        ret_val = xmlTextWriterWriteDTD(writer, name, pubid, sysid, subset);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_pubid, pubid);
        des_const_xmlChar_ptr(n_sysid, sysid);
        des_const_xmlChar_ptr(n_subset, subset);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteDTD",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_name);
            printf(" %d", n_pubid);
            printf(" %d", n_sysid);
            printf(" %d", n_subset);
            printf("\n");
        }
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteDTDAttlist(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWriteDTDAttlist(writer, name, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteDTDAttlist",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_name);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteDTDElement(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWriteDTDElement(writer, name, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteDTDElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_name);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteDTDEntity(void) {
    int ret = 0;

#ifdef 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);
        pe = gen_int(n_pe);
        name = gen_const_xmlChar_ptr(n_name);
        pubid = gen_const_xmlChar_ptr(n_pubid);
        sysid = gen_const_xmlChar_ptr(n_sysid);
        ndataid = gen_const_xmlChar_ptr(n_ndataid);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWriteDTDEntity(writer, pe, name, pubid, sysid, ndataid, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_int(n_pe, pe);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_pubid, pubid);
        des_const_xmlChar_ptr(n_sysid, sysid);
        des_const_xmlChar_ptr(n_ndataid, ndataid);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteDTDEntity",
	           xmlMemBlocks() - mem_base);
	    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");
        }
    }
    }
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteDTDExternalEntity(void) {
    int ret = 0;

#ifdef 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);
        pe = gen_int(n_pe);
        name = gen_const_xmlChar_ptr(n_name);
        pubid = gen_const_xmlChar_ptr(n_pubid);
        sysid = gen_const_xmlChar_ptr(n_sysid);
        ndataid = gen_const_xmlChar_ptr(n_ndataid);

        ret_val = xmlTextWriterWriteDTDExternalEntity(writer, pe, name, pubid, sysid, ndataid);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_int(n_pe, pe);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_pubid, pubid);
        des_const_xmlChar_ptr(n_sysid, sysid);
        des_const_xmlChar_ptr(n_ndataid, ndataid);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntity",
	           xmlMemBlocks() - mem_base);
	    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");
        }
    }
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteDTDExternalEntityContents(void) {
    int ret = 0;

#ifdef 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);
        pubid = gen_const_xmlChar_ptr(n_pubid);
        sysid = gen_const_xmlChar_ptr(n_sysid);
        ndataid = gen_const_xmlChar_ptr(n_ndataid);

        ret_val = xmlTextWriterWriteDTDExternalEntityContents(writer, pubid, sysid, ndataid);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_pubid, pubid);
        des_const_xmlChar_ptr(n_sysid, sysid);
        des_const_xmlChar_ptr(n_ndataid, ndataid);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntityContents",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_pubid);
            printf(" %d", n_sysid);
            printf(" %d", n_ndataid);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteDTDInternalEntity(void) {
    int ret = 0;

#ifdef 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);
        pe = gen_int(n_pe);
        name = gen_const_xmlChar_ptr(n_name);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWriteDTDInternalEntity(writer, pe, name, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_int(n_pe, pe);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteDTDInternalEntity",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_pe);
            printf(" %d", n_name);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteDTDNotation(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);
        pubid = gen_const_xmlChar_ptr(n_pubid);
        sysid = gen_const_xmlChar_ptr(n_sysid);

        ret_val = xmlTextWriterWriteDTDNotation(writer, name, pubid, sysid);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_pubid, pubid);
        des_const_xmlChar_ptr(n_sysid, sysid);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteDTDNotation",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_name);
            printf(" %d", n_pubid);
            printf(" %d", n_sysid);
            printf("\n");
        }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteElement(void) {
    int ret = 0;

#ifdef 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);
        name = gen_const_xmlChar_ptr(n_name);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWriteElement(writer, name, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteElement",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_name);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteElementNS(void) {
    int ret = 0;

#ifdef 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);
        prefix = gen_const_xmlChar_ptr(n_prefix);
        name = gen_const_xmlChar_ptr(n_name);
        namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWriteElementNS(writer, prefix, name, namespaceURI, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_prefix, prefix);
        des_const_xmlChar_ptr(n_name, name);
        des_const_xmlChar_ptr(n_namespaceURI, namespaceURI);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteElementNS",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_prefix);
            printf(" %d", n_name);
            printf(" %d", n_namespaceURI);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteFormatAttribute(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteFormatAttributeNS(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteFormatCDATA(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteFormatComment(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteFormatDTD(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteFormatDTDAttlist(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteFormatDTDElement(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteFormatDTDInternalEntity(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteFormatElement(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteFormatElementNS(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteFormatPI(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteFormatRaw(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteFormatString(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWritePI(void) {
    int ret = 0;

#ifdef 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);
        target = gen_const_xmlChar_ptr(n_target);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWritePI(writer, target, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_target, target);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWritePI",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_target);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteRaw(void) {
    int ret = 0;

#ifdef 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);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWriteRaw(writer, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteRaw",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteRawLen(void) {
    int ret = 0;

#ifdef 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);
        content = gen_const_xmlChar_ptr(n_content);
        len = gen_int(n_len);

        ret_val = xmlTextWriterWriteRawLen(writer, content, len);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_content, content);
        des_int(n_len, len);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteRawLen",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_content);
            printf(" %d", n_len);
            printf("\n");
        }
    }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteString(void) {
    int ret = 0;

#ifdef 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);
        content = gen_const_xmlChar_ptr(n_content);

        ret_val = xmlTextWriterWriteString(writer, content);
        desret_int(ret_val);
        call_tests++;
        des_xmlTextWriterPtr(n_writer, writer);
        des_const_xmlChar_ptr(n_content, content);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlTextWriterWriteString",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_writer);
            printf(" %d", n_content);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlTextWriterWriteVFormatAttribute(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteVFormatAttributeNS(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteVFormatCDATA(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteVFormatComment(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteVFormatDTD(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteVFormatDTDAttlist(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteVFormatDTDElement(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteVFormatDTDInternalEntity(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteVFormatElement(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteVFormatElementNS(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteVFormatPI(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteVFormatRaw(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlTextWriterWriteVFormatString(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_xmlwriter(void) {
    int ret = 0;

    printf("Testing xmlwriter ...\n");
    ret += test_xmlNewTextWriter();
    ret += test_xmlNewTextWriterDoc();
    ret += test_xmlNewTextWriterFilename();
    ret += test_xmlNewTextWriterMemory();
    ret += test_xmlNewTextWriterPushParser();
    ret += test_xmlNewTextWriterTree();
    ret += test_xmlTextWriterEndAttribute();
    ret += test_xmlTextWriterEndCDATA();
    ret += test_xmlTextWriterEndComment();
    ret += test_xmlTextWriterEndDTD();
    ret += test_xmlTextWriterEndDTDAttlist();
    ret += test_xmlTextWriterEndDTDElement();
    ret += test_xmlTextWriterEndDTDEntity();
    ret += test_xmlTextWriterEndDocument();
    ret += test_xmlTextWriterEndElement();
    ret += test_xmlTextWriterEndPI();
    ret += test_xmlTextWriterFlush();
    ret += test_xmlTextWriterFullEndElement();
    ret += test_xmlTextWriterSetIndent();
    ret += test_xmlTextWriterSetIndentString();
    ret += test_xmlTextWriterStartAttribute();
    ret += test_xmlTextWriterStartAttributeNS();
    ret += test_xmlTextWriterStartCDATA();
    ret += test_xmlTextWriterStartComment();
    ret += test_xmlTextWriterStartDTD();
    ret += test_xmlTextWriterStartDTDAttlist();
    ret += test_xmlTextWriterStartDTDElement();
    ret += test_xmlTextWriterStartDTDEntity();
    ret += test_xmlTextWriterStartDocument();
    ret += test_xmlTextWriterStartElement();
    ret += test_xmlTextWriterStartElementNS();
    ret += test_xmlTextWriterStartPI();
    ret += test_xmlTextWriterWriteAttribute();
    ret += test_xmlTextWriterWriteAttributeNS();
    ret += test_xmlTextWriterWriteBase64();
    ret += test_xmlTextWriterWriteBinHex();
    ret += test_xmlTextWriterWriteCDATA();
    ret += test_xmlTextWriterWriteComment();
    ret += test_xmlTextWriterWriteDTD();
    ret += test_xmlTextWriterWriteDTDAttlist();
    ret += test_xmlTextWriterWriteDTDElement();
    ret += test_xmlTextWriterWriteDTDEntity();
    ret += test_xmlTextWriterWriteDTDExternalEntity();
    ret += test_xmlTextWriterWriteDTDExternalEntityContents();
    ret += test_xmlTextWriterWriteDTDInternalEntity();
    ret += test_xmlTextWriterWriteDTDNotation();
    ret += test_xmlTextWriterWriteElement();
    ret += test_xmlTextWriterWriteElementNS();
    ret += test_xmlTextWriterWriteFormatAttribute();
    ret += test_xmlTextWriterWriteFormatAttributeNS();
    ret += test_xmlTextWriterWriteFormatCDATA();
    ret += test_xmlTextWriterWriteFormatComment();
    ret += test_xmlTextWriterWriteFormatDTD();
    ret += test_xmlTextWriterWriteFormatDTDAttlist();
    ret += test_xmlTextWriterWriteFormatDTDElement();
    ret += test_xmlTextWriterWriteFormatDTDInternalEntity();
    ret += test_xmlTextWriterWriteFormatElement();
    ret += test_xmlTextWriterWriteFormatElementNS();
    ret += test_xmlTextWriterWriteFormatPI();
    ret += test_xmlTextWriterWriteFormatRaw();
    ret += test_xmlTextWriterWriteFormatString();
    ret += test_xmlTextWriterWritePI();
    ret += test_xmlTextWriterWriteRaw();
    ret += test_xmlTextWriterWriteRawLen();
    ret += test_xmlTextWriterWriteString();
    ret += test_xmlTextWriterWriteVFormatAttribute();
    ret += test_xmlTextWriterWriteVFormatAttributeNS();
    ret += test_xmlTextWriterWriteVFormatCDATA();
    ret += test_xmlTextWriterWriteVFormatComment();
    ret += test_xmlTextWriterWriteVFormatDTD();
    ret += test_xmlTextWriterWriteVFormatDTDAttlist();
    ret += test_xmlTextWriterWriteVFormatDTDElement();
    ret += test_xmlTextWriterWriteVFormatDTDInternalEntity();
    ret += test_xmlTextWriterWriteVFormatElement();
    ret += test_xmlTextWriterWriteVFormatElementNS();
    ret += test_xmlTextWriterWriteVFormatPI();
    ret += test_xmlTextWriterWriteVFormatRaw();
    ret += test_xmlTextWriterWriteVFormatString();

    if (ret != 0)
	printf("Module xmlwriter: %d errors\n", ret);
    return(ret);
}

static int
test_xmlXPathCastBooleanToNumber(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathCastBooleanToString(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlXPathCastBooleanToString(val);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_int(n_val, val);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlXPathCastBooleanToString",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_val);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlXPathCastNodeSetToBoolean(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathCastNodeSetToNumber(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathCastNodeSetToString(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathCastNodeToNumber(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathCastNodeToString(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlXPathCastNodeToString(node);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlNodePtr(n_node, node);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlXPathCastNodeToString",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_node);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlXPathCastNumberToBoolean(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathCastNumberToString(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathCastStringToBoolean(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlXPathCastStringToBoolean(val);
        desret_int(ret_val);
        call_tests++;
        des_const_xmlChar_ptr(n_val, val);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlXPathCastStringToBoolean",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_val);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlXPathCastStringToNumber(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathCastToBoolean(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlXPathCastToBoolean(val);
        desret_int(ret_val);
        call_tests++;
        des_xmlXPathObjectPtr(n_val, val);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlXPathCastToBoolean",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_val);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlXPathCastToNumber(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathCastToString(void) {
    int ret = 0;

#ifdef 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);

        ret_val = xmlXPathCastToString(val);
        desret_xmlChar_ptr(ret_val);
        call_tests++;
        des_xmlXPathObjectPtr(n_val, val);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlXPathCastToString",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_val);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlXPathCmpNodes(void) {
    int ret = 0;

#ifdef 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);
        node2 = gen_xmlNodePtr(n_node2);

        ret_val = xmlXPathCmpNodes(node1, node2);
        desret_int(ret_val);
        call_tests++;
        des_xmlNodePtr(n_node1, node1);
        des_xmlNodePtr(n_node2, node2);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlXPathCmpNodes",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_node1);
            printf(" %d", n_node2);
            printf("\n");
        }
    }
    }
#endif

    return(ret);
}


static int
test_xmlXPathCompile(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathCompiledEval(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathConvertBoolean(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathConvertNumber(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathConvertString(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathCtxtCompile(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathEval(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathEvalExpression(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathEvalPredicate(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathInit(void) {
    int ret = 0;

#ifdef LIBXML_XPATH_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);
	    ret++;
            printf("\n");
        }
#endif

    return(ret);
}


static int
test_xmlXPathIsInf(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathIsNaN(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathNewContext(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathNodeSetCreate(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathObjectCopy(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPathOrderDocElems(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_xpath(void) {
    int ret = 0;

    printf("Testing xpath ...\n");
    ret += test_xmlXPathCastBooleanToNumber();
    ret += test_xmlXPathCastBooleanToString();
    ret += test_xmlXPathCastNodeSetToBoolean();
    ret += test_xmlXPathCastNodeSetToNumber();
    ret += test_xmlXPathCastNodeSetToString();
    ret += test_xmlXPathCastNodeToNumber();
    ret += test_xmlXPathCastNodeToString();
    ret += test_xmlXPathCastNumberToBoolean();
    ret += test_xmlXPathCastNumberToString();
    ret += test_xmlXPathCastStringToBoolean();
    ret += test_xmlXPathCastStringToNumber();
    ret += test_xmlXPathCastToBoolean();
    ret += test_xmlXPathCastToNumber();
    ret += test_xmlXPathCastToString();
    ret += test_xmlXPathCmpNodes();
    ret += test_xmlXPathCompile();
    ret += test_xmlXPathCompiledEval();
    ret += test_xmlXPathConvertBoolean();
    ret += test_xmlXPathConvertNumber();
    ret += test_xmlXPathConvertString();
    ret += test_xmlXPathCtxtCompile();
    ret += test_xmlXPathEval();
    ret += test_xmlXPathEvalExpression();
    ret += test_xmlXPathEvalPredicate();
    ret += test_xmlXPathInit();
    ret += test_xmlXPathIsInf();
    ret += test_xmlXPathIsNaN();
    ret += test_xmlXPathNewContext();
    ret += test_xmlXPathNodeSetCreate();
    ret += test_xmlXPathObjectCopy();
    ret += test_xmlXPathOrderDocElems();

    if (ret != 0)
	printf("Module xpath: %d errors\n", ret);
    return(ret);
}

static int
test_xmlXPtrBuildNodeList(void) {
    int ret = 0;

#ifdef LIBXML_XPTR_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);

        ret_val = xmlXPtrBuildNodeList(obj);
        desret_xmlNodePtr(ret_val);
        call_tests++;
        des_xmlXPathObjectPtr(n_obj, obj);
        xmlResetLastError();
        if (mem_base != xmlMemBlocks()) {
            printf("Leak of %d blocks found in xmlXPtrBuildNodeList",
	           xmlMemBlocks() - mem_base);
	    ret++;
            printf(" %d", n_obj);
            printf("\n");
        }
    }
#endif

    return(ret);
}


static int
test_xmlXPtrEval(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrEvalRangePredicate(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrLocationSetAdd(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrLocationSetCreate(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrLocationSetDel(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrLocationSetMerge(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrLocationSetRemove(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrNewCollapsedRange(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrNewContext(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrNewLocationSetNodeSet(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrNewLocationSetNodes(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrNewRange(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrNewRangeNodeObject(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrNewRangeNodePoint(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrNewRangeNodes(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrNewRangePointNode(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrNewRangePoints(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrRangeToFunction(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}


static int
test_xmlXPtrWrapLocationSet(void) {
    int ret = 0;


    /* missing type support */
    return(ret);
}

static int
test_xpointer(void) {
    int ret = 0;

    printf("Testing xpointer ...\n");
    ret += test_xmlXPtrBuildNodeList();
    ret += test_xmlXPtrEval();
    ret += test_xmlXPtrEvalRangePredicate();
    ret += test_xmlXPtrLocationSetAdd();
    ret += test_xmlXPtrLocationSetCreate();
    ret += test_xmlXPtrLocationSetDel();
    ret += test_xmlXPtrLocationSetMerge();
    ret += test_xmlXPtrLocationSetRemove();
    ret += test_xmlXPtrNewCollapsedRange();
    ret += test_xmlXPtrNewContext();
    ret += test_xmlXPtrNewLocationSetNodeSet();
    ret += test_xmlXPtrNewLocationSetNodes();
    ret += test_xmlXPtrNewRange();
    ret += test_xmlXPtrNewRangeNodeObject();
    ret += test_xmlXPtrNewRangeNodePoint();
    ret += test_xmlXPtrNewRangeNodes();
    ret += test_xmlXPtrNewRangePointNode();
    ret += test_xmlXPtrNewRangePoints();
    ret += test_xmlXPtrRangeToFunction();
    ret += test_xmlXPtrWrapLocationSet();

    if (ret != 0)
	printf("Module xpointer: %d errors\n", ret);
    return(ret);
}