poky/meta/recipes-core/libxml/libxml2/runtest.patch

From 6172ccd1e74bc181f5298f19e240234e12876abe Mon Sep 17 00:00:00 2001
From: Tony Tascioglu <tony.tascioglu@windriver.com>
Date: Tue, 11 May 2021 11:57:46 -0400
Subject: [PATCH] Add 'install-ptest' rule.

Print a standard result line for each test.

The patch needs a rework according to comments in the merge request.

Signed-off-by: Mihaela Sendrea <mihaela.sendrea@enea.com>
Signed-off-by: Andrej Valek <andrej.valek@siemens.com>
Upstream-Status: Inappropriate [https://gitlab.gnome.org/GNOME/libxml2/-/merge_requests/137]

Signed-off-by: Hongxu Jia <hongxu.jia@windriver.com>
Signed-off-by: Tony Tascioglu <tony.tascioglu@windriver.com>
---
 Makefile.am   |   9 +++
 runsuite.c    |   1 +
 runtest.c     |   2 +
 runxmlconf.c  |   1 +
 testapi.c     | 122 ++++++++++++++++++++++++++-------------
 testchar.c    | 156 +++++++++++++++++++++++++++++++++++---------------
 testdict.c    |   1 +
 testlimits.c  |   1 +
 testrecurse.c |   2 +
 9 files changed, 210 insertions(+), 85 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index 05d1671f..ae622745 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -198,6 +198,15 @@ runxmlconf_LDADD= $(LDADDS)
 #testOOM_DEPENDENCIES = $(DEPS)
 #testOOM_LDADD= $(LDADDS)
 
+install-ptest:
+	@(if [ -d .libs ] ; then cd .libs; fi; \
+	install $(check_PROGRAMS) $(DESTDIR))
+	cp -r $(srcdir)/test $(DESTDIR)
+	cp -r $(srcdir)/result $(DESTDIR)
+	cp -r $(srcdir)/python $(DESTDIR)
+	cp Makefile $(DESTDIR)
+	sed -i -e 's|^Makefile:|_Makefile:|' $(DESTDIR)/Makefile
+
 runtests: runtest$(EXEEXT) testrecurse$(EXEEXT) testapi$(EXEEXT) \
           testchar$(EXEEXT) testdict$(EXEEXT) runxmlconf$(EXEEXT)
 	[ -d test   ] || $(LN_S) $(srcdir)/test   .
diff --git a/runsuite.c b/runsuite.c
index d24b5ec3..f7ff2521 100644
--- a/runsuite.c
+++ b/runsuite.c
@@ -1147,6 +1147,7 @@ main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
 
     if (logfile != NULL)
         fclose(logfile);
+    printf("%s: runsuite\n\n", (ret == 0) ? "PASS" : "FAIL");
     return(ret);
 }
 #else /* !SCHEMAS */
diff --git a/runtest.c b/runtest.c
index ffa98d04..470f95cb 100644
--- a/runtest.c
+++ b/runtest.c
@@ -4508,6 +4508,7 @@ launchTests(testDescPtr tst) {
     xmlCharEncCloseFunc(ebcdicHandler);
     xmlCharEncCloseFunc(eucJpHandler);
 
+    printf("%s: %s\n", (err == 0) ? "PASS" : "FAIL", tst->desc);
     return(err);
 }
 
@@ -4588,6 +4589,7 @@ main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
     xmlCleanupParser();
     xmlMemoryDump();
 
+    printf("%s: runtest\n\n", (ret == 0) ? "PASS" : "FAIL");
     return(ret);
 }
 
diff --git a/runxmlconf.c b/runxmlconf.c
index 70f61017..e882b3a1 100644
--- a/runxmlconf.c
+++ b/runxmlconf.c
@@ -595,6 +595,7 @@ main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
 
     if (logfile != NULL)
         fclose(logfile);
+    printf("%s: runxmlconf\n", (ret == 0) ? "PASS" : "FAIL");
     return(ret);
 }
 
