gnunet-svn
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[libmicrohttpd] branch master updated (6884fa83 -> 9668d71f)


From: gnunet
Subject: [libmicrohttpd] branch master updated (6884fa83 -> 9668d71f)
Date: Mon, 13 Jun 2022 20:28:31 +0200

This is an automated email from the git hooks/post-receive script.

karlson2k pushed a change to branch master
in repository libmicrohttpd.

    from 6884fa83 Fixed function name introduced by 
3eb2fb6dfb302a7ffbc74174d37fa047e3a94036
     new 003c29eb postprocessor.h: added new internal header
     new c39070a6 postprocessor.c: added assert
     new 11c6f7a6 test_postprocessor_md: removed include of .c file, fixed 
extra long lines
     new 9f805215 test_postprocessor{,_amp,_large}: fixed compiler warnings, 
fixed extra-long strings
     new fd3ff5c6 test_str: minor refactoring, fixed compiler warnings
     new 70f6be39 test_str_token{,s,s_remove}: fixed compiler warnings
     new fa5b49e0 test_daemon: fixed compiler warnings
     new 7d7085b6 test_http_reasons: fixed compiler warnings
     new 9668d71f test_start_stop: fixed compiler warnings

The 9 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 src/microhttpd/Makefile.am                |  10 +-
 src/microhttpd/postprocessor.c            | 218 +---------------
 src/microhttpd/postprocessor.h            | 246 ++++++++++++++++++
 src/microhttpd/test_daemon.c              |  30 +--
 src/microhttpd/test_http_reasons.c        |   8 +-
 src/microhttpd/test_postprocessor.c       |  38 +--
 src/microhttpd/test_postprocessor_amp.c   |  47 +++-
 src/microhttpd/test_postprocessor_large.c |   6 +-
 src/microhttpd/test_postprocessor_md.c    | 368 +++++++++++++++++++++++++--
 src/microhttpd/test_start_stop.c          |  26 +-
 src/microhttpd/test_str.c                 | 403 +++++++++---------------------
 src/microhttpd/test_str_token.c           |   4 +-
 src/microhttpd/test_str_token_remove.c    |   7 +-
 src/microhttpd/test_str_tokens_remove.c   |   2 +-
 w32/common/libmicrohttpd-files.vcxproj    |   1 +
 w32/common/libmicrohttpd-filters.vcxproj  |   3 +
 16 files changed, 836 insertions(+), 581 deletions(-)
 create mode 100644 src/microhttpd/postprocessor.h

diff --git a/src/microhttpd/Makefile.am b/src/microhttpd/Makefile.am
index 14ee6c23..9e0bb7a4 100644
--- a/src/microhttpd/Makefile.am
+++ b/src/microhttpd/Makefile.am
@@ -158,7 +158,7 @@ endif
 
 if HAVE_POSTPROCESSOR
 libmicrohttpd_la_SOURCES += \
-  postprocessor.c
+  postprocessor.c postprocessor.h
 endif
 
 if HAVE_ANYAUTH
@@ -374,11 +374,9 @@ test_postprocessor_large_LDADD = \
   $(builddir)/libmicrohttpd.la
 
 test_postprocessor_md_SOURCES = \
-  test_postprocessor_md.c
-test_postprocessor_md_CPPFLAGS = \
-  $(AM_CPPFLAGS) $(MHD_TLS_LIB_CPPFLAGS)
-test_postprocessor_md_CFLAGS = \
-  $(AM_CFLAGS) $(MHD_TLS_LIB_CFLAGS)
+  test_postprocessor_md.c postprocessor.h postprocessor.c \
+  internal.h internal.c mhd_str.h mhd_str.c \
+  mhd_panic.h mhd_panic.c
 
 test_shutdown_select_SOURCES = \
   test_shutdown_select.c
diff --git a/src/microhttpd/postprocessor.c b/src/microhttpd/postprocessor.c
index 8249fc35..a9738906 100644
--- a/src/microhttpd/postprocessor.c
+++ b/src/microhttpd/postprocessor.c
@@ -24,6 +24,7 @@
  * @author Karlson2k (Evgeny Grin)
  */
 
+#include "postprocessor.h"
 #include "internal.h"
 #include "mhd_str.h"
 #include "mhd_compat.h"
@@ -36,221 +37,6 @@
  */
 #define XBUF_SIZE 512
 
