aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ChangeLog6
-rw-r--r--doc/APIconstructors.html2
-rw-r--r--doc/html/libxml-xmlstring.html4
-rw-r--r--doc/libxml2-api.xml2
-rw-r--r--doc/libxml2-refs.xml2
-rw-r--r--elfgcchack.h4
-rwxr-xr-xgentest.py51
-rw-r--r--include/libxml/xmlstring.h2
-rw-r--r--testapi.c1161
-rw-r--r--win32/libxml2.def.src1
-rw-r--r--xmlstring.c4
11 files changed, 1157 insertions, 82 deletions
diff --git a/ChangeLog b/ChangeLog
index 12ed45d8..7163c33f 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+Tue Nov 2 23:09:06 CET 2004 Daniel Veillard <daniel@veillard.com>
+
+ * gentest.py testapi.c: more testing and coverage
+ * elfgcchack.h xmlstring.c include/libxml/xmlstring.h: more cleanups
+ * doc/*: rebuilt
+
Tue Nov 2 19:44:32 CET 2004 Daniel Veillard <daniel@veillard.com>
* gentest.py testapi.c: more developments on the API testing
diff --git a/doc/APIconstructors.html b/doc/APIconstructors.html
index e00c5c4b..fbe9e0cf 100644
--- a/doc/APIconstructors.html
+++ b/doc/APIconstructors.html
@@ -42,6 +42,7 @@ A:link, A:visited, A:active { text-decoration: underline }
<a href="html/libxml-xmlreader.html#xmlTextReaderConstValue">xmlTextReaderConstValue</a><br />
<a href="html/libxml-xmlreader.html#xmlTextReaderConstXmlLang">xmlTextReaderConstXmlLang</a><br />
<a href="html/libxml-xmlreader.html#xmlTextReaderConstXmlVersion">xmlTextReaderConstXmlVersion</a><br />
+<a href="html/libxml-xmlstring.html#xmlUTF8Strpos">xmlUTF8Strpos</a><br />
<a href="html/libxml-xpathInternals.html#xmlXPathNsLookup">xmlXPathNsLookup</a><br />
</p><h2>Type const xmlParserNodeInfo *:</h2><p><a href="html/libxml-parser.html#xmlParserFindNodeInfo">xmlParserFindNodeInfo</a><br />
</p><h2>Type docbDocPtr:</h2><p><a href="html/libxml-DOCBparser.html#docbParseDoc">docbParseDoc</a><br />
@@ -233,7 +234,6 @@ A:link, A:visited, A:active { text-decoration: underline }
<a href="html/libxml-uri.html#xmlURIEscape">xmlURIEscape</a><br />
<a href="html/libxml-uri.html#xmlURIEscapeStr">xmlURIEscapeStr</a><br />
<a href="html/libxml-xmlstring.html#xmlUTF8Strndup">xmlUTF8Strndup</a><br />
-<a href="html/libxml-xmlstring.html#xmlUTF8Strpos">xmlUTF8Strpos</a><br />
<a href="html/libxml-xmlstring.html#xmlUTF8Strsub">xmlUTF8Strsub</a><br />
<a href="html/libxml-valid.html#xmlValidCtxtNormalizeAttributeValue">xmlValidCtxtNormalizeAttributeValue</a><br />
<a href="html/libxml-valid.html#xmlValidNormalizeAttributeValue">xmlValidNormalizeAttributeValue</a><br />
diff --git a/doc/html/libxml-xmlstring.html b/doc/html/libxml-xmlstring.html
index 490df42f..4a48826a 100644
--- a/doc/html/libxml-xmlstring.html
+++ b/doc/html/libxml-xmlstring.html
@@ -38,7 +38,7 @@ A:link, A:visited, A:active { text-decoration: underline }
<pre class="programlisting">int <a href="#xmlUTF8Strlen">xmlUTF8Strlen</a> (const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * utf)</pre>
<pre class="programlisting">int <a href="#xmlUTF8Strloc">xmlUTF8Strloc</a> (const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * utf, <br /> const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * utfchar)</pre>
<pre class="programlisting"><a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlUTF8Strndup">xmlUTF8Strndup</a> (const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * utf, <br /> int len)</pre>
-<pre class="programlisting"><a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlUTF8Strpos">xmlUTF8Strpos</a> (const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * utf, <br /> int pos)</pre>
+<pre class="programlisting">const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlUTF8Strpos">xmlUTF8Strpos</a> (const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * utf, <br /> int pos)</pre>
<pre class="programlisting">int <a href="#xmlUTF8Strsize">xmlUTF8Strsize</a> (const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * utf, <br /> int len)</pre>
<pre class="programlisting"><a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * <a href="#xmlUTF8Strsub">xmlUTF8Strsub</a> (const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * utf, <br /> int start, <br /> int len)</pre>
<h2>Description</h2>
@@ -97,7 +97,7 @@ A:link, A:visited, A:active { text-decoration: underline }
</pre><p>a function to provide the relative location of a UTF8 char</p>
<div class="variablelist"><table border="0"><col align="left" /><tbody><tr><td><span class="term"><i><tt>utf</tt></i>:</span></td><td>the input UTF8 *</td></tr><tr><td><span class="term"><i><tt>utfchar</tt></i>:</span></td><td>the UTF8 character to be found</td></tr><tr><td><span class="term"><i><tt>Returns</tt></i>:</span></td><td>the relative character position of the desired char or -1 if not found</td></tr></tbody></table></div><h3><a name="xmlUTF8Strndup" id="xmlUTF8Strndup"></a>Function: xmlUTF8Strndup</h3><pre class="programlisting"><a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * xmlUTF8Strndup (const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * utf, <br /> int len)<br />
</pre><p>a strndup for array of UTF8's</p>
-<div class="variablelist"><table border="0"><col align="left" /><tbody><tr><td><span class="term"><i><tt>utf</tt></i>:</span></td><td>the input UTF8 *</td></tr><tr><td><span class="term"><i><tt>len</tt></i>:</span></td><td>the len of @utf (in chars)</td></tr><tr><td><span class="term"><i><tt>Returns</tt></i>:</span></td><td>a new UTF8 * or NULL</td></tr></tbody></table></div><h3><a name="xmlUTF8Strpos" id="xmlUTF8Strpos"></a>Function: xmlUTF8Strpos</h3><pre class="programlisting"><a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * xmlUTF8Strpos (const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * utf, <br /> int pos)<br />
+<div class="variablelist"><table border="0"><col align="left" /><tbody><tr><td><span class="term"><i><tt>utf</tt></i>:</span></td><td>the input UTF8 *</td></tr><tr><td><span class="term"><i><tt>len</tt></i>:</span></td><td>the len of @utf (in chars)</td></tr><tr><td><span class="term"><i><tt>Returns</tt></i>:</span></td><td>a new UTF8 * or NULL</td></tr></tbody></table></div><h3><a name="xmlUTF8Strpos" id="xmlUTF8Strpos"></a>Function: xmlUTF8Strpos</h3><pre class="programlisting">const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * xmlUTF8Strpos (const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * utf, <br /> int pos)<br />
</pre><p>a function to provide the equivalent of fetching a character from a string array</p>
<div class="variablelist"><table border="0"><col align="left" /><tbody><tr><td><span class="term"><i><tt>utf</tt></i>:</span></td><td>the input UTF8 *</td></tr><tr><td><span class="term"><i><tt>pos</tt></i>:</span></td><td>the position of the desired UTF8 char (in chars)</td></tr><tr><td><span class="term"><i><tt>Returns</tt></i>:</span></td><td>a pointer to the UTF8 character or NULL</td></tr></tbody></table></div><h3><a name="xmlUTF8Strsize" id="xmlUTF8Strsize"></a>Function: xmlUTF8Strsize</h3><pre class="programlisting">int xmlUTF8Strsize (const <a href="libxml-xmlstring.html#xmlChar">xmlChar</a> * utf, <br /> int len)<br />
</pre><p>storage size of an UTF8 string</p>
diff --git a/doc/libxml2-api.xml b/doc/libxml2-api.xml
index 8d243575..e65e13d1 100644
--- a/doc/libxml2-api.xml
+++ b/doc/libxml2-api.xml
@@ -15276,7 +15276,7 @@ actually an xmlCharEncoding'/>
</function>
<function name='xmlUTF8Strpos' file='xmlstring'>
<info>a function to provide the equivalent of fetching a character from a string array</info>
- <return type='xmlChar *' info='a pointer to the UTF8 character or NULL'/>
+ <return type='const xmlChar *' info='a pointer to the UTF8 character or NULL'/>
<arg name='utf' type='const xmlChar *' info='the input UTF8 *'/>
<arg name='pos' type='int' info='the position of the desired UTF8 char (in chars)'/>
</function>
diff --git a/doc/libxml2-refs.xml b/doc/libxml2-refs.xml
index 6c4e3484..dfa100b5 100644
--- a/doc/libxml2-refs.xml
+++ b/doc/libxml2-refs.xml
@@ -6561,6 +6561,7 @@
<ref name='xmlTextReaderConstValue'/>
<ref name='xmlTextReaderConstXmlLang'/>
<ref name='xmlTextReaderConstXmlVersion'/>
+ <ref name='xmlUTF8Strpos'/>
<ref name='xmlXPathNsLookup'/>
</type>
<type name='const xmlParserNodeInfo *'>
@@ -6802,7 +6803,6 @@
<ref name='xmlURIEscape'/>
<ref name='xmlURIEscapeStr'/>
<ref name='xmlUTF8Strndup'/>
- <ref name='xmlUTF8Strpos'/>
<ref name='xmlUTF8Strsub'/>
<ref name='xmlValidCtxtNormalizeAttributeValue'/>
<ref name='xmlValidNormalizeAttributeValue'/>
diff --git a/elfgcchack.h b/elfgcchack.h
index 2fd2ee47..3f024457 100644
--- a/elfgcchack.h
+++ b/elfgcchack.h
@@ -2154,6 +2154,10 @@ extern __typeof (xmlMallocLoc) xmlMallocLoc__internal_alias __attribute((visibil
extern __typeof (xmlMallocLoc) xmlMallocLoc __attribute((alias("xmlMallocLoc__internal_alias")));
#define xmlMallocLoc xmlMallocLoc__internal_alias
+extern __typeof (xmlMemBlocks) xmlMemBlocks__internal_alias __attribute((visibility("hidden")));
+extern __typeof (xmlMemBlocks) xmlMemBlocks __attribute((alias("xmlMemBlocks__internal_alias")));
+#define xmlMemBlocks xmlMemBlocks__internal_alias
+
extern __typeof (xmlMemDisplay) xmlMemDisplay__internal_alias __attribute((visibility("hidden")));
extern __typeof (xmlMemDisplay) xmlMemDisplay __attribute((alias("xmlMemDisplay__internal_alias")));
#define xmlMemDisplay xmlMemDisplay__internal_alias
diff --git a/gentest.py b/gentest.py
index c74942cf..b7456b18 100755
--- a/gentest.py
+++ b/gentest.py
@@ -22,7 +22,7 @@ skipped_modules = [ "SAX", "SAX2", "xlink", "threads", "globals",
#
skipped_functions = [ "xmlFdRead", "xmlReadFd", "xmlCtxtReadFd",
"htmlFdRead", "htmlReadFd", "htmlCtxtReadFd",
- "xmlCleanupParser" ]
+ "xmlCleanupParser", "xmlStrcat", "xmlStrncat" ]
#
# Those functions have side effect on the global state
@@ -58,6 +58,11 @@ extra_post_call = {
"xmlTextMerge":
"""if ((first != NULL) && (first->type != XML_TEXT_NODE)) {
xmlFreeNode(second) ; second = NULL ; }""",
+ "xmlBuildQName":
+ """if ((ret_val != NULL) && (ret_val != ncname) &&
+ (ret_val != prefix) && (ret_val != memory))
+ xmlFree(ret_val);
+ ret_val = NULL;""",
}
modules = []
@@ -123,6 +128,8 @@ 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) {
@@ -211,6 +218,8 @@ def type_convert(str, name, info, module, function, pos):
return('xmlNanoFTPCtxtPtr')
if module == 'nanohttp' and name == 'ctx':
return('xmlNanoHTTPCtxtPtr')
+ if string.find(name, "data") != -1:
+ return('userdata');
if res == 'xmlNodePtr' and pos != 0:
if (function == 'xmlAddChild' and pos == 2) or \
(function == 'xmlAddChildList' and pos == 2) or \
@@ -226,7 +235,7 @@ def type_convert(str, name, info, module, function, pos):
known_param_types = [ "int", "const_char_ptr", "const_xmlChar_ptr",
"xmlParserCtxtPtr", "xmlDocPtr", "filepath", "fileoutput" ,
- "xmlNodePtr", "xmlNodePtr_in" ];
+ "xmlNodePtr", "xmlNodePtr_in", "userdata", "xmlChar_ptr" ];
def is_known_param_type(name):
for type in known_param_types:
@@ -235,6 +244,17 @@ def is_known_param_type(name):
return 0
test.write("""
+#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) {
@@ -258,6 +278,15 @@ static const char *gen_const_char_ptr(int no) {
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);
+ 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) {
@@ -346,7 +375,8 @@ static void des_xmlNodePtr_in(int no ATTRIBUTE_UNUSED, xmlNodePtr val ATTRIBUTE_
# Provide the type destructors for the return values
#
-known_return_types = [ "int", "const_char_ptr", "xmlDocPtr", "xmlNodePtr" ];
+known_return_types = [ "int", "const_char_ptr", "xmlDocPtr", "xmlNodePtr",
+ "xmlChar_ptr" ];
def is_known_return_type(name):
for type in known_return_types:
@@ -359,6 +389,10 @@ static void desret_int(int val ATTRIBUTE_UNUSED) {
}
static void desret_const_char_ptr(const char *val ATTRIBUTE_UNUSED) {
}
+static void desret_xmlChar_ptr(xmlChar *val) {
+ if (val != NULL)
+ xmlFree(val);
+}
static void desret_xmlDocPtr(xmlDocPtr val) {
xmlFreeDoc(val);
}
@@ -522,7 +556,10 @@ test_%s(void) {
else:
need = 1
test.write("%s" % nam);
- test.write(");\n desret_%s(ret_val);\n" % t_ret[0])
+ test.write(");\n")
+ if extra_post_call.has_key(name):
+ test.write(" %s\n"% (extra_post_call[name]))
+ test.write(" desret_%s(ret_val);\n" % t_ret[0])
else:
test.write("\n %s(" % (name));
need = 0;
@@ -534,10 +571,10 @@ test_%s(void) {
need = 1
test.write("%s" % nam)
test.write(");\n")
- test.write(" call_tests++;\n");
+ if extra_post_call.has_key(name):
+ test.write(" %s\n"% (extra_post_call[name]))
- if extra_post_call.has_key(name):
- test.write(" %s\n"% (extra_post_call[name]))
+ test.write(" call_tests++;\n");
# Free the arguments
for arg in t_args:
diff --git a/include/libxml/xmlstring.h b/include/libxml/xmlstring.h
index 74ae4050..39f846e2 100644
--- a/include/libxml/xmlstring.h
+++ b/include/libxml/xmlstring.h
@@ -117,7 +117,7 @@ XMLPUBFUN int XMLCALL
XMLPUBFUN xmlChar * XMLCALL
xmlUTF8Strndup (const xmlChar *utf,
int len);
-XMLPUBFUN xmlChar * XMLCALL
+XMLPUBFUN const xmlChar * XMLCALL
xmlUTF8Strpos (const xmlChar *utf,
int pos);
XMLPUBFUN int XMLCALL
diff --git a/testapi.c b/testapi.c
index 75faa00e..19142a03 100644
--- a/testapi.c
+++ b/testapi.c
@@ -16,6 +16,9 @@ static int testlibxml2(void);
static int generic_errors = 0;
static int call_tests = 0;
+static xmlChar chartab[1024] = " chartab
+";
+
static void
structured_errors(void *userData ATTRIBUTE_UNUSED,
xmlErrorPtr error ATTRIBUTE_UNUSED) {
@@ -112,6 +115,17 @@ 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) {
@@ -135,6 +149,15 @@ static const char *gen_const_char_ptr(int no) {
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);
+ 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) {
@@ -222,6 +245,10 @@ static void desret_int(int val ATTRIBUTE_UNUSED) {
}
static void desret_const_char_ptr(const char *val ATTRIBUTE_UNUSED) {
}
+static void desret_xmlChar_ptr(xmlChar *val) {
+ if (val != NULL)
+ xmlFree(val);
+}
static void desret_xmlDocPtr(xmlDocPtr val) {
xmlFreeDoc(val);
}
@@ -892,8 +919,38 @@ 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
- /* missing type support */
return(ret);
}
@@ -1988,8 +2045,38 @@ 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
- /* missing type support */
return(ret);
}
@@ -1998,8 +2085,31 @@ 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
- /* missing type support */
return(ret);
}
@@ -2008,8 +2118,31 @@ 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
- /* missing type support */
return(ret);
}
@@ -2018,8 +2151,31 @@ 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
- /* missing type support */
return(ret);
}
@@ -2855,8 +3011,36 @@ 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");
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -2865,8 +3049,36 @@ 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");
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -4745,8 +4957,29 @@ 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");
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -5184,8 +5417,29 @@ 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");
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -5829,9 +6083,9 @@ test_xmlAddChild(void) {
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++;
- if (ret_val == NULL) { xmlFreeNode(cur) ; cur = NULL ; }
des_xmlNodePtr(n_parent, parent);
des_xmlNodePtr_in(n_cur, cur);
xmlResetLastError();
@@ -5868,9 +6122,9 @@ test_xmlAddChildList(void) {
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++;
- if (ret_val == NULL) { xmlFreeNodeList(cur) ; cur = NULL ; }
des_xmlNodePtr(n_parent, parent);
des_xmlNodePtr_in(n_cur, cur);
xmlResetLastError();
@@ -5907,9 +6161,9 @@ test_xmlAddNextSibling(void) {
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++;
- if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
des_xmlNodePtr(n_cur, cur);
des_xmlNodePtr_in(n_elem, elem);
xmlResetLastError();
@@ -5947,9 +6201,9 @@ test_xmlAddPrevSibling(void) {
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++;
- if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
des_xmlNodePtr(n_cur, cur);
des_xmlNodePtr_in(n_elem, elem);
xmlResetLastError();
@@ -5987,9 +6241,9 @@ test_xmlAddSibling(void) {
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++;
- if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
des_xmlNodePtr(n_cur, cur);
des_xmlNodePtr_in(n_elem, elem);
xmlResetLastError();
@@ -6202,8 +6456,54 @@ 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");
+ }
+ }
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -6458,9 +6758,9 @@ test_xmlDocSetRootElement(void) {
root = gen_xmlNodePtr_in(n_root);
ret_val = xmlDocSetRootElement(doc, root);
+ if (doc == NULL) { xmlFreeNode(root) ; root = NULL ; }
desret_xmlNodePtr(ret_val);
call_tests++;
- if (doc == NULL) { xmlFreeNode(root) ; root = NULL ; }
des_xmlDocPtr(n_doc, doc);
des_xmlNodePtr_in(n_root, root);
xmlResetLastError();
@@ -6610,8 +6910,36 @@ 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");
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -6620,8 +6948,31 @@ 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
- /* missing type support */
return(ret);
}
@@ -6640,8 +6991,43 @@ 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");
+ }
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -6650,8 +7036,36 @@ 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");
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -7487,8 +7901,36 @@ 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");
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -7497,8 +7939,29 @@ 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");
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -7507,8 +7970,29 @@ 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");
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -7579,8 +8063,45 @@ 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
- /* missing type support */
return(ret);
}
@@ -7589,8 +8110,43 @@ 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");
+ }
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -7895,10 +8451,10 @@ test_xmlReplaceNode(void) {
cur = gen_xmlNodePtr_in(n_cur);
ret_val = xmlReplaceNode(old, cur);
- desret_xmlNodePtr(ret_val);
- call_tests++;
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();
@@ -8489,10 +9045,10 @@ test_xmlTextMerge(void) {
second = gen_xmlNodePtr_in(n_second);
ret_val = xmlTextMerge(first, second);
- desret_xmlNodePtr(ret_val);
- call_tests++;
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();
@@ -8893,8 +9449,36 @@ 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");
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -8903,8 +9487,36 @@ 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");
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -8913,8 +9525,29 @@ 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");
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -8983,8 +9616,29 @@ 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");
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -8993,8 +9647,36 @@ 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");
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -9433,8 +10115,52 @@ 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
- /* missing type support */
return(ret);
}
@@ -10321,8 +11047,29 @@ 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");
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -12339,8 +13086,31 @@ 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
- /* missing type support */
return(ret);
}
@@ -12522,8 +13292,29 @@ 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");
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -12532,8 +13323,36 @@ 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");
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -12710,16 +13529,6 @@ test_xmlStrcasestr(void) {
static int
-test_xmlStrcat(void) {
- int ret = 0;
-
-
- /* missing type support */
- return(ret);
-}
-
-
-static int
test_xmlStrchr(void) {
int ret = 0;
@@ -12771,8 +13580,29 @@ 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");
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -12854,21 +13684,46 @@ test_xmlStrncasecmp(void) {
static int
-test_xmlStrncat(void) {
+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;
- /* missing type support */
- return(ret);
-}
-
-
-static int
-test_xmlStrncatNew(void) {
- int ret = 0;
+ 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");
+ }
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -12922,8 +13777,36 @@ 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");
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -12942,8 +13825,43 @@ 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");
+ }
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -13090,8 +14008,36 @@ 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");
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -13148,8 +14094,43 @@ 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");
+ }
+ }
+ }
+ }
- /* missing type support */
return(ret);
}
@@ -13168,13 +14149,11 @@ test_xmlstring(void) {
ret += test_xmlStrVPrintf();
ret += test_xmlStrcasecmp();
ret += test_xmlStrcasestr();
- ret += test_xmlStrcat();
ret += test_xmlStrchr();
ret += test_xmlStrcmp();
ret += test_xmlStrdup();
ret += test_xmlStrlen();
ret += test_xmlStrncasecmp();
- ret += test_xmlStrncat();
ret += test_xmlStrncatNew();
ret += test_xmlStrncmp();
ret += test_xmlStrndup();
@@ -14076,8 +15055,31 @@ 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
- /* missing type support */
return(ret);
}
@@ -14126,8 +15128,31 @@ 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
- /* missing type support */
return(ret);
}
diff --git a/win32/libxml2.def.src b/win32/libxml2.def.src
index 2b9f6e08..05850f24 100644
--- a/win32/libxml2.def.src
+++ b/win32/libxml2.def.src
@@ -976,6 +976,7 @@ xmlMallocAtomicLoc
#ifdef DEBUG_MEMORY_LOCATION
xmlMallocLoc
#endif
+xmlMemBlocks
xmlMemDisplay
xmlMemFree
xmlMemGet
diff --git a/xmlstring.c b/xmlstring.c
index 15ca76c8..78acbff7 100644
--- a/xmlstring.c
+++ b/xmlstring.c
@@ -478,6 +478,8 @@ xmlStrncatNew(const xmlChar *str1, const xmlChar *str2, int len) {
int size;
xmlChar *ret;
+ if (len < 0)
+ len = xmlStrlen(str2);
if ((str2 == NULL) || (len == 0))
return(xmlStrdup(str1));
if (str1 == NULL)
@@ -869,7 +871,7 @@ xmlUTF8Strndup(const xmlChar *utf, int len) {
*
* Returns a pointer to the UTF8 character or NULL
*/
-xmlChar *
+const xmlChar *
xmlUTF8Strpos(const xmlChar *utf, int pos) {
xmlChar ch;
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-07 16:53:26 +0000