diff --git a/testapi.c b/testapi.c
index ff8b470d..52b51d78 100644
--- a/testapi.c
+++ b/testapi.c
@@ -1246,49 +1246,91 @@ static int
 testlibxml2(void)
 {
     int test_ret = 0;
-
-    test_ret += test_HTMLparser();
-    test_ret += test_HTMLtree();
-    test_ret += test_SAX2();
-    test_ret += test_c14n();
-    test_ret += test_catalog();
-    test_ret += test_chvalid();
-    test_ret += test_debugXML();
-    test_ret += test_dict();
-    test_ret += test_encoding();
-    test_ret += test_entities();
-    test_ret += test_hash();
-    test_ret += test_list();
-    test_ret += test_nanoftp();
-    test_ret += test_nanohttp();
-    test_ret += test_parser();
-    test_ret += test_parserInternals();
-    test_ret += test_pattern();
-    test_ret += test_relaxng();
-    test_ret += test_schemasInternals();
-    test_ret += test_schematron();
-    test_ret += test_tree();
-    test_ret += test_uri();
-    test_ret += test_valid();
-    test_ret += test_xinclude();
-    test_ret += test_xmlIO();
-    test_ret += test_xmlautomata();
-    test_ret += test_xmlerror();
-    test_ret += test_xmlmodule();
-    test_ret += test_xmlreader();
-    test_ret += test_xmlregexp();
-    test_ret += test_xmlsave();
-    test_ret += test_xmlschemas();
-    test_ret += test_xmlschemastypes();
-    test_ret += test_xmlstring();
-    test_ret += test_xmlunicode();
-    test_ret += test_xmlwriter();
-    test_ret += test_xpath();
-    test_ret += test_xpathInternals();
-    test_ret += test_xpointer();
+    int ret = 0;
+
+    test_ret += (ret = test_HTMLparser());
+    printf("%s: HTMLparser\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_HTMLtree());
+    printf("%s: HTMLtree\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_SAX2());
+    printf("%s: SAX2\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_c14n());
+    printf("%s: c14n\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_catalog());
+    printf("%s: catalog\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_chvalid());
+    printf("%s: chvalid\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_debugXML());
+    printf("%s: debugXML\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_dict());
+    printf("%s: dict\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_encoding());
+    printf("%s: encoding\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_entities());
+    printf("%s: entities\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_hash());
+    printf("%s: hash\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_list());
+    printf("%s: list\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_nanoftp());
+    printf("%s: nanoftp\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_nanohttp());
+    printf("%s: nanohttp\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_parser());
+    printf("%s: parser\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_parserInternals());
+    printf("%s: parserInternals\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_pattern());
+    printf("%s: pattern\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_relaxng());
+    printf("%s: relaxng\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_schemasInternals());
+    printf("%s: schemasInternals\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_schematron());
+    printf("%s: schematron\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_tree());
+    printf("%s: tree\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_uri());
+    printf("%s: uri\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_valid());
+    printf("%s: valid\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xinclude());
+    printf("%s: xinclude\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xmlIO());
+    printf("%s: xmlIO\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xmlautomata());
+    printf("%s: xmlautomata\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xmlerror());
+    printf("%s: xmlerror\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xmlmodule());
+    printf("%s: xmlmodule\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xmlreader());
+    printf("%s: xmlreader\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xmlregexp());
+    printf("%s: xmlregexp\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xmlsave());
+    printf("%s: xmlsave\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xmlschemas());
+    printf("%s: xmlschemas\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xmlschemastypes());
+    printf("%s: xmlschemastypes\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xmlstring());
+    printf("%s: xmlstring\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xmlunicode());
+    printf("%s: xmlunicode\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xmlwriter());
+    printf("%s: xmlwriter\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xpath());
+    printf("%s: xpath\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xpathInternals());
+    printf("%s: xpathInternals\n", (ret == 0) ? "PASS" : "FAIL");
+    test_ret += (ret = test_xpointer());
+    printf("%s: xpointer\n", (ret == 0) ? "PASS" : "FAIL");
 
     printf("Total: %d functions, %d tests, %d errors\n",
            function_tests, call_tests, test_ret);
+
+    printf("%s: testapi\n\n", (test_ret == 0) ? "PASS" : "FAIL");
     return(test_ret);
 }
 
diff --git a/testchar.c b/testchar.c
index 6866a175..7bce0132 100644
--- a/testchar.c
+++ b/testchar.c
@@ -23,7 +23,7 @@ static void errorHandler(void *unused, xmlErrorPtr err) {
 char document1[100] = "<doc>XXXX</doc>";
 char document2[100] = "<doc foo='XXXX'/>";
 
-static void testDocumentRangeByte1(xmlParserCtxtPtr ctxt, char *document,
+static int testDocumentRangeByte1(xmlParserCtxtPtr ctxt, char *document,
                   int len,  char *data, int forbid1, int forbid2) {
     int i;
     xmlDocPtr res;
@@ -37,33 +37,41 @@ static void testDocumentRangeByte1(xmlParserCtxtPtr ctxt, char *document,
 	res = xmlReadMemory(document, len, "test", NULL, 0);
 
 	if ((i == forbid1) || (i == forbid2)) {
-	    if ((lastError == 0) || (res != NULL))
+	    if ((lastError == 0) || (res != NULL)) {
 	        fprintf(stderr,
 		    "Failed to detect invalid char for Byte 0x%02X: %c\n",
 		        i, i);
+		return(1);
+	    }
 	}
 
 	else if ((i == '<') || (i == '&')) {
-	    if ((lastError == 0) || (res != NULL))
+	    if ((lastError == 0) || (res != NULL)) {
 	        fprintf(stderr,
 		    "Failed to detect illegal char %c for Byte 0x%02X\n", i, i);
+		return(1);
+	    }
 	}
 	else if (((i < 0x20) || (i >= 0x80)) &&
 	    (i != 0x9) && (i != 0xA) && (i != 0xD)) {
-	    if ((lastError != XML_ERR_INVALID_CHAR) && (res != NULL))
+	    if ((lastError != XML_ERR_INVALID_CHAR) && (res != NULL)) {
 	        fprintf(stderr,
 		    "Failed to detect invalid char for Byte 0x%02X\n", i);
+		return(1);
+	    }
 	}
 	else if (res == NULL) {
 	    fprintf(stderr,
 		"Failed to parse valid char for Byte 0x%02X : %c\n", i, i);
+		return(1);
 	}
 	if (res != NULL)
 	    xmlFreeDoc(res);
     }
+    return(0);
 }
 
-static void testDocumentRangeByte2(xmlParserCtxtPtr ctxt, char *document,
+static int testDocumentRangeByte2(xmlParserCtxtPtr ctxt, char *document,
                   int len,  char *data) {
     int i, j;
     xmlDocPtr res;
@@ -80,10 +88,12 @@ static void testDocumentRangeByte2(xmlParserCtxtPtr ctxt, char *document,
 
 	/* if first bit of first char is set, then second bit must too */
 	if ((i & 0x80) && ((i & 0x40) == 0)) {
-	    if ((lastError == 0) || (res != NULL))
+	    if ((lastError == 0) || (res != NULL)) {
 		fprintf(stderr,
 		"Failed to detect invalid char for Bytes 0x%02X 0x%02X\n",
 			i, j);
+		return(1);
+	    }
 	}
 
 	/*
@@ -91,10 +101,12 @@ static void testDocumentRangeByte2(xmlParserCtxtPtr ctxt, char *document,
 	 * bits must be 10
 	 */
 	else if ((i & 0x80) && ((j & 0xC0) != 0x80)) {
-	    if ((lastError == 0) || (res != NULL))
+	    if ((lastError == 0) || (res != NULL)) {
 		fprintf(stderr,
 	    "Failed to detect invalid char for Bytes 0x%02X 0x%02X\n",
 			i, j);
+		return(1);
+	    }
 	}
 
 	/*
@@ -102,10 +114,12 @@ static void testDocumentRangeByte2(xmlParserCtxtPtr ctxt, char *document,
 	 * than 0x80, i.e. one of bits 5 to 1 of i must be set
 	 */
 	else if ((i & 0x80) && ((i & 0x1E) == 0)) {
-	    if ((lastError == 0) || (res != NULL))
+	    if ((lastError == 0) || (res != NULL)) {
 		fprintf(stderr,
 	    "Failed to detect invalid char for Bytes 0x%02X 0x%02X\n",
 			i, j);
+		return(1);
+	    }
 	}
 
 	/*
@@ -113,10 +127,12 @@ static void testDocumentRangeByte2(xmlParserCtxtPtr ctxt, char *document,
 	 * at least 3 bytes, but we give only 2 !
 	 */
 	else if ((i & 0xE0) == 0xE0) {
-	    if ((lastError == 0) || (res != NULL))
+	    if ((lastError == 0) || (res != NULL)) {
 		fprintf(stderr,
 	    "Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x00\n",
 			i, j);
+		return(1);
+	    }
 	}
 
 	/*
@@ -125,11 +141,13 @@ static void testDocumentRangeByte2(xmlParserCtxtPtr ctxt, char *document,
 	else if ((lastError != 0) || (res == NULL)) {
 	    fprintf(stderr,
 		"Failed to parse document for Bytes 0x%02X 0x%02X\n", i, j);
+	    return(1);
 	}
 	if (res != NULL)
 	    xmlFreeDoc(res);
     }
     }
+    return(0);
 }
 
 /**
@@ -141,9 +159,10 @@ static void testDocumentRangeByte2(xmlParserCtxtPtr ctxt, char *document,
  * CDATA in text or in attribute values.
  */
 
-static void testDocumentRanges(void) {
+static int testDocumentRanges(void) {
     xmlParserCtxtPtr ctxt;
     char *data;
+    int test_ret = 0;
 
     /*
      * Set up a parsing context using the first document as
@@ -152,7 +171,7 @@ static void testDocumentRanges(void) {
     ctxt = xmlNewParserCtxt();
     if (ctxt == NULL) {
         fprintf(stderr, "Failed to allocate parser context\n");
-	return;
+	return(1);
     }
 
     printf("testing 1 byte char in document: 1");
@@ -163,7 +182,7 @@ static void testDocumentRanges(void) {
     data[2] = ' ';
     data[3] = ' ';
     /* test 1 byte injection at beginning of area */
-    testDocumentRangeByte1(ctxt, &document1[0], strlen(document1),
+    test_ret += testDocumentRangeByte1(ctxt, &document1[0], strlen(document1),
                            data, -1, -1);
     printf(" 2");
     fflush(stdout);
@@ -172,7 +191,7 @@ static void testDocumentRanges(void) {
     data[2] = ' ';
     data[3] = ' ';
     /* test 1 byte injection at end of area */
-    testDocumentRangeByte1(ctxt, &document1[0], strlen(document1),
+    test_ret += testDocumentRangeByte1(ctxt, &document1[0], strlen(document1),
                            data + 3, -1, -1);
 
     printf(" 3");
@@ -183,7 +202,7 @@ static void testDocumentRanges(void) {
     data[2] = ' ';
     data[3] = ' ';
     /* test 1 byte injection at beginning of area */
-    testDocumentRangeByte1(ctxt, &document2[0], strlen(document2),
+    test_ret += testDocumentRangeByte1(ctxt, &document2[0], strlen(document2),
                            data, '\'', -1);
     printf(" 4");
     fflush(stdout);
@@ -192,7 +211,7 @@ static void testDocumentRanges(void) {
     data[2] = ' ';
     data[3] = ' ';
     /* test 1 byte injection at end of area */
-    testDocumentRangeByte1(ctxt, &document2[0], strlen(document2),
+    test_ret += testDocumentRangeByte1(ctxt, &document2[0], strlen(document2),
                            data + 3, '\'', -1);
     printf(" done\n");
 
@@ -204,7 +223,7 @@ static void testDocumentRanges(void) {
     data[2] = ' ';
     data[3] = ' ';
     /* test 2 byte injection at beginning of area */
-    testDocumentRangeByte2(ctxt, &document1[0], strlen(document1),
+    test_ret += testDocumentRangeByte2(ctxt, &document1[0], strlen(document1),
                            data);
     printf(" 2");
     fflush(stdout);
@@ -213,7 +232,7 @@ static void testDocumentRanges(void) {
     data[2] = ' ';
     data[3] = ' ';
     /* test 2 byte injection at end of area */
-    testDocumentRangeByte2(ctxt, &document1[0], strlen(document1),
+    test_ret += testDocumentRangeByte2(ctxt, &document1[0], strlen(document1),
                            data + 2);
 
     printf(" 3");
@@ -224,7 +243,7 @@ static void testDocumentRanges(void) {
     data[2] = ' ';
     data[3] = ' ';
     /* test 2 byte injection at beginning of area */
-    testDocumentRangeByte2(ctxt, &document2[0], strlen(document2),
+    test_ret += testDocumentRangeByte2(ctxt, &document2[0], strlen(document2),
                            data);
     printf(" 4");
     fflush(stdout);
@@ -233,14 +252,15 @@ static void testDocumentRanges(void) {
     data[2] = ' ';
     data[3] = ' ';
     /* test 2 byte injection at end of area */
-    testDocumentRangeByte2(ctxt, &document2[0], strlen(document2),
+    test_ret += testDocumentRangeByte2(ctxt, &document2[0], strlen(document2),
                            data + 2);
     printf(" done\n");
 
     xmlFreeParserCtxt(ctxt);
+    return(test_ret);
 }
 
-static void testCharRangeByte1(xmlParserCtxtPtr ctxt, char *data) {
+static int testCharRangeByte1(xmlParserCtxtPtr ctxt, char *data) {
     int i = 0;
     int len, c;
 
@@ -255,19 +275,25 @@ static void testCharRangeByte1(xmlParserCtxtPtr ctxt, char *data) {
         c = xmlCurrentChar(ctxt, &len);
 	if ((i == 0) || (i >= 0x80)) {
 	    /* we must see an error there */
-	    if (lastError != XML_ERR_INVALID_CHAR)
+	    if (lastError != XML_ERR_INVALID_CHAR) {
 	        fprintf(stderr,
 		    "Failed to detect invalid char for Byte 0x%02X\n", i);
+		return(1);
+	    }
 	} else if (i == 0xD) {
-	    if ((c != 0xA) || (len != 1))
+	    if ((c != 0xA) || (len != 1)) {
 		fprintf(stderr, "Failed to convert char for Byte 0x%02X\n", i);
+		return(1);
+	    }
 	} else if ((c != i) || (len != 1)) {
 	    fprintf(stderr, "Failed to parse char for Byte 0x%02X\n", i);
+	    return(1);
 	}
     }
+    return(0);
 }
 
-static void testCharRangeByte2(xmlParserCtxtPtr ctxt, char *data) {
+static int testCharRangeByte2(xmlParserCtxtPtr ctxt, char *data) {
     int i, j;
     int len, c;
 
@@ -284,10 +310,12 @@ static void testCharRangeByte2(xmlParserCtxtPtr ctxt, char *data) {
 
 	    /* if first bit of first char is set, then second bit must too */
 	    if ((i & 0x80) && ((i & 0x40) == 0)) {
-		if (lastError != XML_ERR_INVALID_CHAR)
+		if (lastError != XML_ERR_INVALID_CHAR) {
 		    fprintf(stderr,
 		    "Failed to detect invalid char for Bytes 0x%02X 0x%02X\n",
 		            i, j);
+		    return(1);
+		}
 	    }
 
 	    /*
@@ -295,10 +323,12 @@ static void testCharRangeByte2(xmlParserCtxtPtr ctxt, char *data) {
 	     * bits must be 10
 	     */
 	    else if ((i & 0x80) && ((j & 0xC0) != 0x80)) {
-		if (lastError != XML_ERR_INVALID_CHAR)
+		if (lastError != XML_ERR_INVALID_CHAR) {
 		    fprintf(stderr,
 		"Failed to detect invalid char for Bytes 0x%02X 0x%02X: %d\n",
 		            i, j, c);
+		    return(1);
+		}
 	    }
 
 	    /*
@@ -306,10 +336,12 @@ static void testCharRangeByte2(xmlParserCtxtPtr ctxt, char *data) {
 	     * than 0x80, i.e. one of bits 5 to 1 of i must be set
 	     */
 	    else if ((i & 0x80) && ((i & 0x1E) == 0)) {
-		if (lastError != XML_ERR_INVALID_CHAR)
+		if (lastError != XML_ERR_INVALID_CHAR) {
 		    fprintf(stderr,
 		"Failed to detect invalid char for Bytes 0x%02X 0x%02X: %d\n",
 		            i, j, c);
+		    return(1);
+		}
 	    }
 
 	    /*
@@ -317,10 +349,12 @@ static void testCharRangeByte2(xmlParserCtxtPtr ctxt, char *data) {
 	     * at least 3 bytes, but we give only 2 !
 	     */
 	    else if ((i & 0xE0) == 0xE0) {
-		if (lastError != XML_ERR_INVALID_CHAR)
+		if (lastError != XML_ERR_INVALID_CHAR) {
 		    fprintf(stderr,
 		"Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x00\n",
 		            i, j);
+		    return(1);
+		}
 	    }
 
             /*
@@ -329,6 +363,7 @@ static void testCharRangeByte2(xmlParserCtxtPtr ctxt, char *data) {
 	    else if ((lastError != 0) || (len != 2)) {
 		fprintf(stderr,
 		    "Failed to parse char for Bytes 0x%02X 0x%02X\n", i, j);
+		return(1);
 	    }
 
             /*
@@ -338,12 +373,14 @@ static void testCharRangeByte2(xmlParserCtxtPtr ctxt, char *data) {
 		fprintf(stderr,
 	"Failed to parse char for Bytes 0x%02X 0x%02X: expect %d got %d\n",
 	                i, j, ((j & 0x3F) + ((i & 0x1F) << 6)), c);
+		return(1);
 	    }
         }
     }
+    return(0);
 }
 
-static void testCharRangeByte3(xmlParserCtxtPtr ctxt, char *data) {
+static int testCharRangeByte3(xmlParserCtxtPtr ctxt, char *data) {
     int i, j, k, K;
     int len, c;
     unsigned char lows[6] = {0, 0x80, 0x81, 0xC1, 0xFF, 0xBF};
@@ -368,20 +405,24 @@ static void testCharRangeByte3(xmlParserCtxtPtr ctxt, char *data) {
 	 * at least 4 bytes, but we give only 3 !
 	 */
 	if ((i & 0xF0) == 0xF0) {
-	    if (lastError != XML_ERR_INVALID_CHAR)
+	    if (lastError != XML_ERR_INVALID_CHAR) {
 		fprintf(stderr,
 	"Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x%02X 0x%02X\n",
 			i, j, K, data[3]);
+		return(1);
+	    }
 	}
 
         /*
 	 * The second and the third bytes must start with 10
 	 */
 	else if (((j & 0xC0) != 0x80) || ((K & 0xC0) != 0x80)) {
-	    if (lastError != XML_ERR_INVALID_CHAR)
+	    if (lastError != XML_ERR_INVALID_CHAR) {
 		fprintf(stderr,
 	"Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x%02X\n",
 			i, j, K);
+		return(1);
+	    }
 	}
 
 	/*
@@ -390,10 +431,12 @@ static void testCharRangeByte3(xmlParserCtxtPtr ctxt, char *data) {
 	 * the 6th byte of data[1] must be set
 	 */
 	else if (((i & 0xF) == 0) && ((j & 0x20) == 0)) {
-	    if (lastError != XML_ERR_INVALID_CHAR)
+	    if (lastError != XML_ERR_INVALID_CHAR) {
 		fprintf(stderr,
 	    "Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x%02X\n",
 			i, j, K);
+		return(1);
+	    }
 	}
 
         /*
@@ -401,10 +444,12 @@ static void testCharRangeByte3(xmlParserCtxtPtr ctxt, char *data) {
 	 */
 	else if (((value > 0xD7FF) && (value <0xE000)) ||
 	         ((value > 0xFFFD) && (value <0x10000))) {
-	    if (lastError != XML_ERR_INVALID_CHAR)
+	    if (lastError != XML_ERR_INVALID_CHAR) {
 		fprintf(stderr,
 	"Failed to detect invalid char 0x%04X for Bytes 0x%02X 0x%02X 0x%02X\n",
 			value, i, j, K);
+		return(1);
+	    }
 	}
 
 	/*
@@ -414,6 +459,7 @@ static void testCharRangeByte3(xmlParserCtxtPtr ctxt, char *data) {
 	    fprintf(stderr,
 		"Failed to parse char for Bytes 0x%02X 0x%02X 0x%02X\n",
 		    i, j, K);
+	    return(1);
 	}
 
 	/*
@@ -423,13 +469,15 @@ static void testCharRangeByte3(xmlParserCtxtPtr ctxt, char *data) {
 	    fprintf(stderr,
     "Failed to parse char for Bytes 0x%02X 0x%02X 0x%02X: expect %d got %d\n",
 		i, j, data[2], value, c);
+	    return(1);
 	}
     }
     }
     }
+    return(0);
 }
 
-static void testCharRangeByte4(xmlParserCtxtPtr ctxt, char *data) {
+static int testCharRangeByte4(xmlParserCtxtPtr ctxt, char *data) {
     int i, j, k, K, l, L;
     int len, c;
     unsigned char lows[6] = {0, 0x80, 0x81, 0xC1, 0xFF, 0xBF};
@@ -458,10 +506,12 @@ static void testCharRangeByte4(xmlParserCtxtPtr ctxt, char *data) {
 	 * at least 5 bytes, but we give only 4 !
 	 */
 	if ((i & 0xF8) == 0xF8) {
-	    if (lastError != XML_ERR_INVALID_CHAR)
+	    if (lastError != XML_ERR_INVALID_CHAR) {
 		fprintf(stderr,
   "Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x%02X 0x%02X\n",
 			i, j, K, data[3]);
+		return(1);
+	    }
 	}
 
         /*
@@ -469,10 +519,12 @@ static void testCharRangeByte4(xmlParserCtxtPtr ctxt, char *data) {
 	 */
 	else if (((j & 0xC0) != 0x80) || ((K & 0xC0) != 0x80) ||
 	         ((L & 0xC0) != 0x80)) {
-	    if (lastError != XML_ERR_INVALID_CHAR)
+	    if (lastError != XML_ERR_INVALID_CHAR) {
 		fprintf(stderr,
 	"Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x%02X 0x%02X\n",
 			i, j, K, L);
+		return(1);
+	    }
 	}
 
 	/*
@@ -481,10 +533,12 @@ static void testCharRangeByte4(xmlParserCtxtPtr ctxt, char *data) {
 	 * the 6 or 5th byte of j must be set
 	 */
 	else if (((i & 0x7) == 0) && ((j & 0x30) == 0)) {
-	    if (lastError != XML_ERR_INVALID_CHAR)
+	    if (lastError != XML_ERR_INVALID_CHAR) {
 		fprintf(stderr,
 	"Failed to detect invalid char for Bytes 0x%02X 0x%02X 0x%02X 0x%02X\n",
 			i, j, K, L);
+		return(1);
+	    }
 	}
 
         /*
@@ -493,10 +547,12 @@ static void testCharRangeByte4(xmlParserCtxtPtr ctxt, char *data) {
 	else if (((value > 0xD7FF) && (value <0xE000)) ||
 	         ((value > 0xFFFD) && (value <0x10000)) ||
 		 (value > 0x10FFFF)) {
-	    if (lastError != XML_ERR_INVALID_CHAR)
+	    if (lastError != XML_ERR_INVALID_CHAR) {
 		fprintf(stderr,
 "Failed to detect invalid char 0x%04X for Bytes 0x%02X 0x%02X 0x%02X 0x%02X\n",
 			value, i, j, K, L);
+		return(1);
+	    }
 	}
 
 	/*
@@ -506,6 +562,7 @@ static void testCharRangeByte4(xmlParserCtxtPtr ctxt, char *data) {
 	    fprintf(stderr,
 		"Failed to parse char for Bytes 0x%02X 0x%02X 0x%02X\n",
 		    i, j, K);
+	    return(1);
 	}
 
 	/*
@@ -515,11 +572,13 @@ static void testCharRangeByte4(xmlParserCtxtPtr ctxt, char *data) {
 	    fprintf(stderr,
     "Failed to parse char for Bytes 0x%02X 0x%02X 0x%02X: expect %d got %d\n",
 		i, j, data[2], value, c);
+	    return(1);
 	}
     }
     }
     }
     }
+    return(0);
 }
 
 /**
@@ -530,11 +589,12 @@ static void testCharRangeByte4(xmlParserCtxtPtr ctxt, char *data) {
  * cover the full range of UTF-8 chars accepted by XML-1.0
  */
 
-static void testCharRanges(void) {
+static int testCharRanges(void) {
     char data[5];
     xmlParserCtxtPtr ctxt;
     xmlParserInputBufferPtr buf;
     xmlParserInputPtr input;
+    int test_ret = 0;
 
     memset(data, 0, 5);
 
@@ -545,17 +605,19 @@ static void testCharRanges(void) {
     ctxt = xmlNewParserCtxt();
     if (ctxt == NULL) {
         fprintf(stderr, "Failed to allocate parser context\n");
-	return;
+	return(1);
     }
     buf = xmlParserInputBufferCreateStatic(data, sizeof(data),
                                            XML_CHAR_ENCODING_NONE);
     if (buf == NULL) {
         fprintf(stderr, "Failed to allocate input buffer\n");
+	test_ret = 1;
 	goto error;
     }
     input = xmlNewInputStream(ctxt);
     if (input == NULL) {
         xmlFreeParserInputBuffer(buf);
+	test_ret = 1;
 	goto error;
     }
     input->filename = NULL;
@@ -567,25 +629,28 @@ static void testCharRanges(void) {
 
     printf("testing char range: 1");
     fflush(stdout);
-    testCharRangeByte1(ctxt, data);
+    test_ret += testCharRangeByte1(ctxt, data);
     printf(" 2");
     fflush(stdout);
-    testCharRangeByte2(ctxt, data);
+    test_ret += testCharRangeByte2(ctxt, data);
     printf(" 3");
     fflush(stdout);
-    testCharRangeByte3(ctxt, data);
+    test_ret += testCharRangeByte3(ctxt, data);
     printf(" 4");
     fflush(stdout);
-    testCharRangeByte4(ctxt, data);
+    test_ret += testCharRangeByte4(ctxt, data);
     printf(" done\n");
     fflush(stdout);
 
 error:
     xmlFreeParserCtxt(ctxt);
+    return(test_ret);
 }
 
 int main(void) {
 
+    int ret = 0;
+
     /*
      * this initialize the library and check potential ABI mismatches
      * between the version it was compiled for and the actual shared
@@ -602,8 +667,9 @@ int main(void) {
     /*
      * Run the tests
      */
-    testCharRanges();
-    testDocumentRanges();
+    ret += testCharRanges();
+    ret += testDocumentRanges();
+    printf("%s: testchar\n\n", (ret == 0) ? "PASS" : "FAIL");
 
     /*
      * Cleanup function for the XML library.
diff --git a/testdict.c b/testdict.c
index 40bebd05..114b9347 100644
--- a/testdict.c
+++ b/testdict.c
@@ -440,5 +440,6 @@ int main(void)
     clean_strings();
     xmlCleanupParser();
     xmlMemoryDump();
+    printf("%s: testdict\n\n", (ret == 0) ? "PASS" : "FAIL");
     return(ret);
 }
diff --git a/testlimits.c b/testlimits.c
index 059116a6..f0bee68d 100644
--- a/testlimits.c
+++ b/testlimits.c
@@ -1634,5 +1634,6 @@ main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
     xmlCleanupParser();
     xmlMemoryDump();
 
+    printf("%s: testlimits\n", (ret == 0) ? "PASS" : "FAIL");
     return(ret);
 }
diff --git a/testrecurse.c b/testrecurse.c
index 0cbe25a6..3ecadb40 100644
--- a/testrecurse.c
+++ b/testrecurse.c
@@ -892,6 +892,7 @@ launchTests(testDescPtr tst) {
 	    err++;
 	}
     }
+    printf("%s: %s\n", (err == 0) ? "PASS" : "FAIL", tst->desc);
     return(err);
 }
 
@@ -961,5 +962,6 @@ main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
     xmlCleanupParser();
     xmlMemoryDump();
 
+    printf("%s: testrecurse\n\n", (ret == 0) ? "PASS" : "FAIL");
     return(ret);
 }
-- 
2.25.1