-/**
- * States in the PP parser's state machine.
- */
-enum PP_State
-{
-  /* general states */
-  PP_Error,
-  PP_Done,
-  PP_Init,
-  PP_NextBoundary,
-
-  /* url encoding-states */
-  PP_ProcessKey,
-  PP_ProcessValue,
-  PP_Callback,
-
-  /* post encoding-states  */
-  PP_ProcessEntryHeaders,
-  PP_PerformCheckMultipart,
-  PP_ProcessValueToBoundary,
-  PP_PerformCleanup,
-
-  /* nested post-encoding states */
-  PP_Nested_Init,
-  PP_Nested_PerformMarking,
-  PP_Nested_ProcessEntryHeaders,
-  PP_Nested_ProcessValueToBoundary,
-  PP_Nested_PerformCleanup
-
-};
-
-
-enum RN_State
-{
-  /**
-   * No RN-preprocessing in this state.
-   */
-  RN_Inactive = 0,
-
-  /**
-   * If the next character is CR, skip it.  Otherwise,
-   * just go inactive.
-   */
-  RN_OptN = 1,
-
-  /**
-   * Expect LFCR (and only LFCR).  As always, we also
-   * expect only LF or only CR.
-   */
-  RN_Full = 2,
-
-  /**
-   * Expect either LFCR or '--'LFCR.  If '--'LFCR, transition into dash-state
-   * for the main state machine
-   */
-  RN_Dash = 3,
-
-  /**
-   * Got a single dash, expect second dash.
-   */
-  RN_Dash2 = 4
-};
-
-
-/**
- * Bits for the globally known fields that
- * should not be deleted when we exit the
- * nested state.
- */
-enum NE_State
-{
-  NE_none = 0,
-  NE_content_name = 1,
-  NE_content_type = 2,
-  NE_content_filename = 4,
-  NE_content_transfer_encoding = 8
-};
-
-
-/**
- * Internal state of the post-processor.  Note that the fields
- * are sorted by type to enable optimal packing by the compiler.
- */
-struct MHD_PostProcessor
-{
-
-  /**
-   * The connection for which we are doing
-   * POST processing.
-   */
-  struct MHD_Connection *connection;
-
-  /**
-   * Function to call with POST data.
-   */
-  MHD_PostDataIterator ikvi;
-
-  /**
-   * Extra argument to ikvi.
-   */
-  void *cls;
-
-  /**
-   * Encoding as given by the headers of the connection.
-   */
-  const char *encoding;
-
-  /**
-   * Primary boundary (points into encoding string)
-   */
-  const char *boundary;
-
-  /**
-   * Nested boundary (if we have multipart/mixed encoding).
-   */
-  char *nested_boundary;
-
-  /**
-   * Pointer to the name given in disposition.
-   */
-  char *content_name;
-
-  /**
-   * Pointer to the (current) content type.
-   */
-  char *content_type;
-
-  /**
-   * Pointer to the (current) filename.
-   */
-  char *content_filename;
-
-  /**
-   * Pointer to the (current) encoding.
-   */
-  char *content_transfer_encoding;
-
-  /**
-   * Value data left over from previous iteration.
-   */
-  char xbuf[2];
-
-  /**
-   * Size of our buffer for the key.
-   */
-  size_t buffer_size;
-
-  /**
-   * Current position in the key buffer.
-   */
-  size_t buffer_pos;
-
-  /**
-   * Current position in @e xbuf.
-   */
-  size_t xbuf_pos;
-
-  /**
-   * Current offset in the value being processed.
-   */
-  uint64_t value_offset;
-
-  /**
-   * strlen(boundary) -- if boundary != NULL.
-   */
-  size_t blen;
-
-  /**
-   * strlen(nested_boundary) -- if nested_boundary != NULL.
-   */
-  size_t nlen;
-
-  /**
-   * Do we have to call the 'ikvi' callback when processing the
-   * multipart post body even if the size of the payload is zero?
-   * Set to #MHD_YES whenever we parse a new multiparty entry header,
-   * and to #MHD_NO the first time we call the 'ikvi' callback.
-   * Used to ensure that we do always call 'ikvi' even if the
-   * payload is empty (but not more than once).
-   */
-  bool must_ikvi;
-
-  /**
-   * Set if we still need to run the unescape logic
-   * on the key allocated at the end of this struct.
-   */
-  bool must_unescape_key;
-
-  /**
-   * State of the parser.
-   */
-  enum PP_State state;
-
-  /**
-   * Side-state-machine: skip LRCR (or just LF).
-   * Set to 0 if we are not in skip mode.  Set to 2
-   * if a LFCR is expected, set to 1 if a CR should
-   * be skipped if it is the next character.
-   */
-  enum RN_State skip_rn;
-
-  /**
-   * If we are in skip_rn with "dash" mode and
-   * do find 2 dashes, what state do we go into?
-   */
-  enum PP_State dash_state;
-
-  /**
-   * Which headers are global? (used to tell which
-   * headers were only valid for the nested multipart).
-   */
-  enum NE_State have;
-
-};
-
 
 _MHD_EXTERN struct MHD_PostProcessor *
 MHD_create_post_processor (struct MHD_Connection *connection,
@@ -267,6 +53,7 @@ MHD_create_post_processor (struct MHD_Connection *connection,
        (NULL == connection) ||
        (NULL == iter))
     MHD_PANIC (_ ("libmicrohttpd API violation.\n"));
+  encoding = NULL;
   if (MHD_NO == MHD_lookup_connection_value_n (connection,
                                                MHD_HEADER_KIND,
                                                MHD_HTTP_HEADER_CONTENT_TYPE,
@@ -275,6 +62,7 @@ MHD_create_post_processor (struct MHD_Connection *connection,
                                                &encoding,
                                                NULL))
     return NULL;
+  mhd_assert (NULL != encoding);
   boundary = NULL;
   if (! MHD_str_equal_caseless_n_ (MHD_HTTP_POST_ENCODING_FORM_URLENCODED,
                                    encoding,
diff --git a/src/microhttpd/postprocessor.h b/src/microhttpd/postprocessor.h
new file mode 100644
index 00000000..df681ce9
--- /dev/null
+++ b/src/microhttpd/postprocessor.h
@@ -0,0 +1,246 @@
+/*
+     This file is part of libmicrohttpd
+     Copyright (C) 2007-2022 Daniel Pittman, Christian Grothoff, and Evgeny 
Grin
+
+     This library is free software; you can redistribute it and/or
+     modify it under the terms of the GNU Lesser General Public
+     License as published by the Free Software Foundation; either
+     version 2.1 of the License, or (at your option) any later version.
+
+     This library is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Lesser General Public License for more details.
+
+     You should have received a copy of the GNU Lesser General Public
+     License along with this library; if not, write to the Free Software
+     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 
 USA
+*/
+
+/**
+ * @file postprocessor.h
+ * @brief  Declarations for parsing POST data
+ * @author Christian Grothoff
+ * @author Karlson2k (Evgeny Grin)
+ */
+
+#ifndef MHD_POSTPROCESSOR_H
+#define MHD_POSTPROCESSOR_H 1
+#include "internal.h"
+
+/**
+ * States in the PP parser's state machine.
+ */
+enum PP_State
+{
+  /* general states */
+  PP_Error,
+  PP_Done,
+  PP_Init,
+  PP_NextBoundary,
+
+  /* url encoding-states */
+  PP_ProcessKey,
+  PP_ProcessValue,
+  PP_Callback,
+
+  /* post encoding-states  */
+  PP_ProcessEntryHeaders,
+  PP_PerformCheckMultipart,
+  PP_ProcessValueToBoundary,
+  PP_PerformCleanup,
+
+  /* nested post-encoding states */
+  PP_Nested_Init,
+  PP_Nested_PerformMarking,
+  PP_Nested_ProcessEntryHeaders,
+  PP_Nested_ProcessValueToBoundary,
+  PP_Nested_PerformCleanup
+
+};
+
+
+enum RN_State
+{
+  /**
+   * No RN-preprocessing in this state.
+   */
+  RN_Inactive = 0,
+
+  /**
+   * If the next character is CR, skip it.  Otherwise,
+   * just go inactive.
+   */
+  RN_OptN = 1,
+
+  /**
+   * Expect LFCR (and only LFCR).  As always, we also
+   * expect only LF or only CR.
+   */
+  RN_Full = 2,
+
+  /**
+   * Expect either LFCR or '--'LFCR.  If '--'LFCR, transition into dash-state
+   * for the main state machine
+   */
+  RN_Dash = 3,
+
+  /**
+   * Got a single dash, expect second dash.
+   */
+  RN_Dash2 = 4
+};
+
+
+/**
+ * Bits for the globally known fields that
+ * should not be deleted when we exit the
+ * nested state.
+ */
+enum NE_State
+{
+  NE_none = 0,
+  NE_content_name = 1,
+  NE_content_type = 2,
+  NE_content_filename = 4,
+  NE_content_transfer_encoding = 8
+};
+
+
+/**
+ * Internal state of the post-processor.  Note that the fields
+ * are sorted by type to enable optimal packing by the compiler.
+ */
+struct MHD_PostProcessor
+{
+
+  /**
+   * The connection for which we are doing
+   * POST processing.
+   */
+  struct MHD_Connection *connection;
+
+  /**
+   * Function to call with POST data.
+   */
+  MHD_PostDataIterator ikvi;
+
+  /**
+   * Extra argument to ikvi.
+   */
+  void *cls;
+
+  /**
+   * Encoding as given by the headers of the connection.
+   */
+  const char *encoding;
+
+  /**
+   * Primary boundary (points into encoding string)
+   */
+  const char *boundary;
+
+  /**
+   * Nested boundary (if we have multipart/mixed encoding).
+   */
+  char *nested_boundary;
+
+  /**
+   * Pointer to the name given in disposition.
+   */
+  char *content_name;
+
+  /**
+   * Pointer to the (current) content type.
+   */
+  char *content_type;
+
+  /**
+   * Pointer to the (current) filename.
+   */
+  char *content_filename;
+
+  /**
+   * Pointer to the (current) encoding.
+   */
+  char *content_transfer_encoding;
+
+  /**
+   * Value data left over from previous iteration.
+   */
+  char xbuf[2];
+
+  /**
+   * Size of our buffer for the key.
+   */
+  size_t buffer_size;
+
+  /**
+   * Current position in the key buffer.
+   */
+  size_t buffer_pos;
+
+  /**
+   * Current position in @e xbuf.
+   */
+  size_t xbuf_pos;
+
+  /**
+   * Current offset in the value being processed.
+   */
+  uint64_t value_offset;
+
+  /**
+   * strlen(boundary) -- if boundary != NULL.
+   */
+  size_t blen;
+
+  /**
+   * strlen(nested_boundary) -- if nested_boundary != NULL.
+   */
+  size_t nlen;
+
+  /**
+   * Do we have to call the 'ikvi' callback when processing the
+   * multipart post body even if the size of the payload is zero?
+   * Set to #MHD_YES whenever we parse a new multiparty entry header,
+   * and to #MHD_NO the first time we call the 'ikvi' callback.
+   * Used to ensure that we do always call 'ikvi' even if the
+   * payload is empty (but not more than once).
+   */
+  bool must_ikvi;
+
+  /**
+   * Set if we still need to run the unescape logic
+   * on the key allocated at the end of this struct.
+   */
+  bool must_unescape_key;
+
+  /**
+   * State of the parser.
+   */
+  enum PP_State state;
+
+  /**
+   * Side-state-machine: skip LRCR (or just LF).
+   * Set to 0 if we are not in skip mode.  Set to 2
+   * if a LFCR is expected, set to 1 if a CR should
+   * be skipped if it is the next character.
+   */
+  enum RN_State skip_rn;
+
+  /**
+   * If we are in skip_rn with "dash" mode and
+   * do find 2 dashes, what state do we go into?
+   */
+  enum PP_State dash_state;
+
+  /**
+   * Which headers are global? (used to tell which
+   * headers were only valid for the nested multipart).
+   */
+  enum NE_State have;
+
+};
+
+#endif /* ! MHD_POSTPROCESSOR_H */
diff --git a/src/microhttpd/test_daemon.c b/src/microhttpd/test_daemon.c
index 7a55ff65..6990ea3a 100644
--- a/src/microhttpd/test_daemon.c
+++ b/src/microhttpd/test_daemon.c
@@ -35,8 +35,8 @@
 #endif
 
 
-static int
-testStartError ()
+static unsigned int
+testStartError (void)
 {
   struct MHD_Daemon *d;
 
@@ -91,8 +91,8 @@ ahc_nothing (void *cls,
 }
 
 
-static int
-testStartStop ()
+static unsigned int
+testStartStop (void)
 {
   struct MHD_Daemon *d;
 
@@ -105,7 +105,7 @@ testStartStop ()
   {
     fprintf (stderr,
              "Failed to start daemon on port %u\n",
-             0);
+             (unsigned int) 0);
     exit (77);
   }
   MHD_stop_daemon (d);
@@ -113,8 +113,8 @@ testStartStop ()
 }
 
 
-static int
-testExternalRun ()
+static unsigned int
+testExternalRun (void)
 {
   struct MHD_Daemon *d;
   fd_set rs;
@@ -131,7 +131,7 @@ testExternalRun ()
   {
     fprintf (stderr,
              "Failed to start daemon on port %u\n",
-             0);
+             (unsigned int) 0);
     exit (77);
   }
   i = 0;
@@ -160,8 +160,8 @@ testExternalRun ()
 }
 
 
-static int
-testThread ()
+static unsigned int
+testThread (void)
 {
   struct MHD_Daemon *d;
 
@@ -175,7 +175,7 @@ testThread ()
   {
     fprintf (stderr,
              "Failed to start daemon on port %u.\n",
-             1082);
+             (unsigned int) 1082);
     exit (77);
   }
   if (MHD_run (d) != MHD_NO)
@@ -189,8 +189,8 @@ testThread ()
 }
 
 
-static int
-testMultithread ()
+static unsigned int
+testMultithread (void)
 {
   struct MHD_Daemon *d;
 
@@ -205,7 +205,7 @@ testMultithread ()
   {
     fprintf (stderr,
              "Failed to start daemon on port %u\n",
-             0);
+             (unsigned int) 0);
     exit (77);
   }
   if (MHD_run (d) != MHD_NO)
@@ -223,7 +223,7 @@ int
 main (int argc,
       char *const *argv)
 {
-  int errorCount = 0;
+  unsigned int errorCount = 0;
   (void) argc; (void) argv; /* Unused. Silent compiler warning. */
 
   errorCount += testStartError ();
diff --git a/src/microhttpd/test_http_reasons.c 
b/src/microhttpd/test_http_reasons.c
index 6a0b24b9..19bbcde3 100644
--- a/src/microhttpd/test_http_reasons.c
+++ b/src/microhttpd/test_http_reasons.c
@@ -33,7 +33,7 @@ static const char *const r_unknown = "unknown";
 
 /* Return zero when no error is detected */
 static int
-expect_result (int code, const char *expected)
+expect_result (unsigned int code, const char *expected)
 {
   const char *const reason = MHD_get_reason_phrase_for (code);
   const size_t len = MHD_get_reason_phrase_len_for (code);
@@ -41,7 +41,7 @@ expect_result (int code, const char *expected)
   if (! MHD_str_equal_caseless_ (reason, expected))
   {
     fprintf (stderr,
-             "Incorrect reason returned for code %d:\n  Returned: \"%s\"  
\tExpected: \"%s\"\n",
+             "Incorrect reason returned for code %u:\n  Returned: \"%s\"  
\tExpected: \"%s\"\n",
              code, reason, expected);
     return 1;
   }
@@ -52,7 +52,7 @@ expect_result (int code, const char *expected)
   if (exp_len != len)
   {
     fprintf (stderr,
-             "Incorrect reason length returned for code %d:\n  Returned: 
\"%u\"  \tExpected: \"%u\"\n",
+             "Incorrect reason length returned for code %u:\n  Returned: 
\"%u\"  \tExpected: \"%u\"\n",
              code, (unsigned) len, (unsigned) exp_len);
     return 1;
   }
@@ -61,7 +61,7 @@ expect_result (int code, const char *expected)
 
 
 static int
-expect_absent (int code)
+expect_absent (unsigned int code)
 {
   return expect_result (code, r_unknown);
 }
diff --git a/src/microhttpd/test_postprocessor.c 
b/src/microhttpd/test_postprocessor.c
index 9a5977bc..ab68541b 100644
--- a/src/microhttpd/test_postprocessor.c
+++ b/src/microhttpd/test_postprocessor.c
@@ -87,14 +87,24 @@ struct expResult exp_results[] = {
 #define URL_ENC_END (URL_ENC_START + 4)
   {NULL, NULL, NULL, NULL, NULL},
 #define FORM_DATA \
-  "--AaB03x\r\ncontent-disposition: form-data; name=\"field1\"\r\n\r\nJoe 
Blow\r\n--AaB03x\r\ncontent-disposition: form-data; name=\"pics\"; 
filename=\"file1.txt\"\r\nContent-Type: 
text/plain\r\nContent-Transfer-Encoding: 
binary\r\n\r\nfiledata\r\n--AaB03x--\r\n"
+  "--AaB03x\r\ncontent-disposition: form-data; name=\"field1\"\r\n\r\n" \
+  "Joe Blow\r\n--AaB03x\r\ncontent-disposition: form-data; name=\"pics\";" \
+  " filename=\"file1.txt\"\r\nContent-Type: text/plain\r\n" \
+  "Content-Transfer-Encoding: binary\r\n\r\nfiledata\r\n--AaB03x--\r\n"
 #define FORM_START (URL_ENC_END + 1)
   {"field1", NULL, NULL, NULL, "Joe Blow"},
   {"pics", "file1.txt", "text/plain", "binary", "filedata"},
 #define FORM_END (FORM_START + 2)
   {NULL, NULL, NULL, NULL, NULL},
 #define FORM_NESTED_DATA \
-  "--AaB03x\r\ncontent-disposition: form-data; name=\"field1\"\r\n\r\nJane 
Blow\r\n--AaB03x\r\ncontent-disposition: form-data; 
name=\"pics\"\r\nContent-type: multipart/mixed, 
boundary=BbC04y\r\n\r\n--BbC04y\r\nContent-disposition: attachment; 
filename=\"file1.txt\"\r\nContent-Type: 
text/plain\r\n\r\nfiledata1\r\n--BbC04y\r\nContent-disposition: attachment; 
filename=\"file2.gif\"\r\nContent-type: image/gif\r\nContent-Transfer-Encoding: 
binary\r\n\r\nfiledata2\r\n--BbC04y--\r\n--AaB03x--"
+  "--AaB03x\r\ncontent-disposition: form-data; name=\"field1\"\r\n\r\n" \
+  "Jane Blow\r\n--AaB03x\r\ncontent-disposition: form-data; name=\"pics\"\r\n" 
\
+  "Content-type: multipart/mixed, boundary=BbC04y\r\n\r\n--BbC04y\r\n" \
+  "Content-disposition: attachment; filename=\"file1.txt\"\r\n" \
+  "Content-Type: text/plain\r\n\r\nfiledata1\r\n--BbC04y\r\n" \
+  "Content-disposition: attachment; filename=\"file2.gif\"\r\n" \
+  "Content-type: image/gif\r\nContent-Transfer-Encoding: binary\r\n\r\n" \
+  "filedata2\r\n--BbC04y--\r\n--AaB03x--"
 #define FORM_NESTED_START (FORM_END + 1)
   {"field1", NULL, NULL, NULL, "Jane Blow"},
   {"pics", "file1.txt", "text/plain", NULL, "filedata1"},
@@ -210,13 +220,13 @@ value_checker (void *cls,
 }
 
 
-static int
+static unsigned int
 test_urlencoding_case (unsigned int want_start,
                        unsigned int want_end,
                        const char *url_data)
 {
   size_t step;
-  int errors = 0;
+  unsigned int errors = 0;
   const size_t size = strlen (url_data);
 
   for (step = 1; size >= step; ++step)
@@ -278,7 +288,7 @@ test_urlencoding_case (unsigned int want_start,
 }
 
 
-static int
+static unsigned int
 test_urlencoding (void)
 {
   unsigned int errorCount = 0;
@@ -357,7 +367,7 @@ test_urlencoding (void)
 }
 
 
-static int
+static unsigned int
 test_multipart_garbage (void)
 {
   struct MHD_Connection connection;
@@ -425,7 +435,7 @@ test_multipart_garbage (void)
 }
 
 
-static int
+static unsigned int
 test_multipart_splits (void)
 {
   struct MHD_Connection connection;
@@ -487,7 +497,7 @@ test_multipart_splits (void)
 }
 
 
-static int
+static unsigned int
 test_multipart (void)
 {
   struct MHD_Connection connection;
@@ -544,7 +554,7 @@ test_multipart (void)
 }
 
 
-static int
+static unsigned int
 test_nested_multipart (void)
 {
   struct MHD_Connection connection;
@@ -619,8 +629,8 @@ value_checker2 (void *cls,
 }
 
 
-static int
-test_overflow ()
+static unsigned int
+test_overflow (void)
 {
   struct MHD_Connection connection;
   struct MHD_HTTP_Req_Header header;
@@ -675,7 +685,7 @@ test_overflow ()
 }
 
 
-static int
+static unsigned int
 test_empty_key (void)
 {
   const char form_data[] = "=abcdef";
@@ -726,7 +736,7 @@ test_empty_key (void)
 }
 
 
-static int
+static unsigned int
 test_double_value (void)
 {
   const char form_data[] = URL_DATA "=abcdef";
@@ -822,5 +832,5 @@ main (int argc, char *const *argv)
   errorCount += test_overflow ();
   if (errorCount != 0)
     fprintf (stderr, "Error (code: %u)\n", errorCount);
-  return errorCount != 0;       /* 0 == pass */
+  return (errorCount == 0) ? 0 : 1;       /* 0 == pass */
 }
diff --git a/src/microhttpd/test_postprocessor_amp.c 
b/src/microhttpd/test_postprocessor_amp.c
index 0569cb1f..c72b85f3 100644
--- a/src/microhttpd/test_postprocessor_amp.c
+++ b/src/microhttpd/test_postprocessor_amp.c
@@ -7,7 +7,7 @@
 
 uint64_t num_errors;
 
-enum MHD_Result
+static enum MHD_Result
 check_post (void *cls, enum MHD_ValueKind kind, const char *key,
             const char *filename, const char *content_type,
             const char *content_encoding, const char *data,
@@ -32,7 +32,50 @@ main (int argc, char *const *argv)
   struct MHD_HTTP_Req_Header header;
   struct MHD_PostProcessor *pp;
   const char *post =
-    
"a=xx+xx+xxx+xxxxx+xxxx+xxxxxxxx+xxx+xxxxxx+xxx+xxx+xxxxxxx+xxxxx%0A+++++++xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%0A+++++++--%3E%0A++++++++++++++%3Cxxxxx+xxxxx%3D%22xxx%25%22%3E%0A+++++++++++%3Cxx%3E%0A+++++++++++++++%3Cxx+xxxxxxx%3D%22x%22+xxxxx%3D%22xxxxx%22%3E%0A+++++++++++++++++++%3Cxxxxx+xxxxx%3D%22xxx%25%22%3E%0A+++++++++++++++++++++++%3Cxx%3E%0A+++++++++++++++++++++++++++%3Cxx+xxxxx%3D%22xxxx%22%3E%0A+++++++++++++++++++++++++++++++%3Cx
 [...]
+    "a=xx+xx+xxx+xxxxx+xxxx+xxxxxxxx+xxx+xxxxxx+xxx+xxx+xxxxxxx+xxxxx%0A+++"
+    "++++xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+    "xxxxxxxxxxxxxx%0A+++++++--%3E%0A++++++++++++++%3Cxxxxx+xxxxx%3D%22xxx%"
+    "25%22%3E%0A+++++++++++%3Cxx%3E%0A+++++++++++++++%3Cxx+xxxxxxx%3D%22x%2"
+    "2+xxxxx%3D%22xxxxx%22%3E%0A+++++++++++++++++++%3Cxxxxx+xxxxx%3D%22xxx%"
+    "25%22%3E%0A+++++++++++++++++++++++%3Cxx%3E%0A+++++++++++++++++++++++++"
+    "++%3Cxx+xxxxx%3D%22xxxx%22%3E%0A+++++++++++++++++++++++++++++++%3Cx+xx"
+    "xxx%3D%22xxxx-xxxxx%3Axxxxx%22%3Exxxxx%3A%3C%2Fx%3E%0A%0A+++++++++++++"
+    "++++++++++++++++++%3Cx+xxxxx%3D%22xxxx-xxxxx%3Axxxxx%22%3Exxx%3A%3C%2F"
+    "x%3E%0A%0A+++++++++++++++++++++++++++++++%3Cx+xxxxx%3D%22xxxx-xxxxx%3A"
+    "xxxxx%3B+xxxx-xxxxxx%3A+xxxx%3B%22%3Exxxxx+xxxxx%3A%3C%2Fx%3E%0A++++++"
+    "+++++++++++++++++++++%3C%2Fxx%3E%0A+++++++++++++++++++++++%3C%2Fxx%3E%"
+    "0A+++++++++++++++++++%3C%2Fxxxxx%3E%0A+++++++++++++++%3C%2Fxx%3E%0A+++"
+    "++++++++++++%3Cxx+xxxxx%3D%22xxxx-xxxxx%3A+xxxxx%3B+xxxxx%3A+xxxx%22%3"
+    "E%26xxxxx%3B+%3Cxxxx%0A+++++++++++++++++++++++xxxxx%3D%22xxxxxxxxxxxxx"
+    "xx%22%3Exxxx.xx%3C%2Fxxxx%3E%0A+++++++++++++++%3C%2Fxx%3E%0A++++++++++"
+    "+%3C%2Fxx%3E%0A++++++++++++++++++++++++++%3Cxx%3E%0A++++++++++++++++++"
+    "+%3Cxx+xxxxx%3D%22xxxx-xxxxx%3A+xxxxx%3B+xxxxx%3A+xxxx%22%3E%26xxxxx%3"
+    "B+%3Cxxxx%0A+++++++++++++++++++++++++++xxxxx%3D%22xxxxxxxxxxxxxxx%22%3"
+    "Exxx.xx%3C%2Fxxxx%3E%0A+++++++++++++++++++%3C%2Fxx%3E%0A++++++++++++++"
+    "+%3C%2Fxx%3E%0A++++++++++++++++++++++%3Cxx%3E%0A+++++++++++++++%3Cxx+x"
+    "xxxx%3D%22xxxx-xxxxx%3A+xxxxx%3Bxxxx-xxxxxx%3A+xxxx%3B+xxxxx%3A+xxxx%2"
+    "2%3E%26xxxxx%3B+%3Cxxxx%0A+++++++++++++++++++++++xxxxx%3D%22xxxxxxxxxx"
+    "xxxxx%22%3Exxxx.xx%3C%2Fxxxx%3E%3C%2Fxx%3E%0A+++++++++++%3C%2Fxx%3E%0A"
+    "+++++++%3C%2Fxxxxx%3E%0A+++++++%3C%21--%0A+++++++xxxxxxxxxxxxxxxxxxxxx"
+    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%0A+++++++x"
+    "xx+xx+xxxxx+xxxxxxx+xxxxxxx%0A+++++++xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%0A+++++++--%3E%0A+++%3"
+    "C%2Fxxx%3E%0A%0A%0A%0A+++%3Cxxx+xxxxx%3D%22xxxxxxxxx%22+xx%3D%22xxxxxx"
+    "xxx%22%3E%3C%2Fxxx%3E%0A%0A+++%3Cxxx+xx%3D%22xxxx%22+xxxxx%3D%22xxxx%2"
+    "2%3E%0A+++++++%3Cxxxxx+xxxxx%3D%22xxxxxxxxx%22%3E%0A+++++++++++%3Cxx%3"
+    "E%0A+++++++++++++++%3Cxx+xxxxxxx%3D%22x%22+xx%3D%22xxxxxxxxxxxxx%22+xx"
+    "xxx%3D%22xxxxxxxxxxxxx%22%3E%0A+++++++++++++++++++%3Cxxx+xx%3D%22xxxxx"
+    "x%22%3E%3C%2Fxxx%3E%0A+++++++++++++++%3C%2Fxx%3E%0A+++++++++++%3C%2Fxx"
+    "%3E%0A+++++++++++%3Cxx%3E%0A+++++++++++++++%3Cxx+xx%3D%22xxxxxxxxxxxxx"
+    "xxxx%22+xxxxx%3D%22xxxxxxxxxxxxxxxxx%22%3E%3C%2Fxx%3E%0A++++++++++++++"
+    "+%3Cxx+xx%3D%22xxxxxxxxxxxxxx%22+xxxxx%3D%22xxxxxxxxxxxxxx%22%3E%0A+++"
+    "++++++++++++++++%3Cxxx+xx%3D%22xxxxxxx%22%3E%3C%2Fxxx%3E%0A+++++++++++"
+    "++++%3C%2Fxx%3E%0A+++++++++++%3C%2Fxx%3E%0A+++++++++++%3Cxx%3E%0A+++++"
+    "++++++++++%3Cxx+xxxxxxx%3D%22x%22+xx%3D%22xxxxxxxxxxxxx%22+xxxxx%3D%22"
+    "xxxxxxxxxxxxx%22%3E%0A+++++++++++++++++++%3Cxxx+xx%3D%22xxxxxx%22%3E%3"
+    "C%2Fxxx%3E%0A+++++++++++++++%3C%2Fxx%3E%0A+++++++++++%3C%2Fxx%3E%0A+++"
+    "++++%3C%2Fxxxxx%3E%0A+++%3C%2Fxxx%3E%0A%3C%2Fxxx%3E%0A%0A%3Cxxx+xx%3D%"
+    "22xxxxxx%22%3E%3C%2Fxxx%3E%0A%0A%3C%2Fxxxx%3E%0A%3C%2Fxxxx%3E+&b=value";
   (void) argc; (void) argv;  /* Unused. Silent compiler warning. */
 
   num_errors = 0;
diff --git a/src/microhttpd/test_postprocessor_large.c 
b/src/microhttpd/test_postprocessor_large.c
index 0a821f09..9f7096fa 100644
--- a/src/microhttpd/test_postprocessor_large.c
+++ b/src/microhttpd/test_postprocessor_large.c
@@ -42,7 +42,7 @@ value_checker (void *cls,
                const char *transfer_encoding,
                const char *data, uint64_t off, size_t size)
 {
-  unsigned int *pos = cls;
+  size_t *pos = (size_t *) cls;
   (void) kind; (void) key; (void) filename; (void) content_type; /* Unused. 
Silent compiler warning. */
   (void) transfer_encoding; (void) data; (void) off;             /* Unused. 
Silent compiler warning. */
 #if 0
@@ -60,7 +60,7 @@ value_checker (void *cls,
 
 
 static int
-test_simple_large ()
+test_simple_large (void)
 {
   struct MHD_Connection connection;
   struct MHD_HTTP_Req_Header header;
@@ -69,7 +69,7 @@ test_simple_large ()
   size_t delta;
   size_t size;
   char data[102400];
-  unsigned int pos;
+  size_t pos;
 
   pos = 0;
   memset (data, 'A', sizeof (data));
diff --git a/src/microhttpd/test_postprocessor_md.c 
b/src/microhttpd/test_postprocessor_md.c
index 25a62d8c..afa00599 100644
--- a/src/microhttpd/test_postprocessor_md.c
+++ b/src/microhttpd/test_postprocessor_md.c
@@ -1,6 +1,7 @@
 /*
      This file is part of libmicrohttpd
      Copyright (C) 2020 Christian Grothoff
+     Copyright (C) 2020-2022 Evgeny Grin (Karlson2k)
 
      libmicrohttpd is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -18,20 +19,31 @@
      Boston, MA 02110-1301, USA.
 */
 /**
- * @file test_postprocessor.c
+ * @file test_postprocessor_md.c
  * @brief  Testcase for postprocessor, keys with no value
  * @author Markus Doppelbauer
+ * @author Karlson2k (Evgeny Grin)
  */
-#include "MHD_config.h"
+#include "mhd_options.h"
 #include <stdio.h>
+#ifdef HAVE_STDLIB_H
 #include <stdlib.h>
-#include <microhttpd.h>
+#endif /* HAVE_STDLIB_H */
+#include "microhttpd.h"
+#include "internal.h"
+#include "postprocessor.h"
+#if 0
+#include "mhd_panic.c"
+#include "mhd_str.c"
+#include "internal.c"
+#endif
+
 
 #define DEBUG 0
 
-#define ARRAY_LENGTH(array)     (sizeof(array) / sizeof(array[0]))
+/* local replacement for MHD functions */
 
-enum MHD_Result
+_MHD_EXTERN enum MHD_Result
 MHD_lookup_connection_value_n (struct MHD_Connection *connection,
                                enum MHD_ValueKind kind,
                                const char *key,
@@ -40,15 +52,16 @@ MHD_lookup_connection_value_n (struct MHD_Connection 
*connection,
                                size_t *value_size_ptr)
 {
   (void) connection; (void) kind; (void) key; /* Mute compiler warnings */
-  (void) key_size; (void) value_ptr; (void) value_size_ptr;
+  (void) key_size;
+
+  *value_ptr = "";
+  if (NULL != value_size_ptr)
+    *value_size_ptr = 0;
   return MHD_NO;
 }
 
 
-#include "mhd_panic.c"
-#include "mhd_str.c"
-#include "internal.c"
-#include "postprocessor.c"
+#define ARRAY_LENGTH(array)     (sizeof(array) / sizeof(array[0]))
 
 
 static unsigned int found;
@@ -313,7 +326,183 @@ main (int argc, char *argv[])
         "xxxxxxxxxxxxxxxxxxx%2C%2Cxx%2C%2Cx%2Cxx%2C%2Cxxxx%2Cxxx"
         
"%2C%2Cx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
         
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-        
"xxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxx
 [...]
+        
"xxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C"
+        
"%2Cxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxx%2Cxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"x%2C%2C%2C%2C%2C%2C%2Cxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xx%2Cxxxxx%2Cxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxx%2Cxxxxx%2Cxxxxxxxxx%2Cxxxxxxx%2Cxxxxxxxxxxxxxxxxxxx%2C%2Cxxxxx"
+        
"xx%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxx%2Cxxxxxxxxxxx"
+        
"xxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cx%2Cx%2Cxxxxxxxxxxxxxxxxxxxxxx%2Cxxxx"
+        
"xxxxxx%2Cxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxx%2Cxx%2Cx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxx%2Cxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxx%2Cxxxxxxxxxxxxxxxxx%2"
+        
"Cxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxx%2Cxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxx%2Cx"
+        
"xxxxxxxx%2Cxxxxxx%2Cxxxxxxxxx%2Cxxxxxxx%2Cxxxxx%2Cxxxxxxxxxxxxxxxxxxxx"
+        
"%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C"
+        
"%2C%2C%2C%2C%2Cxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%"
+        
"2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxx%2Cxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C"
+        
"%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2"
+        
"Cxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxx%2C%2Cxxxxxxxxxxxx%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2"
+        
"C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%"
+        
"2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxx%2Cxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxx%2Cx%2Cxxxxxxxxx"
+        
"xxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxx%2Cxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2Cxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxx%2"
+        
"Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2"
+        
"C%2C%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxx%2Cx%2C%"
+        
"2Cx%2Cxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxx%2Cxxxxxxxxxx%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxx%2Cxxxx%2Cx"
+        
"xxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2Cxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxx"
+        
"xxx%2Cxxxxxxxxxxxxxxxxxx%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxx%2Cxxxxxxxxxx%2Cxxxxxxxxxxx%2C%2C%2Cxxxxxxxxxxxxxxxxxxxx%2Cx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cx"
+        
"xxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxx"
+        
"xx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxx"
+        
"xxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C"
+        
"%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxx"
+        
"xxxxxx%2Cxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxx"
+        
"xxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2C"
+        
"xxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxx"
+        
"xxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxx%2Cxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxx%2"
+        
"Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxx%2Cxxxxxxxxxxxx%2Cxxxx"
+        
"xxx%2Cxxxxxxxxxxxx%2Cxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxx%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxx%2Cxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxx%2Cx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxx"
+        
"xxxxxxxxxxx%2Cxxxxxxxxxx%2Cxxxxxxxxx%2Cxxxxxxx%2Cxxxxxxxxxx%2Cxxxxxxxx"
+        
"xxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxx%2Cxxxxxxxx%2Cxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxx"
+        
"xxxxxxxxx%2Cxxxxx%2Cxxxx%2Cxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cx"
+        
"xxxxxxxxxxxxxxx%2Cx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxx%2Cx%2Cxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxx%2Cx%2Cxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%"
+        
"2Cxxxxx%2Cxx%2Cxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxx%2Cxxxxxx%"
+        
"2Cxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxx%2Cxxx"
+        
"xx%2Cxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxx%2Cxxxxxxxxxxxx"
+        
"xxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%"
+        
"2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxx%2Cxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxx%2Cx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxx%2Cxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxxxx"
+        
"x%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxx"
+        
"xxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C"
+        
"%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxx%2C%2C%2C%2Cxxxxxxx"
+        
"xxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%"
+        
"2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxx"
+        
"xxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxx%2C%2C%2Cxxxxxxxxxx%2Cxxx"
+        
"xxxx%2Cxxxxxxxxx%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxx%"
+        "2C%2C%2Cxxxxxxxxx%2Cxxxxxxxx%2C"
         "&y=y&z=z";
 
       if (MHD_YES != MHD_post_process (postprocessor, chunk, strlen (chunk) ))
@@ -330,10 +519,153 @@ main (int argc, char *argv[])
   if (1)
   {
     const char *chunks[] = {
-      
"t=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2Cxxxxx%2C%2Cx%2Cxxxxxxxxxxxxxxxxxxxx%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxx%2Cxxxxxxxxxxxxxxxx%2Cxxxxx%2Cxxxxxxx%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2Cxx%2C%2Cx%2Cxx%2C%2Cxxxx%2Cxxx%2C%2Cx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxx
 [...]
+      "t=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2Cxxxxx%2C%2Cx%2Cxxxxxxxx"
+      "xxxxxxxxxxxx%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxx%2Cxxxxxxxxxxxxxxxx%2Cxxxxx%"
+      "2Cxxxxxxx%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2Cxx%2C%2Cx%2"
+      "Cxx%2C%2Cxxxx%2Cxxx%2C%2Cx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "x%2C%2C%2C%2C%2C%2C%2Cxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2"
+      "Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxx%2C%2C%2C%2Cxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxx%2Cxxxxx%2Cxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxx%2Cxxxxxxxxx%2Cxxxxxxx%2Cxxxxxxxxxxx"
+      "xxxxxxxx%2C%2Cxxxxxxx%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxx"
+      "xxxxx%2Cxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cx%2Cx%2Cxxxxxxxxxx"
+      "xxxxxxxxxxxx%2Cxxxxxxxxxx%2Cxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xx%2Cxxxxx%2Cxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxx%2Cxxxx"
+      "xxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxx%2C"
+      "xxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C"
+      "%2C%2C%2C%2Cxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxx%2Cxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxx%2Cxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C"
+      "%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cxx"
+      "xxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxx%2C%2Cxxxxxxxxxxxx%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2"
+      "C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxx%2Cxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxx%2Cx%2Cxxxxxxxxxxxx"
+      "xxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxx%2Cxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2Cxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxx%2Cxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2"
+      "C%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxx%2Cxxxxxxxxx",
       /* one chunk: second line is dropped */
-      
"yyyyyyyyyyyyyyyyyyyyyyyyyyyyyxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxx%2Cx%2C%2Cx%2Cxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxx%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxx%2Cxxxx%2Cxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2
 [...]
-      
"%E2%80%A2MMMMMMMM%2C%2C%2C%2CMMMMMMMMMMMMMMMMMMMM%2CMMMMMMMMMMMMMMMMMMMMMMM%2CMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM%2C%2C%2C%2CMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM%2CMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM%2CM
 [...]
+      "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C"
+      "xxxxxxxxxxxxxxxx%2Cx%2C%2Cx%2Cxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2Cxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxx%2C%2C%2Cxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxx"
+      "xxxxxxxxxxxxx%2Cxxxx%2Cxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2Cxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2Cx%2C%2C"
+      "%2C%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxx%2Cxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%"
+      "2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxx"
+      "xxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "x%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxxxxxx%2C%2C%2C%2C"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxx%2Cxxxxxxx"
+      "xxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxxxxxxxxxx"
+      "%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxx"
+      "x%2Cxxxxxxxxxxxx%2Cxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxx%2Cxxxxxxxxxxxx%2Cxxxxxxx%2Cxxxxxxxxxx"
+      "xx%2Cxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxx%2Cxxxxxx%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxx%2Cxx%2Cxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxx%2Cxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%"
+      "2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxx%2Cxx"
+      "xxxxxxxx%2Cxxxxxxxxx%2Cxxxxxxx%2Cxxxxxxxxxx%2Cxxxxxxxxxxxxxx%2Cxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxx%2Cxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxx%2Cxxxx"
+      "x%2Cxxxx%2Cxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxx%"
+      "2Cx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxx%2Cx%2Cxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xx%2Cx%2Cxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxx%2Cxx%2Cx"
+      "xxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxx%2Cxxxxxx%2Cxxxxxxxxxxxxxx"
+      "xxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%"
+      "2C%2C%2C%2Cxxxxxxxxxxx%2C%2Cxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxx%2Cxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2"
+      "Cxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxx"
+      "xxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2"
+      "C%2C%2C%2C%2C%2C%2Cxxxxxxxxxxx%2C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%2C%2C%2C%2C%2C%2C%2Cxxxxxxxxxxxxxx%2"
+      "C%2C%2C%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxx%2Cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+      "xxxxxxxxxxxxxxxxxxxxxxxxxZZZZZZZZZZZZZ%2C%2C%2C%2C"
+      "%E2%80%A2MMMMMMMM%2C%2C%2C%2CMMMMMMMMMMMMMMMMMMMM%2CMMMMMMMMMMMMMMMMMM"
+      "MMMMM%2CMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM"
+      "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM"
+      "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM"
+      "MMMMMMMMMMMMMMMMMMMMMMMMMM%2C%2C%2C%2CMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM"
+      "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM%2CMMMMMMMMMMMMMMMMMMMM"
+      "MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM%2CMMMMMM"
+      "MMMMMMMMMMMMMMMMMMMMMMMMMMMM"
       "zz",
       "",
     };
@@ -362,7 +694,13 @@ main (int argc, char *argv[])
   if (1)
   {
     const char *chunks[] = {
-      
"XXXXXXXXXXXX=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX&XXXXXX=&XXXXXXXXXXXXXX=XXXX+&XXXXXXXXXXXXXXX=XXXXXXXXX&XXXXXXXXXXXXX=XXXX%XX%XXXXXX&XXXXXXXXXXX=XXXXXXXXX&XXXXXXXXXXXXX=XXXXXXXXXX&XXXXXXXXXXXXXXX=XX&XXXXXXXXXXXXXXX=XXXXXXXXX&XXXXXXXXXXXXX=XXXXXX&XXXXXXXXXXX=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
+      "XXXXXXXXXXXX=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+      "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX&XXXXXX=&XXXXXXXXXXXXXX=X"
+      "XXX+&XXXXXXXXXXXXXXX=XXXXXXXXX&XXXXXXXXXXXXX=XXXX%XX%XXXXXX&XXXXXXXXXX"
+      "X=XXXXXXXXX&XXXXXXXXXXXXX=XXXXXXXXXX&XXXXXXXXXXXXXXX=XX&XXXXXXXXXXXXXX"
+      "X=XXXXXXXXX&XXXXXXXXXXXXX=XXXXXX&XXXXXXXXXXX=XXXXXXXXXXXXXXXXXXXXXXXXX"
+      "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+      "XXXXXXXXXX",
       "&XXXXXXXX=XXXX",
       "",
     };
diff --git a/src/microhttpd/test_start_stop.c b/src/microhttpd/test_start_stop.c
index fec35e2c..a64f3011 100644
--- a/src/microhttpd/test_start_stop.c
+++ b/src/microhttpd/test_start_stop.c
@@ -53,14 +53,14 @@ ahc_echo (void *cls,
 
 
 #if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
-static int
-testInternalGet (int poll_flag)
+static unsigned int
+testInternalGet (unsigned int poll_flag)
 {
   struct MHD_Daemon *d;
 
   d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG
                         | poll_flag,
-                        0, NULL, NULL, &ahc_echo, "GET", MHD_OPTION_END);
+                        0, NULL, NULL, &ahc_echo, NULL, MHD_OPTION_END);
   if (d == NULL)
     return 1;
   MHD_stop_daemon (d);
@@ -68,15 +68,15 @@ testInternalGet (int poll_flag)
 }
 
 
-static int
-testMultithreadedGet (int poll_flag)
+static unsigned int
+testMultithreadedGet (unsigned int poll_flag)
 {
   struct MHD_Daemon *d;
 
   d = MHD_start_daemon (MHD_USE_THREAD_PER_CONNECTION
                         | MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG
                         | poll_flag,
-                        0, NULL, NULL, &ahc_echo, "GET", MHD_OPTION_END);
+                        0, NULL, NULL, &ahc_echo, NULL, MHD_OPTION_END);
   if (d == NULL)
     return 2;
   MHD_stop_daemon (d);
@@ -84,14 +84,14 @@ testMultithreadedGet (int poll_flag)
 }
 
 
-static int
-testMultithreadedPoolGet (int poll_flag)
+static unsigned int
+testMultithreadedPoolGet (unsigned int poll_flag)
 {
   struct MHD_Daemon *d;
 
   d = MHD_start_daemon (MHD_USE_INTERNAL_POLLING_THREAD | MHD_USE_ERROR_LOG
                         | poll_flag,
-                        0, NULL, NULL, &ahc_echo, "GET",
+                        0, NULL, NULL, &ahc_echo, NULL,
                         MHD_OPTION_THREAD_POOL_SIZE, MHD_CPU_COUNT,
                         MHD_OPTION_END);
   if (d == NULL)
@@ -104,14 +104,14 @@ testMultithreadedPoolGet (int poll_flag)
 #endif
 
 
-static int
-testExternalGet ()
+static unsigned int
+testExternalGet (void)
 {
   struct MHD_Daemon *d;
 
   d = MHD_start_daemon (MHD_USE_ERROR_LOG,
                         0, NULL, NULL,
-                        &ahc_echo, "GET",
+                        &ahc_echo, NULL,
                         MHD_OPTION_END);
   if (NULL == d)
     return 8;
@@ -151,5 +151,5 @@ main (int argc,
     fprintf (stderr,
              "Error (code: %u)\n",
              errorCount);
-  return errorCount != 0;       /* 0 == pass */
+  return (errorCount == 0) ? 0 : 1;       /* 0 == pass */
 }
diff --git a/src/microhttpd/test_str.c b/src/microhttpd/test_str.c
index 341585a2..75f8092b 100644
--- a/src/microhttpd/test_str.c
+++ b/src/microhttpd/test_str.c
@@ -35,6 +35,9 @@
 #define PRIX64 "llX"
 #endif /* ! HAVE_INTTYPES_H */
 #include <stdint.h>
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif /* HAVE_STDLIB_H */
 #include "mhd_limits.h"
 #include "mhd_str.h"
 #include "test_helpers.h"
@@ -208,11 +211,14 @@ static const unsigned int locale_name_count = 
sizeof(locale_names)
  *  Helper functions
  */
 
-int
-set_test_locale (unsigned int num)
+static int
+set_test_locale (size_t num)
 {
   if (num >= locale_name_count)
-    return -1;
+  {
+    fprintf (stderr, "Unexpected number of locale.\n");
+    exit (99);
+  }
   if (verbose > 2)
     printf ("Setting locale \"%s\":", locale_names[num]);
   if (setlocale (LC_ALL, locale_names[num]))
@@ -227,7 +233,7 @@ set_test_locale (unsigned int num)
 }
 
 
-const char *
+static const char *
 get_current_locale_str (void)
 {
   char const *loc_str = setlocale (LC_ALL, NULL);
@@ -239,7 +245,7 @@ static char tmp_bufs[4][4 * 1024]; /* should be enough for 
testing */
 static size_t buf_idx = 0;
 
 /* print non-printable chars as char codes */
-char *
+static char *
 n_prnt (const char *str)
 {
   static char *buf;  /* should be enough for testing */
@@ -258,10 +264,10 @@ n_prnt (const char *str)
       if (w_pos + 2 >= buf_size)
         break;
       buf[w_pos++] = '\\';
-      buf[w_pos++] = c;
+      buf[w_pos++] = (char) c;
     }
     else if ((c >= 0x20) && (c <= 0x7E) )
-      buf[w_pos++] = c;
+      buf[w_pos++] = (char) c;
     else
     {
       if (w_pos + 4 >= buf_size)
@@ -502,7 +508,7 @@ static const struct two_neq_strs neq_strings[] = {
 };
 
 
-int
+static size_t
 check_eq_strings (void)
 {
   size_t t_failed = 0;
@@ -549,7 +555,7 @@ check_eq_strings (void)
 }
 
 
-int
+static size_t
 check_neq_strings (void)
 {
   size_t t_failed = 0;
@@ -596,7 +602,7 @@ check_neq_strings (void)
 }
 
 
-int
+static size_t
 check_eq_strings_n (void)
 {
   size_t t_failed = 0;
@@ -649,7 +655,7 @@ check_eq_strings_n (void)
 }
 
 
-int
+static size_t
 check_neq_strings_n (void)
 {
   size_t t_failed = 0;
@@ -675,7 +681,7 @@ check_neq_strings_n (void)
                                                                      int) t->
                  dif_pos,
                  (unsigned int) t->s1.len, (unsigned int) t->s2.len);
-        return -1;
+        exit (99);
       }
       if (t->dif_pos > t->s1.len)
       {
@@ -684,7 +690,7 @@ check_neq_strings_n (void)
                  "equal to s1.len (%u).\n", (unsigned int) i, (unsigned
                                                                int) t->dif_pos,
                  (unsigned int) t->s1.len);
-        return -1;
+        exit (99);
       }
       if (t->dif_pos > t->s2.len)
       {
@@ -693,7 +699,7 @@ check_neq_strings_n (void)
                  "equal to s2.len (%u).\n", (unsigned int) i, (unsigned
                                                                int) t->dif_pos,
                  (unsigned int) t->s2.len);
-        return -1;
+        exit (99);
       }
       for (k = 0; k <= m_len + 1 && ! c_failed[i]; k++)
       {
@@ -769,21 +775,16 @@ check_neq_strings_n (void)
 /*
  * Run eq/neq strings tests
  */
-int
+static int
 run_eq_neq_str_tests (void)
 {
-  int str_equal_caseless_fails = 0;
-  int str_equal_caseless_n_fails = 0;
-  int res;
+  size_t str_equal_caseless_fails = 0;
+  size_t str_equal_caseless_n_fails = 0;
+  size_t res;
 
   res = check_eq_strings ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr, "ERROR: test internal error in check_eq_strings().\n");
-      return 99;
-    }
     str_equal_caseless_fails += res;
     fprintf (stderr, "FAILED: testcase check_eq_strings() failed.\n\n");
   }
@@ -793,11 +794,6 @@ run_eq_neq_str_tests (void)
   res = check_neq_strings ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr, "ERROR: test internal error in check_neq_strings().\n");
-      return 99;
-    }
     str_equal_caseless_fails += res;
     fprintf (stderr, "FAILED: testcase check_neq_strings() failed.\n\n");
   }
@@ -806,8 +802,9 @@ run_eq_neq_str_tests (void)
 
   if (str_equal_caseless_fails)
     fprintf (stderr,
-             "FAILED: function MHD_str_equal_caseless_() failed %d 
time%s.\n\n",
-             str_equal_caseless_fails, str_equal_caseless_fails == 1 ? "" :
+             "FAILED: function MHD_str_equal_caseless_() failed %lu 
time%s.\n\n",
+             (unsigned long) str_equal_caseless_fails,
+             str_equal_caseless_fails == 1 ? "" :
              "s");
   else if (verbose > 0)
     printf (
@@ -816,11 +813,6 @@ run_eq_neq_str_tests (void)
   res = check_eq_strings_n ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr, "ERROR: test internal error in 
check_eq_strings_n().\n");
-      return 99;
-    }
     str_equal_caseless_n_fails += res;
     fprintf (stderr, "FAILED: testcase check_eq_strings_n() failed.\n\n");
   }
@@ -830,12 +822,6 @@ run_eq_neq_str_tests (void)
   res = check_neq_strings_n ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in check_neq_strings_n().\n");
-      return 99;
-    }
     str_equal_caseless_n_fails += res;
     fprintf (stderr, "FAILED: testcase check_neq_strings_n() failed.\n\n");
   }
@@ -844,8 +830,9 @@ run_eq_neq_str_tests (void)
 
   if (str_equal_caseless_n_fails)
     fprintf (stderr,
-             "FAILED: function MHD_str_equal_caseless_n_() failed %d 
time%s.\n\n",
-             str_equal_caseless_n_fails, str_equal_caseless_n_fails == 1 ? "" :
+             "FAILED: function MHD_str_equal_caseless_n_() failed %lu 
time%s.\n\n",
+             (unsigned long) str_equal_caseless_n_fails,
+             str_equal_caseless_n_fails == 1 ? "" :
              "s");
   else if (verbose > 0)
     printf (
@@ -1133,7 +1120,7 @@ const struct str_with_len strx_ovflw[] = {
 };
 
 
-int
+static size_t
 check_str_to_uint64_valid (void)
 {
   size_t t_failed = 0;
@@ -1164,7 +1151,7 @@ check_str_to_uint64_valid (void)
                  (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned
                                                                    int) t->str.
                  len);
-        return -1;
+        exit (99);
       }
       rv = 9435223;     /* some random value */
       rs = MHD_str_to_uint64_ (t->str.str, &rv);
@@ -1201,7 +1188,7 @@ check_str_to_uint64_valid (void)
 }
 
 
-int
+static size_t
 check_str_to_uint64_all_chars (void)
 {
   static const size_t n_checks = 256; /* from 0 to 255 */
@@ -1268,7 +1255,7 @@ check_str_to_uint64_all_chars (void)
 }
 
 
-int
+static size_t
 check_str_to_uint64_overflow (void)
 {
   size_t t_failed = 0;
@@ -1326,7 +1313,7 @@ check_str_to_uint64_overflow (void)
 }
 
 
-int
+static size_t
 check_str_to_uint64_no_val (void)
 {
   size_t t_failed = 0;
@@ -1384,7 +1371,7 @@ check_str_to_uint64_no_val (void)
 }
 
 
-int
+static size_t
 check_str_to_uint64_n_valid (void)
 {
   size_t t_failed = 0;
@@ -1413,7 +1400,7 @@ check_str_to_uint64_n_valid (void)
                  (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned
                                                                    int) t->str.
                  len);
-        return -1;
+        exit (99);
       }
       for (len = t->num_of_digt; len <= t->str.len + 1 && ! c_failed[i]; len++)
       {
@@ -1456,7 +1443,7 @@ check_str_to_uint64_n_valid (void)
 }
 
 
-int
+static size_t
 check_str_to_uint64_n_all_chars (void)
 {
   static const size_t n_checks = 256; /* from 0 to 255 */
@@ -1533,7 +1520,7 @@ check_str_to_uint64_n_all_chars (void)
 }
 
 
-int
+static size_t
 check_str_to_uint64_n_overflow (void)
 {
   size_t t_failed = 0;
@@ -1602,7 +1589,7 @@ check_str_to_uint64_n_overflow (void)
 }
 
 
-int
+static size_t
 check_str_to_uint64_n_no_val (void)
 {
   size_t t_failed = 0;
@@ -1670,7 +1657,7 @@ check_str_to_uint64_n_no_val (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint32_valid (void)
 {
   size_t t_failed = 0;
@@ -1704,7 +1691,7 @@ check_strx_to_uint32_valid (void)
                  (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned
                                                                    int) t->str.
                  len);
-        return -1;
+        exit (99);
       }
       rv = 1458532;     /* some random value */
       rs = MHD_strx_to_uint32_ (t->str.str, &rv);
@@ -1743,7 +1730,7 @@ check_strx_to_uint32_valid (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint32_all_chars (void)
 {
   static const size_t n_checks = 256; /* from 0 to 255 */
@@ -1815,7 +1802,7 @@ check_strx_to_uint32_all_chars (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint32_overflow (void)
 {
   size_t t_failed = 0;
@@ -1891,7 +1878,7 @@ check_strx_to_uint32_overflow (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint32_no_val (void)
 {
   size_t t_failed = 0;
@@ -1950,7 +1937,7 @@ check_strx_to_uint32_no_val (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint32_n_valid (void)
 {
   size_t t_failed = 0;
@@ -1982,7 +1969,7 @@ check_strx_to_uint32_n_valid (void)
                  (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned
                                                                    int) t->str.
                  len);
-        return -1;
+        exit (99);
       }
       for (len = t->num_of_digt; len <= t->str.len + 1 && ! c_failed[i]; len++)
       {
@@ -2027,7 +2014,7 @@ check_strx_to_uint32_n_valid (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint32_n_all_chars (void)
 {
   static const size_t n_checks = 256; /* from 0 to 255 */
@@ -2109,7 +2096,7 @@ check_strx_to_uint32_n_all_chars (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint32_n_overflow (void)
 {
   size_t t_failed = 0;
@@ -2154,7 +2141,7 @@ check_strx_to_uint32_n_overflow (void)
                    (unsigned int) (i - n_checks1), (unsigned
                                                     int) t->num_of_digt,
                    (unsigned int) t->str.len);
-          return -1;
+          exit (99);
         }
         str = t->str.str;
         min_len = t->num_of_digt;
@@ -2211,7 +2198,7 @@ check_strx_to_uint32_n_overflow (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint32_n_no_val (void)
 {
   size_t t_failed = 0;
@@ -2280,7 +2267,7 @@ check_strx_to_uint32_n_no_val (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint64_valid (void)
 {
   size_t t_failed = 0;
@@ -2311,7 +2298,7 @@ check_strx_to_uint64_valid (void)
                  (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned
                                                                    int) t->str.
                  len);
-        return -1;
+        exit (99);
       }
       rv = 1458532;     /* some random value */
       rs = MHD_strx_to_uint64_ (t->str.str, &rv);
@@ -2349,7 +2336,7 @@ check_strx_to_uint64_valid (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint64_all_chars (void)
 {
   static const size_t n_checks = 256; /* from 0 to 255 */
@@ -2420,7 +2407,7 @@ check_strx_to_uint64_all_chars (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint64_overflow (void)
 {
   size_t t_failed = 0;
@@ -2478,7 +2465,7 @@ check_strx_to_uint64_overflow (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint64_no_val (void)
 {
   size_t t_failed = 0;
@@ -2536,7 +2523,7 @@ check_strx_to_uint64_no_val (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint64_n_valid (void)
 {
   size_t t_failed = 0;
@@ -2565,7 +2552,7 @@ check_strx_to_uint64_n_valid (void)
                  (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned
                                                                    int) t->str.
                  len);
-        return -1;
+        exit (99);
       }
       for (len = t->num_of_digt; len <= t->str.len + 1 && ! c_failed[i]; len++)
       {
@@ -2609,7 +2596,7 @@ check_strx_to_uint64_n_valid (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint64_n_all_chars (void)
 {
   static const size_t n_checks = 256; /* from 0 to 255 */
@@ -2691,7 +2678,7 @@ check_strx_to_uint64_n_all_chars (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint64_n_overflow (void)
 {
   size_t t_failed = 0;
@@ -2761,7 +2748,7 @@ check_strx_to_uint64_n_overflow (void)
 }
 
 
-int
+static size_t
 check_strx_to_uint64_n_no_val (void)
 {
   size_t t_failed = 0;
@@ -2830,26 +2817,20 @@ check_strx_to_uint64_n_no_val (void)
 }
 
 
-int
+static int
 run_str_to_X_tests (void)
 {
-  int str_to_uint64_fails = 0;
-  int str_to_uint64_n_fails = 0;
-  int strx_to_uint32_fails = 0;
-  int strx_to_uint32_n_fails = 0;
-  int strx_to_uint64_fails = 0;
-  int strx_to_uint64_n_fails = 0;
-  int res;
+  size_t str_to_uint64_fails = 0;
+  size_t str_to_uint64_n_fails = 0;
+  size_t strx_to_uint32_fails = 0;
+  size_t strx_to_uint32_n_fails = 0;
+  size_t strx_to_uint64_fails = 0;
+  size_t strx_to_uint64_n_fails = 0;
+  size_t res;
 
   res = check_str_to_uint64_valid ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in check_str_to_uint64_valid().\n");
-      return 99;
-    }
     str_to_uint64_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_str_to_uint64_valid() failed.\n\n");
@@ -2861,12 +2842,6 @@ run_str_to_X_tests (void)
   res = check_str_to_uint64_all_chars ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_str_to_uint64_all_chars().\n");
-      return 99;
-    }
     str_to_uint64_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_str_to_uint64_all_chars() failed.\n\n");
@@ -2878,12 +2853,6 @@ run_str_to_X_tests (void)
   res = check_str_to_uint64_overflow ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_str_to_uint64_overflow().\n");
-      return 99;
-    }
     str_to_uint64_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_str_to_uint64_overflow() failed.\n\n");
@@ -2895,12 +2864,6 @@ run_str_to_X_tests (void)
   res = check_str_to_uint64_no_val ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_str_to_uint64_no_val().\n");
-      return 99;
-    }
     str_to_uint64_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_str_to_uint64_no_val() failed.\n\n");
@@ -2911,8 +2874,9 @@ run_str_to_X_tests (void)
 
   if (str_to_uint64_fails)
     fprintf (stderr,
-             "FAILED: function MHD_str_to_uint64_() failed %d time%s.\n\n",
-             str_to_uint64_fails, str_to_uint64_fails == 1 ? "" : "s");
+             "FAILED: function MHD_str_to_uint64_() failed %lu time%s.\n\n",
+             (unsigned long) str_to_uint64_fails,
+             str_to_uint64_fails == 1 ? "" : "s");
   else if (verbose > 0)
     printf (
       "PASSED: function MHD_str_to_uint64_() successfully passed all 
checks.\n\n");
@@ -2920,12 +2884,6 @@ run_str_to_X_tests (void)
   res = check_str_to_uint64_n_valid ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_str_to_uint64_n_valid().\n");
-      return 99;
-    }
     str_to_uint64_n_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_str_to_uint64_n_valid() failed.\n\n");
@@ -2937,12 +2895,6 @@ run_str_to_X_tests (void)
   res = check_str_to_uint64_n_all_chars ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_str_to_uint64_n_all_chars().\n");
-      return 99;
-    }
     str_to_uint64_n_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_str_to_uint64_n_all_chars() failed.\n\n");
@@ -2954,12 +2906,6 @@ run_str_to_X_tests (void)
   res = check_str_to_uint64_n_overflow ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_str_to_uint64_n_overflow().\n");
-      return 99;
-    }
     str_to_uint64_n_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_str_to_uint64_n_overflow() failed.\n\n");
@@ -2971,12 +2917,6 @@ run_str_to_X_tests (void)
   res = check_str_to_uint64_n_no_val ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_str_to_uint64_n_no_val().\n");
-      return 99;
-    }
     str_to_uint64_n_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_str_to_uint64_n_no_val() failed.\n\n");
@@ -2987,8 +2927,9 @@ run_str_to_X_tests (void)
 
   if (str_to_uint64_n_fails)
     fprintf (stderr,
-             "FAILED: function MHD_str_to_uint64_n_() failed %d time%s.\n\n",
-             str_to_uint64_n_fails, str_to_uint64_n_fails == 1 ? "" : "s");
+             "FAILED: function MHD_str_to_uint64_n_() failed %lu time%s.\n\n",
+             (unsigned long) str_to_uint64_n_fails,
+             str_to_uint64_n_fails == 1 ? "" : "s");
   else if (verbose > 0)
     printf (
       "PASSED: function MHD_str_to_uint64_n_() successfully passed all 
checks.\n\n");
@@ -2996,12 +2937,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint32_valid ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint32_valid().\n");
-      return 99;
-    }
     strx_to_uint32_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint32_valid() failed.\n\n");
@@ -3013,12 +2948,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint32_all_chars ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint32_all_chars().\n");
-      return 99;
-    }
     strx_to_uint32_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint32_all_chars() failed.\n\n");
@@ -3030,12 +2959,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint32_overflow ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint32_overflow().\n");
-      return 99;
-    }
     strx_to_uint32_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint32_overflow() failed.\n\n");
@@ -3047,12 +2970,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint32_no_val ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint32_no_val().\n");
-      return 99;
-    }
     strx_to_uint32_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint32_no_val() failed.\n\n");
@@ -3063,8 +2980,9 @@ run_str_to_X_tests (void)
 
   if (strx_to_uint32_fails)
     fprintf (stderr,
-             "FAILED: function MHD_strx_to_uint32_() failed %d time%s.\n\n",
-             strx_to_uint32_fails, strx_to_uint32_fails == 1 ? "" : "s");
+             "FAILED: function MHD_strx_to_uint32_() failed %lu time%s.\n\n",
+             (unsigned long) strx_to_uint32_fails,
+             strx_to_uint32_fails == 1 ? "" : "s");
   else if (verbose > 0)
     printf (
       "PASSED: function MHD_strx_to_uint32_() successfully passed all 
checks.\n\n");
@@ -3072,12 +2990,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint32_n_valid ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint32_n_valid().\n");
-      return 99;
-    }
     strx_to_uint32_n_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint32_n_valid() failed.\n\n");
@@ -3089,12 +3001,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint32_n_all_chars ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint32_n_all_chars().\n");
-      return 99;
-    }
     strx_to_uint32_n_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint32_n_all_chars() 
failed.\n\n");
@@ -3106,12 +3012,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint32_n_overflow ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint32_n_overflow().\n");
-      return 99;
-    }
     strx_to_uint32_n_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint32_n_overflow() failed.\n\n");
@@ -3123,12 +3023,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint32_n_no_val ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint32_n_no_val().\n");
-      return 99;
-    }
     strx_to_uint32_n_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint32_n_no_val() failed.\n\n");
@@ -3139,8 +3033,9 @@ run_str_to_X_tests (void)
 
   if (strx_to_uint32_n_fails)
     fprintf (stderr,
-             "FAILED: function MHD_strx_to_uint32_n_() failed %d time%s.\n\n",
-             strx_to_uint32_n_fails, strx_to_uint32_n_fails == 1 ? "" : "s");
+             "FAILED: function MHD_strx_to_uint32_n_() failed %lu time%s.\n\n",
+             (unsigned long) strx_to_uint32_n_fails,
+             strx_to_uint32_n_fails == 1 ? "" : "s");
   else if (verbose > 0)
     printf (
       "PASSED: function MHD_strx_to_uint32_n_() successfully passed all 
checks.\n\n");
@@ -3148,12 +3043,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint64_valid ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint64_valid().\n");
-      return 99;
-    }
     strx_to_uint64_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint64_valid() failed.\n\n");
@@ -3165,12 +3054,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint64_all_chars ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint64_all_chars().\n");
-      return 99;
-    }
     strx_to_uint64_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint64_all_chars() failed.\n\n");
@@ -3182,12 +3065,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint64_overflow ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint64_overflow().\n");
-      return 99;
-    }
     strx_to_uint64_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint64_overflow() failed.\n\n");
@@ -3199,12 +3076,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint64_no_val ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint64_no_val().\n");
-      return 99;
-    }
     strx_to_uint64_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint64_no_val() failed.\n\n");
@@ -3215,8 +3086,9 @@ run_str_to_X_tests (void)
 
   if (strx_to_uint64_fails)
     fprintf (stderr,
-             "FAILED: function MHD_strx_to_uint64_() failed %d time%s.\n\n",
-             strx_to_uint64_fails, strx_to_uint64_fails == 1 ? "" : "s");
+             "FAILED: function MHD_strx_to_uint64_() failed %lu time%s.\n\n",
+             (unsigned long) strx_to_uint64_fails,
+             strx_to_uint64_fails == 1 ? "" : "s");
   else if (verbose > 0)
     printf (
       "PASSED: function MHD_strx_to_uint64_() successfully passed all 
checks.\n\n");
@@ -3224,12 +3096,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint64_n_valid ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint64_n_valid().\n");
-      return 99;
-    }
     strx_to_uint64_n_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint64_n_valid() failed.\n\n");
@@ -3241,12 +3107,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint64_n_all_chars ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint64_n_all_chars().\n");
-      return 99;
-    }
     strx_to_uint64_n_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint64_n_all_chars() 
failed.\n\n");
@@ -3258,12 +3118,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint64_n_overflow ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint64_n_overflow().\n");
-      return 99;
-    }
     strx_to_uint64_n_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint64_n_overflow() failed.\n\n");
@@ -3275,12 +3129,6 @@ run_str_to_X_tests (void)
   res = check_strx_to_uint64_n_no_val ();
   if (res != 0)
   {
-    if (res < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in 
check_strx_to_uint64_n_no_val().\n");
-      return 99;
-    }
     strx_to_uint64_n_fails += res;
     fprintf (stderr,
              "FAILED: testcase check_strx_to_uint64_n_no_val() failed.\n\n");
@@ -3291,8 +3139,9 @@ run_str_to_X_tests (void)
 
   if (strx_to_uint64_n_fails)
     fprintf (stderr,
-             "FAILED: function MHD_strx_to_uint64_n_() failed %d time%s.\n\n",
-             strx_to_uint64_n_fails, strx_to_uint64_n_fails == 1 ? "" : "s");
+             "FAILED: function MHD_strx_to_uint64_n_() failed %lu time%s.\n\n",
+             (unsigned long) strx_to_uint64_n_fails,
+             strx_to_uint64_n_fails == 1 ? "" : "s");
   else if (verbose > 0)
     printf (
       "PASSED: function MHD_strx_to_uint64_n_() successfully passed all 
checks.\n\n");
@@ -3314,7 +3163,7 @@ run_str_to_X_tests (void)
 }
 
 
-int
+static size_t
 check_str_from_uint16 (void)
 {
   size_t t_failed = 0;
@@ -3350,7 +3199,7 @@ check_str_from_uint16 (void)
                  (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned
                                                                    int) t->str.
                  len);
-        return -1;
+        exit (99);
       }
       if ('0' == t->str.str[0])
         continue;  /* Skip strings prefixed with zeros */
@@ -3364,14 +3213,15 @@ check_str_from_uint16 (void)
                  "ERROR: dstrs_w_values[%u] has too long (%u) string, "
                  "size of 'buf' should be increased.\n",
                  (unsigned int) i, (unsigned int) t->str.len);
-        return -1;
+        exit (99);
       }
