--- embedaddon/libxml2/testapi.c 2013/07/22 01:22:20 1.1.1.2 +++ embedaddon/libxml2/testapi.c 2014/06/15 19:53:30 1.1.1.3 @@ -8,20 +8,14 @@ * daniel@veillard.com */ -#ifdef HAVE_CONFIG_H #include "libxml.h" -#else #include -#endif #include /* for putenv() */ #include #include #include -#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__MINGW32__) -#define snprintf _snprintf -#endif static int testlibxml2(void); static int test_module(const char *module); @@ -107,7 +101,7 @@ get_api_attr(void) { if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) { get_api_root(); } - if (api_root == NULL) + if (api_root == NULL) return(NULL); if (api_root->properties != NULL) { api_attr = api_root->properties; @@ -127,8 +121,10 @@ int main(int argc, char **argv) { int ret; int blocks, mem; +#ifdef HAVE_PUTENV /* access to the proxy can slow up regression tests a lot */ putenv((char *) "http_proxy="); +#endif memset(chartab, 0, sizeof(chartab)); strncpy((char *) chartab, " chartab\n", 20); @@ -201,7 +197,7 @@ int main(int argc, char **argv) { #include #include -/* +/* We manually define xmlErrMemory because it's normal declaration is "hidden" by #ifdef IN_LIBXML */ @@ -291,7 +287,7 @@ static void des_long(int no ATTRIBUTE_UNUSED, long val static xmlChar gen_xmlChar(int no, int nr ATTRIBUTE_UNUSED) { if (no == 0) return('a'); if (no == 1) return(' '); - if (no == 2) return((xmlChar) 'ø'); + if (no == 2) return((xmlChar) '\xf8'); return(0); } @@ -399,7 +395,7 @@ static void des_debug_FILE_ptr(int no ATTRIBUTE_UNUSED static xmlChar *gen_const_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) { if (no == 0) return((xmlChar *) "foo"); if (no == 1) return((xmlChar *) ""); - if (no == 2) return((xmlChar *) "nøne"); + if (no == 2) return((xmlChar *) "n" "\xf8" "ne"); if (no == 3) return((xmlChar *) " 2ab "); return(NULL); } @@ -543,7 +539,7 @@ static void des_xmlNodePtr(int no, xmlNodePtr val, int #define gen_nb_xmlDtdPtr 3 static xmlDtdPtr gen_xmlDtdPtr(int no, int nr ATTRIBUTE_UNUSED) { - if (no == 0) + if (no == 0) return(xmlNewDtd(NULL, BAD_CAST "dtd", BAD_CAST"foo", BAD_CAST"bar")); if (no == 1) return(get_api_dtd()); return(NULL); @@ -740,7 +736,7 @@ static void des_xmlSchemaValidCtxtPtr(int no ATTRIBUTE #endif /* LIBXML_SCHEMAS_ENABLED */ #define gen_nb_xmlHashDeallocator 2 -static void +static void test_xmlHashDeallocator(void *payload ATTRIBUTE_UNUSED, xmlChar *name ATTRIBUTE_UNUSED) { } @@ -8252,6 +8248,16 @@ test_xmlDictExists(void) { static int +test_xmlDictGetUsage(void) { + int test_ret = 0; + + + /* missing type support */ + return(test_ret); +} + + +static int test_xmlDictLookup(void) { int test_ret = 0; @@ -8416,6 +8422,16 @@ test_xmlDictReference(void) { static int +test_xmlDictSetLimit(void) { + int test_ret = 0; + + + /* missing type support */ + return(test_ret); +} + + +static int test_xmlDictSize(void) { int test_ret = 0; @@ -8475,15 +8491,17 @@ static int test_dict(void) { int test_ret = 0; - if (quiet == 0) printf("Testing dict : 10 of 11 functions ...\n"); + if (quiet == 0) printf("Testing dict : 10 of 13 functions ...\n"); test_ret += test_xmlDictCleanup(); test_ret += test_xmlDictCreate(); test_ret += test_xmlDictCreateSub(); test_ret += test_xmlDictExists(); + test_ret += test_xmlDictGetUsage(); test_ret += test_xmlDictLookup(); test_ret += test_xmlDictOwns(); test_ret += test_xmlDictQLookup(); test_ret += test_xmlDictReference(); + test_ret += test_xmlDictSetLimit(); test_ret += test_xmlDictSize(); test_ret += test_xmlInitializeDict(); @@ -17814,7 +17832,7 @@ test_xmlRelaxNGValidatePushCData(void) { int n_ctxt; xmlChar * data; /* some character data read */ int n_data; - int len; /* the lenght of the data */ + int len; /* the length of the data */ int n_len; for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) { @@ -18385,7 +18403,154 @@ test_xmlAttrSerializeTxtContent(void) { } +#define gen_nb_const_xmlBufPtr 1 +static xmlBufPtr gen_const_xmlBufPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { + return(NULL); +} +static void des_const_xmlBufPtr(int no ATTRIBUTE_UNUSED, const xmlBufPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { +} + static int +test_xmlBufContent(void) { + int test_ret = 0; + + int mem_base; + xmlChar * ret_val; + xmlBufPtr buf; /* the buffer */ + int n_buf; + + for (n_buf = 0;n_buf < gen_nb_const_xmlBufPtr;n_buf++) { + mem_base = xmlMemBlocks(); + buf = gen_const_xmlBufPtr(n_buf, 0); + + ret_val = xmlBufContent((const xmlBufPtr)buf); + desret_xmlChar_ptr(ret_val); + call_tests++; + des_const_xmlBufPtr(n_buf, (const xmlBufPtr)buf, 0); + xmlResetLastError(); + if (mem_base != xmlMemBlocks()) { + printf("Leak of %d blocks found in xmlBufContent", + xmlMemBlocks() - mem_base); + test_ret++; + printf(" %d", n_buf); + printf("\n"); + } + } + function_tests++; + + return(test_ret); +} + + +static int +test_xmlBufEnd(void) { + int test_ret = 0; + + int mem_base; + xmlChar * ret_val; + xmlBufPtr buf; /* the buffer */ + int n_buf; + + for (n_buf = 0;n_buf < gen_nb_const_xmlBufPtr;n_buf++) { + mem_base = xmlMemBlocks(); + buf = gen_const_xmlBufPtr(n_buf, 0); + + ret_val = xmlBufEnd((const xmlBufPtr)buf); + desret_xmlChar_ptr(ret_val); + call_tests++; + des_const_xmlBufPtr(n_buf, (const xmlBufPtr)buf, 0); + xmlResetLastError(); + if (mem_base != xmlMemBlocks()) { + printf("Leak of %d blocks found in xmlBufEnd", + xmlMemBlocks() - mem_base); + test_ret++; + printf(" %d", n_buf); + printf("\n"); + } + } + function_tests++; + + return(test_ret); +} + + +#define gen_nb_xmlBufPtr 1 +static xmlBufPtr gen_xmlBufPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { + return(NULL); +} +static void des_xmlBufPtr(int no ATTRIBUTE_UNUSED, xmlBufPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) { +} + +static int +test_xmlBufGetNodeContent(void) { + int test_ret = 0; + + int mem_base; + int ret_val; + xmlBufPtr buf; /* a buffer xmlBufPtr */ + int n_buf; + xmlNodePtr cur; /* the node being read */ + int n_cur; + + for (n_buf = 0;n_buf < gen_nb_xmlBufPtr;n_buf++) { + for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) { + mem_base = xmlMemBlocks(); + buf = gen_xmlBufPtr(n_buf, 0); + cur = gen_xmlNodePtr(n_cur, 1); + + ret_val = xmlBufGetNodeContent(buf, cur); + desret_int(ret_val); + call_tests++; + des_xmlBufPtr(n_buf, buf, 0); + des_xmlNodePtr(n_cur, cur, 1); + xmlResetLastError(); + if (mem_base != xmlMemBlocks()) { + printf("Leak of %d blocks found in xmlBufGetNodeContent", + xmlMemBlocks() - mem_base); + test_ret++; + printf(" %d", n_buf); + printf(" %d", n_cur); + printf("\n"); + } + } + } + function_tests++; + + return(test_ret); +} + + +static int +test_xmlBufNodeDump(void) { + int test_ret = 0; + + + /* missing type support */ + return(test_ret); +} + + +static int +test_xmlBufShrink(void) { + int test_ret = 0; + + + /* missing type support */ + return(test_ret); +} + + +static int +test_xmlBufUse(void) { + int test_ret = 0; + + + /* missing type support */ + return(test_ret); +} + + +static int test_xmlBufferAdd(void) { int test_ret = 0; @@ -24015,13 +24180,19 @@ static int test_tree(void) { int test_ret = 0; - if (quiet == 0) printf("Testing tree : 139 of 158 functions ...\n"); + if (quiet == 0) printf("Testing tree : 142 of 164 functions ...\n"); test_ret += test_xmlAddChild(); test_ret += test_xmlAddChildList(); test_ret += test_xmlAddNextSibling(); test_ret += test_xmlAddPrevSibling(); test_ret += test_xmlAddSibling(); test_ret += test_xmlAttrSerializeTxtContent(); + test_ret += test_xmlBufContent(); + test_ret += test_xmlBufEnd(); + test_ret += test_xmlBufGetNodeContent(); + test_ret += test_xmlBufNodeDump(); + test_ret += test_xmlBufShrink(); + test_ret += test_xmlBufUse(); test_ret += test_xmlBufferAdd(); test_ret += test_xmlBufferAddHead(); test_ret += test_xmlBufferCCat(); @@ -26923,7 +27094,7 @@ test_xmlValidatePushCData(void) { int n_ctxt; xmlChar * data; /* some character data read */ int n_data; - int len; /* the lenght of the data */ + int len; /* the length of the data */ int n_len; for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) { @@ -28405,6 +28576,50 @@ test_xmlOutputBufferFlush(void) { static int +test_xmlOutputBufferGetContent(void) { + int test_ret = 0; + +#if defined(LIBXML_OUTPUT_ENABLED) + int mem_base; + const xmlChar * ret_val; + xmlOutputBufferPtr out; /* an xmlOutputBufferPtr */ + int n_out; + + for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) { + mem_base = xmlMemBlocks(); + out = gen_xmlOutputBufferPtr(n_out, 0); + + ret_val = xmlOutputBufferGetContent(out); + desret_const_xmlChar_ptr(ret_val); + call_tests++; + des_xmlOutputBufferPtr(n_out, out, 0); + xmlResetLastError(); + if (mem_base != xmlMemBlocks()) { + printf("Leak of %d blocks found in xmlOutputBufferGetContent", + xmlMemBlocks() - mem_base); + test_ret++; + printf(" %d", n_out); + printf("\n"); + } + } + function_tests++; +#endif + + return(test_ret); +} + + +static int +test_xmlOutputBufferGetSize(void) { + int test_ret = 0; + + + /* missing type support */ + return(test_ret); +} + + +static int test_xmlOutputBufferWrite(void) { int test_ret = 0; @@ -28948,7 +29163,7 @@ static int test_xmlIO(void) { int test_ret = 0; - if (quiet == 0) printf("Testing xmlIO : 39 of 48 functions ...\n"); + if (quiet == 0) printf("Testing xmlIO : 40 of 50 functions ...\n"); test_ret += test_xmlAllocOutputBuffer(); test_ret += test_xmlAllocParserInputBuffer(); test_ret += test_xmlCheckFilename(); @@ -28974,6 +29189,8 @@ test_xmlIO(void) { test_ret += test_xmlOutputBufferCreateFile(); test_ret += test_xmlOutputBufferCreateFilename(); test_ret += test_xmlOutputBufferFlush(); + test_ret += test_xmlOutputBufferGetContent(); + test_ret += test_xmlOutputBufferGetSize(); test_ret += test_xmlOutputBufferWrite(); test_ret += test_xmlOutputBufferWriteEscape(); test_ret += test_xmlOutputBufferWriteString(); @@ -32950,7 +33167,7 @@ test_xmlExpGetLanguage(void) { int n_exp; xmlChar ** langList; /* where to store the tokens */ int n_langList; - int len; /* the allocated lenght of @list */ + int len; /* the allocated length of @list */ int n_len; for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) { @@ -33005,7 +33222,7 @@ test_xmlExpGetStart(void) { int n_exp; xmlChar ** tokList; /* where to store the tokens */ int n_tokList; - int len; /* the allocated lenght of @list */ + int len; /* the allocated length of @list */ int n_len; for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) { @@ -34604,6 +34821,55 @@ test_xmlSchemaValidateOneElement(void) { static int +test_xmlSchemaValidateSetFilename(void) { + int test_ret = 0; + +#if defined(LIBXML_SCHEMAS_ENABLED) + int mem_base; + xmlSchemaValidCtxtPtr vctxt; /* the schema validation context */ + int n_vctxt; + const char * filename; /* the file name */ + int n_filename; + + for (n_vctxt = 0;n_vctxt < gen_nb_xmlSchemaValidCtxtPtr;n_vctxt++) { + for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) { + mem_base = xmlMemBlocks(); + vctxt = gen_xmlSchemaValidCtxtPtr(n_vctxt, 0); + filename = gen_filepath(n_filename, 1); + + xmlSchemaValidateSetFilename(vctxt, filename); + call_tests++; + des_xmlSchemaValidCtxtPtr(n_vctxt, vctxt, 0); + des_filepath(n_filename, filename, 1); + xmlResetLastError(); + if (mem_base != xmlMemBlocks()) { + printf("Leak of %d blocks found in xmlSchemaValidateSetFilename", + xmlMemBlocks() - mem_base); + test_ret++; + printf(" %d", n_vctxt); + printf(" %d", n_filename); + printf("\n"); + } + } + } + function_tests++; +#endif + + return(test_ret); +} + + +static int +test_xmlSchemaValidateSetLocator(void) { + int test_ret = 0; + + + /* missing type support */ + return(test_ret); +} + + +static int test_xmlSchemaValidateStream(void) { int test_ret = 0; @@ -34668,7 +34934,7 @@ static int test_xmlschemas(void) { int test_ret = 0; - if (quiet == 0) printf("Testing xmlschemas : 15 of 25 functions ...\n"); + if (quiet == 0) printf("Testing xmlschemas : 16 of 27 functions ...\n"); test_ret += test_xmlSchemaDump(); test_ret += test_xmlSchemaGetParserErrors(); test_ret += test_xmlSchemaGetValidErrors(); @@ -34690,6 +34956,8 @@ test_xmlschemas(void) { test_ret += test_xmlSchemaValidateDoc(); test_ret += test_xmlSchemaValidateFile(); test_ret += test_xmlSchemaValidateOneElement(); + test_ret += test_xmlSchemaValidateSetFilename(); + test_ret += test_xmlSchemaValidateSetLocator(); test_ret += test_xmlSchemaValidateStream(); if (test_ret != 0) @@ -43571,6 +43839,47 @@ test_xmlTextWriterSetIndentString(void) { static int +test_xmlTextWriterSetQuoteChar(void) { + int test_ret = 0; + +#if defined(LIBXML_WRITER_ENABLED) + int mem_base; + int ret_val; + xmlTextWriterPtr writer; /* the xmlTextWriterPtr */ + int n_writer; + xmlChar quotechar; /* the quote character */ + int n_quotechar; + + for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) { + for (n_quotechar = 0;n_quotechar < gen_nb_xmlChar;n_quotechar++) { + mem_base = xmlMemBlocks(); + writer = gen_xmlTextWriterPtr(n_writer, 0); + quotechar = gen_xmlChar(n_quotechar, 1); + + ret_val = xmlTextWriterSetQuoteChar(writer, quotechar); + desret_int(ret_val); + call_tests++; + des_xmlTextWriterPtr(n_writer, writer, 0); + des_xmlChar(n_quotechar, quotechar, 1); + xmlResetLastError(); + if (mem_base != xmlMemBlocks()) { + printf("Leak of %d blocks found in xmlTextWriterSetQuoteChar", + xmlMemBlocks() - mem_base); + test_ret++; + printf(" %d", n_writer); + printf(" %d", n_quotechar); + printf("\n"); + } + } + } + function_tests++; +#endif + + return(test_ret); +} + + +static int test_xmlTextWriterStartAttribute(void) { int test_ret = 0; @@ -45432,7 +45741,7 @@ static int test_xmlwriter(void) { int test_ret = 0; - if (quiet == 0) printf("Testing xmlwriter : 51 of 79 functions ...\n"); + if (quiet == 0) printf("Testing xmlwriter : 52 of 80 functions ...\n"); test_ret += test_xmlNewTextWriter(); test_ret += test_xmlNewTextWriterFilename(); test_ret += test_xmlNewTextWriterMemory(); @@ -45452,6 +45761,7 @@ test_xmlwriter(void) { test_ret += test_xmlTextWriterFullEndElement(); test_ret += test_xmlTextWriterSetIndent(); test_ret += test_xmlTextWriterSetIndentString(); + test_ret += test_xmlTextWriterSetQuoteChar(); test_ret += test_xmlTextWriterStartAttribute(); test_ret += test_xmlTextWriterStartAttributeNS(); test_ret += test_xmlTextWriterStartCDATA(); @@ -46542,6 +46852,54 @@ test_xmlXPathNewContext(void) { static int +test_xmlXPathNodeEval(void) { + int test_ret = 0; + +#if defined(LIBXML_XPATH_ENABLED) + int mem_base; + xmlXPathObjectPtr ret_val; + xmlNodePtr node; /* the node to to use as the context node */ + int n_node; + xmlChar * str; /* the XPath expression */ + int n_str; + xmlXPathContextPtr ctx; /* the XPath context */ + int n_ctx; + + for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { + for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) { + for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) { + mem_base = xmlMemBlocks(); + node = gen_xmlNodePtr(n_node, 0); + str = gen_const_xmlChar_ptr(n_str, 1); + ctx = gen_xmlXPathContextPtr(n_ctx, 2); + + ret_val = xmlXPathNodeEval(node, (const xmlChar *)str, ctx); + desret_xmlXPathObjectPtr(ret_val); + call_tests++; + des_xmlNodePtr(n_node, node, 0); + des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1); + des_xmlXPathContextPtr(n_ctx, ctx, 2); + xmlResetLastError(); + if (mem_base != xmlMemBlocks()) { + printf("Leak of %d blocks found in xmlXPathNodeEval", + xmlMemBlocks() - mem_base); + test_ret++; + printf(" %d", n_node); + printf(" %d", n_str); + printf(" %d", n_ctx); + printf("\n"); + } + } + } + } + function_tests++; +#endif + + return(test_ret); +} + + +static int test_xmlXPathNodeSetCreate(void) { int test_ret = 0; @@ -46642,11 +47000,52 @@ test_xmlXPathOrderDocElems(void) { return(test_ret); } + static int +test_xmlXPathSetContextNode(void) { + int test_ret = 0; + +#if defined(LIBXML_XPATH_ENABLED) + int mem_base; + int ret_val; + xmlNodePtr node; /* the node to to use as the context node */ + int n_node; + xmlXPathContextPtr ctx; /* the XPath context */ + int n_ctx; + + for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) { + for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) { + mem_base = xmlMemBlocks(); + node = gen_xmlNodePtr(n_node, 0); + ctx = gen_xmlXPathContextPtr(n_ctx, 1); + + ret_val = xmlXPathSetContextNode(node, ctx); + desret_int(ret_val); + call_tests++; + des_xmlNodePtr(n_node, node, 0); + des_xmlXPathContextPtr(n_ctx, ctx, 1); + xmlResetLastError(); + if (mem_base != xmlMemBlocks()) { + printf("Leak of %d blocks found in xmlXPathSetContextNode", + xmlMemBlocks() - mem_base); + test_ret++; + printf(" %d", n_node); + printf(" %d", n_ctx); + printf("\n"); + } + } + } + function_tests++; +#endif + + return(test_ret); +} + +static int test_xpath(void) { int test_ret = 0; - if (quiet == 0) printf("Testing xpath : 30 of 38 functions ...\n"); + if (quiet == 0) printf("Testing xpath : 32 of 40 functions ...\n"); test_ret += test_xmlXPathCastBooleanToNumber(); test_ret += test_xmlXPathCastBooleanToString(); test_ret += test_xmlXPathCastNodeSetToBoolean(); @@ -46677,9 +47076,11 @@ test_xpath(void) { test_ret += test_xmlXPathIsInf(); test_ret += test_xmlXPathIsNaN(); test_ret += test_xmlXPathNewContext(); + test_ret += test_xmlXPathNodeEval(); test_ret += test_xmlXPathNodeSetCreate(); test_ret += test_xmlXPathObjectCopy(); test_ret += test_xmlXPathOrderDocElems(); + test_ret += test_xmlXPathSetContextNode(); if (test_ret != 0) printf("Module xpath: %d errors\n", test_ret); @@ -48815,6 +49216,7 @@ test_xmlXPathNodeSetAdd(void) { #if defined(LIBXML_XPATH_ENABLED) int mem_base; + int ret_val; xmlNodeSetPtr cur; /* the initial node set */ int n_cur; xmlNodePtr val; /* a new xmlNodePtr */ @@ -48826,7 +49228,8 @@ test_xmlXPathNodeSetAdd(void) { cur = gen_xmlNodeSetPtr(n_cur, 0); val = gen_xmlNodePtr(n_val, 1); - xmlXPathNodeSetAdd(cur, val); + ret_val = xmlXPathNodeSetAdd(cur, val); + desret_int(ret_val); call_tests++; des_xmlNodeSetPtr(n_cur, cur, 0); des_xmlNodePtr(n_val, val, 1); @@ -48854,6 +49257,7 @@ test_xmlXPathNodeSetAddNs(void) { #if defined(LIBXML_XPATH_ENABLED) int mem_base; + int ret_val; xmlNodeSetPtr cur; /* the initial node set */ int n_cur; xmlNodePtr node; /* the hosting node */ @@ -48869,7 +49273,8 @@ test_xmlXPathNodeSetAddNs(void) { node = gen_xmlNodePtr(n_node, 1); ns = gen_xmlNsPtr(n_ns, 2); - xmlXPathNodeSetAddNs(cur, node, ns); + ret_val = xmlXPathNodeSetAddNs(cur, node, ns); + desret_int(ret_val); call_tests++; des_xmlNodeSetPtr(n_cur, cur, 0); des_xmlNodePtr(n_node, node, 1); @@ -48900,6 +49305,7 @@ test_xmlXPathNodeSetAddUnique(void) { #if defined(LIBXML_XPATH_ENABLED) int mem_base; + int ret_val; xmlNodeSetPtr cur; /* the initial node set */ int n_cur; xmlNodePtr val; /* a new xmlNodePtr */ @@ -48911,7 +49317,8 @@ test_xmlXPathNodeSetAddUnique(void) { cur = gen_xmlNodeSetPtr(n_cur, 0); val = gen_xmlNodePtr(n_val, 1); - xmlXPathNodeSetAddUnique(cur, val); + ret_val = xmlXPathNodeSetAddUnique(cur, val); + desret_int(ret_val); call_tests++; des_xmlNodeSetPtr(n_cur, cur, 0); des_xmlNodePtr(n_val, val, 1);