+      rs = 0; /* Only to mute compiler warning */
       for (b_size = 0; b_size <= t->str.len + 1; ++b_size)
       {
         /* fill buffer with pseudo-random values */
         memcpy (buf, erase, sizeof(buf));
 
-        rs = MHD_uint16_to_str (t->val, buf, b_size);
+        rs = MHD_uint16_to_str ((uint16_t) t->val, buf, b_size);
 
         if (t->num_of_digt > b_size)
         {
@@ -3438,7 +3288,7 @@ check_str_from_uint16 (void)
 }
 
 
-int
+static size_t
 check_str_from_uint64 (void)
 {
   size_t t_failed = 0;
@@ -3474,7 +3324,7 @@ check_str_from_uint64 (void)
                  (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned
                                                                    int) t->str.
                  len);
-        return -1;
+        exit (99);
       }
       if ('0' == t->str.str[0])
         continue;  /* Skip strings prefixed with zeros */
@@ -3486,7 +3336,7 @@ check_str_from_uint64 (void)
                  "ERROR: dstrs_w_values[%u] has too long (%u) string, "
                  "size of 'buf' should be increased.\n",
                  (unsigned int) i, (unsigned int) t->str.len);
-        return -1;
+        exit (99);
       }
       for (b_size = 0; b_size <= t->str.len + 1; ++b_size)
       {
@@ -3560,7 +3410,7 @@ check_str_from_uint64 (void)
 }
 
 
-int
+static size_t
 check_strx_from_uint32 (void)
 {
   size_t t_failed = 0;
@@ -3596,7 +3446,7 @@ check_strx_from_uint32 (void)
                  (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned
                                                                    int) t->str.
                  len);
-        return -1;
+        exit (99);
       }
       if ('0' == t->str.str[0])
         continue;  /* Skip strings prefixed with zeros */
@@ -3610,14 +3460,15 @@ check_strx_from_uint32 (void)
                  "ERROR: dstrs_w_values[%u] has too long (%u) string, "
                  "size of 'buf' should be increased.\n",
                  (unsigned int) i, (unsigned int) t->str.len);
-        return -1;
+        exit (99);
       }
+      rs = 0; /* Only to mute compiler warning */
       for (b_size = 0; b_size <= t->str.len + 1; ++b_size)
       {
         /* fill buffer with pseudo-random values */
         memcpy (buf, erase, sizeof(buf));
 
-        rs = MHD_uint32_to_strx (t->val, buf, b_size);
+        rs = MHD_uint32_to_strx ((uint32_t) t->val, buf, b_size);
 
         if (t->num_of_digt > b_size)
         {
@@ -3667,7 +3518,7 @@ check_strx_from_uint32 (void)
                      "ERROR: dstrs_w_values[%u] has string with too many"
                      "(%u) digits, size of 'buf' should be increased.\n",
                      (unsigned int) i, (unsigned int) rs);
-            return -1;
+            exit (99);
           }
           else if (0 != memcmp (buf + rs, erase + rs, sizeof(buf) - rs))
           {
@@ -4474,12 +4325,12 @@ static const struct str_with_value duint8_w_values_p3[] 
= {
 static const struct str_with_value *duint8_w_values_p[3] =
 {duint8_w_values_p1, duint8_w_values_p2, duint8_w_values_p3};
 
-int
+static size_t
 check_str_from_uint8_pad (void)
 {
   int i;
-  int pad;
-  int t_failed = 0;
+  uint8_t pad;
+  size_t t_failed = 0;
 
   if ((256 != sizeof(duint8_w_values_p1) / sizeof(duint8_w_values_p1[0])) ||
       (256 != sizeof(duint8_w_values_p2) / sizeof(duint8_w_values_p2[0])) ||
@@ -4487,11 +4338,11 @@ check_str_from_uint8_pad (void)
   {
     fprintf (stderr,
              "ERROR: wrong number of items in duint8_w_values_p*.\n");
-    return -1;
+    exit (99);
   }
   for (pad = 0; pad <= 3; pad++)
   {
-    int table_num = pad - 1;
+    size_t table_num = pad - 1;
     if (0 == pad)
       table_num = 0;
 
@@ -4510,7 +4361,7 @@ check_str_from_uint8_pad (void)
                  (unsigned int) i, (unsigned int) t->num_of_digt, (unsigned
                                                                    int) t->str.
                  len);
-        return -1;
+        exit (99);
       }
       if (sizeof(buf) < t->str.len + 1)
       {
@@ -4518,14 +4369,14 @@ check_str_from_uint8_pad (void)
                  "ERROR: dstrs_w_values[%u] has too long (%u) string, "
                  "size of 'buf' should be increased.\n",
                  (unsigned int) i, (unsigned int) t->str.len);
-        return -1;
+        exit (99);
       }
       for (b_size = 0; b_size <= t->str.len + 1; ++b_size)
       {
         /* fill buffer with pseudo-random values */
         memset (buf, '#', sizeof(buf));
 
-        rs = MHD_uint8_to_str_pad (t->val, pad, buf, b_size);
+        rs = MHD_uint8_to_str_pad ((uint8_t) t->val, pad, buf, b_size);
 
         if (t->num_of_digt > b_size)
         {
@@ -4581,26 +4432,20 @@ check_str_from_uint8_pad (void)
 }
 
 
-int
+static int
 run_str_from_X_tests (void)
 {
-  int str_from_uint16;
-  int str_from_uint64;
-  int strx_from_uint32;
-  int str_from_uint8_pad;
-  int failures;
+  size_t str_from_uint16;
+  size_t str_from_uint64;
+  size_t strx_from_uint32;
+  size_t str_from_uint8_pad;
+  size_t failures;
 
   failures = 0;
 
   str_from_uint16 = check_str_from_uint16 ();
   if (str_from_uint16 != 0)
   {
-    if (str_from_uint16 < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in check_str_from_uint16().\n");
-      return 99;
-    }
     fprintf (stderr,
              "FAILED: testcase check_str_from_uint16() failed.\n\n");
     failures += str_from_uint16;
@@ -4612,12 +4457,6 @@ run_str_from_X_tests (void)
   str_from_uint64 = check_str_from_uint64 ();
   if (str_from_uint64 != 0)
   {
-    if (str_from_uint64 < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in check_str_from_uint16().\n");
-      return 99;
-    }
     fprintf (stderr,
              "FAILED: testcase check_str_from_uint16() failed.\n\n");
     failures += str_from_uint64;
@@ -4628,12 +4467,6 @@ run_str_from_X_tests (void)
   strx_from_uint32 = check_strx_from_uint32 ();
   if (strx_from_uint32 != 0)
   {
-    if (strx_from_uint32 < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in check_strx_from_uint32().\n");
-      return 99;
-    }
     fprintf (stderr,
              "FAILED: testcase check_strx_from_uint32() failed.\n\n");
     failures += strx_from_uint32;
@@ -4645,12 +4478,6 @@ run_str_from_X_tests (void)
   str_from_uint8_pad = check_str_from_uint8_pad ();
   if (str_from_uint8_pad != 0)
   {
-    if (str_from_uint8_pad < 0)
-    {
-      fprintf (stderr,
-               "ERROR: test internal error in check_str_from_uint8_pad().\n");
-      return 99;
-    }
     fprintf (stderr,
              "FAILED: testcase check_str_from_uint8_pad() failed.\n\n");
     failures += str_from_uint8_pad;
diff --git a/src/microhttpd/test_str_token.c b/src/microhttpd/test_str_token.c
index 1e1eab28..fe7b111c 100644
--- a/src/microhttpd/test_str_token.c
+++ b/src/microhttpd/test_str_token.c
@@ -61,7 +61,7 @@ expect_not_found_n (const char *str, const char *token, 
size_t token_len)
 #define expect_not_found(s,t) expect_not_found_n ((s),(t),MHD_STATICSTR_LEN_ ( 
\
                                                     t))
 
-int
+static int
 check_match (void)
 {
   int errcount = 0;
@@ -89,7 +89,7 @@ check_match (void)
 }
 
 
-int
+static int
 check_not_match (void)
 {
   int errcount = 0;
diff --git a/src/microhttpd/test_str_token_remove.c 
b/src/microhttpd/test_str_token_remove.c
index a4f7ae55..3e9b61ef 100644
--- a/src/microhttpd/test_str_token_remove.c
+++ b/src/microhttpd/test_str_token_remove.c
@@ -56,7 +56,8 @@ expect_result_n (const char *str, size_t str_len,
     ssize_t result_len;
     memset (buf_out, '$', sizeof(buf_out));
 
-    result_len = buf_len;
+    result_len = (ssize_t) buf_len;
+    mhd_assert (0 <= result_len);
 
     res = MHD_str_remove_token_caseless_ (buf_in, str_len, buf_token, 
token_len,
                                           buf_out, &result_len);
@@ -79,7 +80,7 @@ expect_result_n (const char *str, size_t str_len,
       if ( (expected_removed != res) ||
            (expected_len != (size_t) result_len) ||
            ((0 != result_len) && (0 != memcmp (expected, buf_out,
-                                               result_len))) ||
+                                               (size_t) result_len))) ||
            ('$' != buf_out[result_len]))
       {
         fprintf (stderr,
@@ -104,7 +105,7 @@ expect_result_n (const char *str, size_t str_len,
                    (t),MHD_STATICSTR_LEN_ (t), \
                    (e),MHD_STATICSTR_LEN_ (e), found)
 
-int
+static int
 check_result (void)
 {
   int errcount = 0;
diff --git a/src/microhttpd/test_str_tokens_remove.c 
b/src/microhttpd/test_str_tokens_remove.c
index 1cd1696b..b6b3caac 100644
--- a/src/microhttpd/test_str_tokens_remove.c
+++ b/src/microhttpd/test_str_tokens_remove.c
@@ -89,7 +89,7 @@ expect_result_n (const char *str, size_t str_len,
                    (t),MHD_STATICSTR_LEN_ (t), \
                    (e),MHD_STATICSTR_LEN_ (e), found)
 
-int
+static int
 check_result (void)
 {
   int errcount = 0;
diff --git a/w32/common/libmicrohttpd-files.vcxproj 
b/w32/common/libmicrohttpd-files.vcxproj
index 391e1cec..982227c0 100644
--- a/w32/common/libmicrohttpd-files.vcxproj
+++ b/w32/common/libmicrohttpd-files.vcxproj
@@ -48,6 +48,7 @@
     <ClInclude Include="$(MhdSrc)microhttpd\mhd_limits.h" />
     <ClInclude Include="$(MhdSrc)microhttpd\mhd_mono_clock.h" />
     <ClInclude Include="$(MhdSrc)microhttpd\response.h" />
+    <ClInclude Include="$(MhdSrc)microhttpd\postprocessor.h" />
     <ClInclude Include="$(MhdSrc)microhttpd\tsearch.h" />
     <ClInclude Include="$(MhdSrc)microhttpd\sysfdsetsize.h" />
     <ClInclude Include="$(MhdSrc)microhttpd\mhd_str.h" />
diff --git a/w32/common/libmicrohttpd-filters.vcxproj 
b/w32/common/libmicrohttpd-filters.vcxproj
index 16c6b085..7bc1fe3c 100644
--- a/w32/common/libmicrohttpd-filters.vcxproj
+++ b/w32/common/libmicrohttpd-filters.vcxproj
@@ -67,6 +67,9 @@
     <ClInclude Include="$(MhdSrc)microhttpd\memorypool.h">
       <Filter>Internal Headers</Filter>
     </ClInclude>
+    <ClInclude Include="$(MhdSrc)microhttpd\postprocessor.h">
+      <Filter>Internal Headers</Filter>
+    </ClInclude>
     <ClInclude Include="$(MhdSrc)microhttpd\response.h">
       <Filter>Internal Headers</Filter>
     </ClInclude>

-- 
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.



reply via email to

[Prev in Thread] Current Thread [Next in Thread]