/*
  This file is part of libmicrohttpd
  Copyright (C) 2022 Karlson2k (Evgeny Grin)

  This test tool is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2, or
  (at your option) any later version.

  This test tool 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 microhttpd/test_str_quote.c
 * @brief  Unit tests for quoted strings processing
 * @author Karlson2k (Evgeny Grin)
 */

#include "mhd_options.h"
#include <string.h>
#include <stdio.h>
#include "mhd_str.h"
#include "mhd_assert.h"

#ifndef MHD_STATICSTR_LEN_
/**
 * Determine length of static string / macro strings at compile time.
 */
#define MHD_STATICSTR_LEN_(macro) (sizeof(macro) / sizeof(char) - 1)
#endif /* ! MHD_STATICSTR_LEN_ */


#define TEST_STR_MAX_LEN 1024

/* return zero if succeed, non-zero otherwise */
static unsigned int
expect_result_unquote_n (const char *const quoted, const size_t quoted_len,
                         const char *const unquoted, const size_t unquoted_len,
                         const unsigned int line_num)
{
  static char buf[TEST_STR_MAX_LEN];
  size_t res_len;
  unsigned int ret1;
  unsigned int ret2;
  unsigned int ret3;
  unsigned int ret4;

  mhd_assert (NULL != quoted);
  mhd_assert (NULL != unquoted);
  mhd_assert (TEST_STR_MAX_LEN > quoted_len);
  mhd_assert (quoted_len >= unquoted_len);

  /* First check: MHD_str_unquote () */
  ret1 = 0;
  memset (buf, '#', sizeof(buf)); /* Fill buffer with character unused in the check */
  res_len = MHD_str_unquote (quoted, quoted_len, buf);

  if (res_len != unquoted_len)
  {
    ret1 = 1;
    fprintf (stderr,
             "'MHD_str_unquote ()' FAILED: Wrong result size:\n");
  }
  else if ((0 != unquoted_len) && (0 != memcmp (buf, unquoted, unquoted_len)))
  {
    ret1 = 1;
    fprintf (stderr,
             "'MHD_str_unquote ()' FAILED: Wrong result string:\n");
  }
  if (0 != ret1)
  {
    /* This does NOT print part of the string after binary zero */
    fprintf (stderr,
             "\tRESULT  : MHD_str_unquote('%.*s', %u, ->'%.*s') -> %u\n"
             "\tEXPECTED: MHD_str_unquote('%.*s', %u, ->'%.*s') -> %u\n",
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) res_len, buf, (unsigned) res_len,
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
  }

  /* Second check: MHD_str_equal_quoted_bin_n () */
  ret2 = 0;
  if (! MHD_str_equal_quoted_bin_n (quoted, quoted_len, unquoted, unquoted_len))
  {
    fprintf (stderr,
             "'MHD_str_equal_quoted_bin_n ()' FAILED: Wrong result:\n");
    /* This does NOT print part of the string after binary zero */
    fprintf (stderr,
             "\tRESULT  : MHD_str_equal_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> true\n"
             "\tEXPECTED: MHD_str_equal_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> false\n",
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len,
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
    ret2 = 1;
  }

  /* Third check: MHD_str_equal_caseless_quoted_bin_n () */
  ret3 = 0;
  if (! MHD_str_equal_caseless_quoted_bin_n (quoted, quoted_len, unquoted,
                                             unquoted_len))
  {
    fprintf (stderr,
             "'MHD_str_equal_caseless_quoted_bin_n ()' FAILED: Wrong result:\n");
    /* This does NOT print part of the string after binary zero */
    fprintf (stderr,
             "\tRESULT  : MHD_str_equal_caseless_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> true\n"
             "\tEXPECTED: MHD_str_equal_caseless_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> false\n",
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len,
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
    ret3 = 1;
  }

  /* Fourth check: MHD_str_unquote () */
  ret4 = 0;
  memset (buf, '#', sizeof(buf)); /* Fill buffer with character unused in the check */
  res_len = MHD_str_quote (unquoted, unquoted_len, buf, quoted_len);
  if (res_len != quoted_len)
  {
    ret4 = 1;
    fprintf (stderr,
             "'MHD_str_quote ()' FAILED: Wrong result size:\n");
  }
  else if ((0 != quoted_len) && (0 != memcmp (buf, quoted, quoted_len)))
  {
    ret4 = 1;
    fprintf (stderr,
             "'MHD_str_quote ()' FAILED: Wrong result string:\n");
  }
  if (0 != ret4)
  {
    /* This does NOT print part of the string after binary zero */
    fprintf (stderr,
             "\tRESULT  : MHD_str_quote('%.*s', %u, ->'%.*s', %u) -> %u\n"
             "\tEXPECTED: MHD_str_quote('%.*s', %u, ->'%.*s', %u) -> %u\n",
             (int) unquoted_len, unquoted, (unsigned) unquoted_len,
             (int) res_len, buf, (unsigned) quoted_len, (unsigned) res_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len,
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (unsigned) unquoted_len);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
  }

  return ret1 + ret2 + ret3 + ret4;
}


#define expect_result_unquote(q,u) \
    expect_result_unquote_n(q,MHD_STATICSTR_LEN_(q),\
                            u,MHD_STATICSTR_LEN_(u),__LINE__)


static unsigned int
check_match (void)
{
  unsigned int r = 0; /**< The number of errors */

  r += expect_result_unquote ("", "");
  r += expect_result_unquote ("a", "a");
  r += expect_result_unquote ("abc", "abc");
  r += expect_result_unquote ("abcdef", "abcdef");
  r += expect_result_unquote ("a\0" "bc", "a\0" "bc");
  r += expect_result_unquote ("abc\\\"", "abc\"");
  r += expect_result_unquote ("\\\"", "\"");
  r += expect_result_unquote ("\\\"abc", "\"abc");
  r += expect_result_unquote ("abc\\\\", "abc\\");
  r += expect_result_unquote ("\\\\", "\\");
  r += expect_result_unquote ("\\\\abc", "\\abc");
  r += expect_result_unquote ("123\\\\\\\\\\\\\\\\", "123\\\\\\\\");
  r += expect_result_unquote ("\\\\\\\\\\\\\\\\", "\\\\\\\\");
  r += expect_result_unquote ("\\\\\\\\\\\\\\\\123", "\\\\\\\\123");
  r += expect_result_unquote ("\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"" \
                              "\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"\\\\\\\"", \
                              "\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"\\\"");

  return r;
}


/* return zero if succeed, non-zero otherwise */
static unsigned int
expect_result_quote_failed_n (const char *const unquoted,
                              const size_t unquoted_len,
                              const size_t buf_size,
                              const unsigned int line_num)
{
  static char buf[TEST_STR_MAX_LEN];
  size_t res_len;
  unsigned int ret4;

  mhd_assert (TEST_STR_MAX_LEN > buf_size);

  /* The check: MHD_str_unquote () */
  ret4 = 0;
  memset (buf, '#', sizeof(buf)); /* Fill buffer with character unused in the check */
  res_len = MHD_str_quote (unquoted, unquoted_len, buf, buf_size);
  if (0 != res_len)
  {
    ret4 = 1;
    fprintf (stderr,
             "'MHD_str_quote ()' FAILED: Wrong result size:\n");
  }
  if (0 != ret4)
  {
    /* This does NOT print part of the string after binary zero */
    fprintf (stderr,
             "\tRESULT  : MHD_str_quote('%.*s', %u, ->'%.*s', %u) -> %u\n"
             "\tEXPECTED: MHD_str_quote('%.*s', %u, (not checked), %u) -> 0\n",
             (int) unquoted_len, unquoted, (unsigned) unquoted_len,
             (int) res_len, buf,
             (unsigned) buf_size, (unsigned) res_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len,
             (unsigned) buf_size);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
  }

  return ret4;
}


#define expect_result_quote_failed(q,s) \
    expect_result_quote_failed_n(q,MHD_STATICSTR_LEN_(q),\
                            s,__LINE__)


static unsigned int
check_quote_failed (void)
{
  unsigned int r = 0; /**< The number of errors */

  r += expect_result_quote_failed ("a", 0);
  r += expect_result_quote_failed ("aa", 1);
  r += expect_result_quote_failed ("abc\\", 4);
  r += expect_result_quote_failed ("abc\"", 4);
  r += expect_result_quote_failed ("abc\"\"\"\"", 6);
  r += expect_result_quote_failed ("abc\"\"\"\"", 7);
  r += expect_result_quote_failed ("abc\"\"\"\"", 8);
  r += expect_result_quote_failed ("abc\"\"\"\"", 9);
  r += expect_result_quote_failed ("abc\"\"\"\"", 10);
  r += expect_result_quote_failed ("abc\\\\\\\\", 9);
  r += expect_result_quote_failed ("abc\\\\\\\\", 10);
  r += expect_result_quote_failed ("abc\"\"\"\"", 9);
  r += expect_result_quote_failed ("abc\"\"\"\"", 10);
  r += expect_result_quote_failed ("abc\"\\\"\\", 9);
  r += expect_result_quote_failed ("abc\\\"\\\"", 10);
  r += expect_result_quote_failed ("\"\"\"\"abc", 6);
  r += expect_result_quote_failed ("\"\"\"\"abc", 7);
  r += expect_result_quote_failed ("\"\"\"\"abc", 8);
  r += expect_result_quote_failed ("\"\"\"\"abc", 9);
  r += expect_result_quote_failed ("\"\"\"\"abc", 10);
  r += expect_result_quote_failed ("\\\\\\\\abc", 9);
  r += expect_result_quote_failed ("\\\\\\\\abc", 10);
  r += expect_result_quote_failed ("\"\"\"\"abc", 9);
  r += expect_result_quote_failed ("\"\"\"\"abc", 10);
  r += expect_result_quote_failed ("\"\\\"\\abc", 9);
  r += expect_result_quote_failed ("\\\"\\\"abc", 10);

  return r;
}


/* return zero if succeed, one otherwise */
static unsigned int
expect_match_caseless_n (const char *const quoted, const size_t quoted_len,
                         const char *const unquoted, const size_t unquoted_len,
                         const unsigned int line_num)
{
  unsigned int ret3;

  mhd_assert (NULL != quoted);
  mhd_assert (NULL != unquoted);
  mhd_assert (TEST_STR_MAX_LEN > quoted_len);

  /* The check: MHD_str_equal_caseless_quoted_bin_n () */
  ret3 = 0;
  if (! MHD_str_equal_caseless_quoted_bin_n (quoted, quoted_len, unquoted,
                                             unquoted_len))
  {
    fprintf (stderr,
             "'MHD_str_equal_caseless_quoted_bin_n ()' FAILED: Wrong result:\n");
    /* This does NOT print part of the string after binary zero */
    fprintf (stderr,
             "\tRESULT  : MHD_str_equal_caseless_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> true\n"
             "\tEXPECTED: MHD_str_equal_caseless_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> false\n",
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len,
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
    ret3 = 1;
  }

  return ret3;
}


#define expect_match_caseless(q,u) \
    expect_match_caseless_n(q,MHD_STATICSTR_LEN_(q),\
                            u,MHD_STATICSTR_LEN_(u),__LINE__)

static unsigned int
check_match_caseless (void)
{
  unsigned int r = 0; /**< The number of errors */

  r += expect_match_caseless ("a", "A");
  r += expect_match_caseless ("abC", "aBc");
  r += expect_match_caseless ("AbCdeF", "aBCdEF");
  r += expect_match_caseless ("a\0" "Bc", "a\0" "bC");
  r += expect_match_caseless ("Abc\\\"", "abC\"");
  r += expect_match_caseless ("\\\"", "\"");
  r += expect_match_caseless ("\\\"aBc", "\"abc");
  r += expect_match_caseless ("abc\\\\", "ABC\\");
  r += expect_match_caseless ("\\\\", "\\");
  r += expect_match_caseless ("\\\\ABC", "\\abc");
  r += expect_match_caseless ("\\\\ZYX", "\\ZYX");
  r += expect_match_caseless ("abc", "ABC");
  r += expect_match_caseless ("ABCabc", "abcABC");
  r += expect_match_caseless ("abcXYZ", "ABCxyz");
  r += expect_match_caseless ("AbCdEfABCabc", "ABcdEFabcABC");
  r += expect_match_caseless ("a\\\\bc", "A\\BC");
  r += expect_match_caseless ("ABCa\\\\bc", "abcA\\BC");
  r += expect_match_caseless ("abcXYZ\\\\", "ABCxyz\\");
  r += expect_match_caseless ("\\\\AbCdEfABCabc", "\\ABcdEFabcABC");

  return r;
}


/* return zero if succeed, one otherwise */
static unsigned int
expect_result_invalid_n (const char *const quoted, const size_t quoted_len,
                         const unsigned int line_num)
{
  static char buf[TEST_STR_MAX_LEN];
  size_t res_len;
  unsigned int ret1;

  mhd_assert (NULL != quoted);
  mhd_assert (TEST_STR_MAX_LEN > quoted_len);

  /* The check: MHD_str_unquote () */
  ret1 = 0;
  memset (buf, '#', sizeof(buf)); /* Fill buffer with character unused in the check */
  res_len = MHD_str_unquote (quoted, quoted_len, buf);

  if (res_len != 0)
  {
    ret1 = 1;
    fprintf (stderr,
             "'MHD_str_unquote ()' FAILED: Wrong result size:\n");
  }
  if (0 != ret1)
  {
    /* This does NOT print part of the string after binary zero */
    fprintf (stderr,
             "\tRESULT  : MHD_str_unquote('%.*s', %u, (not checked)) -> %u\n"
             "\tEXPECTED: MHD_str_unquote('%.*s', %u, (not checked)) -> 0\n",
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (unsigned) res_len,
             (int) quoted_len, quoted, (unsigned) quoted_len);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
  }

  return ret1;
}


#define expect_result_invalid(q) \
    expect_result_invalid_n(q,MHD_STATICSTR_LEN_(q),__LINE__)


static unsigned int
check_invalid (void)
{
  unsigned int r = 0; /**< The number of errors */

  r += expect_result_invalid ("\\");
  r += expect_result_invalid ("\\\\\\");
  r += expect_result_invalid ("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\");
  r += expect_result_invalid ("xyz\\");
  r += expect_result_invalid ("\\\"\\");
  r += expect_result_invalid ("\\\"\\\"\\\"\\");

  return r;
}


/* return zero if succeed, non-zero otherwise */
static unsigned int
expect_result_unmatch_n (const char *const quoted, const size_t quoted_len,
                         const char *const unquoted,
                         const size_t unquoted_len,
                         const unsigned int line_num)
{
  unsigned int ret2;
  unsigned int ret3;

  mhd_assert (NULL != quoted);
  mhd_assert (NULL != unquoted);

  /* The check: MHD_str_equal_quoted_bin_n () */
  ret2 = 0;
  if (MHD_str_equal_quoted_bin_n (quoted, quoted_len, unquoted, unquoted_len))
  {
    fprintf (stderr,
             "'MHD_str_equal_quoted_bin_n ()' FAILED: Wrong result:\n");
    /* This does NOT print part of the string after binary zero */
    fprintf (stderr,
             "\tRESULT  : MHD_str_equal_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> true\n"
             "\tEXPECTED: MHD_str_equal_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> false\n",
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len,
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
    ret2 = 1;
  }

  /* The check: MHD_str_equal_quoted_bin_n () */
  ret3 = 0;
  if (MHD_str_equal_caseless_quoted_bin_n (quoted, quoted_len, unquoted,
                                           unquoted_len))
  {
    fprintf (stderr,
             "'MHD_str_equal_caseless_quoted_bin_n ()' FAILED: Wrong result:\n");
    /* This does NOT print part of the string after binary zero */
    fprintf (stderr,
             "\tRESULT  : MHD_str_equal_caseless_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> true\n"
             "\tEXPECTED: MHD_str_equal_caseless_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> false\n",
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len,
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
    ret3 = 1;
  }

  return ret2 + ret3;
}


#define expect_result_unmatch(q,u) \
    expect_result_unmatch_n(q,MHD_STATICSTR_LEN_(q),\
                            u,MHD_STATICSTR_LEN_(u),__LINE__)


static unsigned int
check_unmatch (void)
{
  unsigned int r = 0; /**< The number of errors */

  /* Matched sequence except invalid backslash at the end */
  r += expect_result_unmatch ("\\", "");
  r += expect_result_unmatch ("a\\", "a");
  r += expect_result_unmatch ("abc\\", "abc");
  r += expect_result_unmatch ("a\0" "bc\\", "a\0" "bc");
  r += expect_result_unmatch ("abc\\\"\\", "abc\"");
  r += expect_result_unmatch ("\\\"\\", "\"");
  r += expect_result_unmatch ("\\\"abc\\", "\"abc");
  r += expect_result_unmatch ("abc\\\\\\", "abc\\");
  r += expect_result_unmatch ("\\\\\\", "\\");
  r += expect_result_unmatch ("\\\\abc\\", "\\abc");
  r += expect_result_unmatch ("123\\\\\\\\\\\\\\\\\\", "123\\\\\\\\");
  r += expect_result_unmatch ("\\\\\\\\\\\\\\\\\\", "\\\\\\\\");
  r += expect_result_unmatch ("\\\\\\\\\\\\\\\\123\\", "\\\\\\\\123");
  /* Invalid backslash at the end and empty string */
  r += expect_result_unmatch ("\\", "");
  r += expect_result_unmatch ("a\\", "");
  r += expect_result_unmatch ("abc\\", "");
  r += expect_result_unmatch ("a\0" "bc\\", "");
  r += expect_result_unmatch ("abc\\\"\\", "");
  r += expect_result_unmatch ("\\\"\\", "");
  r += expect_result_unmatch ("\\\"abc\\", "");
  r += expect_result_unmatch ("abc\\\\\\", "");
  r += expect_result_unmatch ("\\\\\\", "");
  r += expect_result_unmatch ("\\\\abc\\", "");
  r += expect_result_unmatch ("123\\\\\\\\\\\\\\\\\\", "");
  r += expect_result_unmatch ("\\\\\\\\\\\\\\\\\\", "");
  r += expect_result_unmatch ("\\\\\\\\\\\\\\\\123\\", "");
  /* Difference at binary zero */
  r += expect_result_unmatch ("\0", "");
  r += expect_result_unmatch ("", "\0");
  r += expect_result_unmatch ("a\0", "a");
  r += expect_result_unmatch ("a", "a\0");
  r += expect_result_unmatch ("abc\0", "abc");
  r += expect_result_unmatch ("abc", "abc\0");
  r += expect_result_unmatch ("a\0" "bc\0", "a\0" "bc");
  r += expect_result_unmatch ("a\0" "bc", "a\0" "bc\0");
  r += expect_result_unmatch ("abc\\\"\0", "abc\"");
  r += expect_result_unmatch ("abc\\\"", "abc\"\0");
  r += expect_result_unmatch ("\\\"\0", "\"");
  r += expect_result_unmatch ("\\\"", "\"\0");
  r += expect_result_unmatch ("\\\"abc\0", "\"abc");
  r += expect_result_unmatch ("\\\"abc", "\"abc\0");
  r += expect_result_unmatch ("\\\\\\\\\\\\\\\\\0", "\\\\\\\\");
  r += expect_result_unmatch ("\\\\\\\\\\\\\\\\", "\\\\\\\\\0");
  r += expect_result_unmatch ("\\\\\\\\\\\\\0" "\\\\", "\\\\\\\\");
  r += expect_result_unmatch ("\\\\\\\\\\\\\\\\", "\\\\\\\0" "\\");
  r += expect_result_unmatch ("\0" "abc", "abc");
  r += expect_result_unmatch ("abc", "\0" "abc");
  r += expect_result_unmatch ("\0" "abc", "0abc");
  r += expect_result_unmatch ("0abc", "\0" "abc");
  r += expect_result_unmatch ("xyz", "xy" "\0" "z");
  r += expect_result_unmatch ("xy" "\0" "z", "xyz");
  /* Difference after binary zero */
  r += expect_result_unmatch ("abc\0" "1", "abc\0" "2");
  r += expect_result_unmatch ("a\0" "bcx", "a\0" "bcy");
  r += expect_result_unmatch ("\0" "abc\\\"2", "\0" "abc\"1");
  r += expect_result_unmatch ("\0" "abc1\\\"", "\0" "abc2\"");
  r += expect_result_unmatch ("\0" "\\\"c", "\0" "\"d");
  r += expect_result_unmatch ("\\\"ab" "\0" "1c", "\"ab" "\0" "2c");
  r += expect_result_unmatch ("a\0" "bcdef2", "a\0" "bcdef1");
  r += expect_result_unmatch ("a\0" "bc2def", "a\0" "bc1def");
  r += expect_result_unmatch ("a\0" "1bcdef", "a\0" "2bcdef");
  r += expect_result_unmatch ("abcde\0" "f2", "abcde\0" "f1");
  r += expect_result_unmatch ("123\\\\\\\\\\\\\0" "\\\\1", "123\\\\\\\0" "\\2");
  r += expect_result_unmatch ("\\\\\\\\\\\\\0" "1\\\\", "\\\\\\" "2\\");
  /* One side is empty */
  r += expect_result_unmatch ("abc", "");
  r += expect_result_unmatch ("", "abc");
  r += expect_result_unmatch ("1234567890", "");
  r += expect_result_unmatch ("", "1234567890");
  r += expect_result_unmatch ("abc\\\"", "");
  r += expect_result_unmatch ("", "abc\"");
  r += expect_result_unmatch ("\\\"", "");
  r += expect_result_unmatch ("", "\"");
  r += expect_result_unmatch ("\\\"abc", "");
  r += expect_result_unmatch ("", "\"abc");
  r += expect_result_unmatch ("abc\\\\", "");
  r += expect_result_unmatch ("", "abc\\");
  r += expect_result_unmatch ("\\\\", "");
  r += expect_result_unmatch ("", "\\");
  r += expect_result_unmatch ("\\\\abc", "");
  r += expect_result_unmatch ("", "\\abc");
  r += expect_result_unmatch ("123\\\\\\\\\\\\\\\\", "");
  r += expect_result_unmatch ("", "123\\\\\\\\");
  r += expect_result_unmatch ("\\\\\\\\\\\\\\\\", "");
  r += expect_result_unmatch ("", "\\\\\\\\");
  r += expect_result_unmatch ("\\\\\\\\\\\\\\\\123", "");
  r += expect_result_unmatch ("", "\\\\\\\\123");
  /* Various unmatched strings */
  r += expect_result_unmatch ("a", "x");
  r += expect_result_unmatch ("abc", "abcabc");
  r += expect_result_unmatch ("abc", "abcabcabc");
  r += expect_result_unmatch ("abc", "abcabcabcabc");
  r += expect_result_unmatch ("ABCABC", "ABC");
  r += expect_result_unmatch ("ABCABCABC", "ABC");
  r += expect_result_unmatch ("ABCABCABCABC", "ABC");
  r += expect_result_unmatch ("123\\\\\\\\\\\\\\\\\\\\", "123\\\\\\\\");
  r += expect_result_unmatch ("\\\\\\\\\\\\\\\\\\\\", "\\\\\\\\");
  r += expect_result_unmatch ("\\\\\\\\\\\\\\\\123\\\\", "\\\\\\\\123");
  r += expect_result_unmatch ("\\\\\\\\\\\\\\\\", "\\\\\\\\\\");

  return r;
}


/* return zero if succeed, one otherwise */
static unsigned int
expect_result_case_unmatch_n (const char *const quoted,
                              const size_t quoted_len,
                              const char *const unquoted,
                              const size_t unquoted_len,
                              const unsigned int line_num)
{
  unsigned int ret2;

  mhd_assert (NULL != quoted);
  mhd_assert (NULL != unquoted);

  /* THe check: MHD_str_equal_quoted_bin_n () */
  ret2 = 0;
  if (MHD_str_equal_quoted_bin_n (quoted, quoted_len, unquoted, unquoted_len))
  {
    fprintf (stderr,
             "'MHD_str_equal_quoted_bin_n ()' FAILED: Wrong result:\n");
    /* This does NOT print part of the string after binary zero */
    fprintf (stderr,
             "\tRESULT  : MHD_str_equal_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> true\n"
             "\tEXPECTED: MHD_str_equal_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> false\n",
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len,
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
    ret2 = 1;
  }

  return ret2;
}


#define expect_result_case_unmatch(q,u) \
    expect_result_case_unmatch_n(q,MHD_STATICSTR_LEN_(q),\
                                 u,MHD_STATICSTR_LEN_(u),__LINE__)

static unsigned int
check_unmatch_case (void)
{
  unsigned int r = 0; /**< The number of errors */

  r += expect_result_case_unmatch ("a", "A");
  r += expect_result_case_unmatch ("abC", "aBc");
  r += expect_result_case_unmatch ("AbCdeF", "aBCdEF");
  r += expect_result_case_unmatch ("a\0" "Bc", "a\0" "bC");
  r += expect_result_case_unmatch ("Abc\\\"", "abC\"");
  r += expect_result_case_unmatch ("\\\"aBc", "\"abc");
  r += expect_result_case_unmatch ("abc\\\\", "ABC\\");
  r += expect_result_case_unmatch ("\\\\ABC", "\\abc");
  r += expect_result_case_unmatch ("\\\\ZYX", "\\ZYx");
  r += expect_result_case_unmatch ("abc", "ABC");
  r += expect_result_case_unmatch ("ABCabc", "abcABC");
  r += expect_result_case_unmatch ("abcXYZ", "ABCxyz");
  r += expect_result_case_unmatch ("AbCdEfABCabc", "ABcdEFabcABC");
  r += expect_result_case_unmatch ("a\\\\bc", "A\\BC");
  r += expect_result_case_unmatch ("ABCa\\\\bc", "abcA\\BC");
  r += expect_result_case_unmatch ("abcXYZ\\\\", "ABCxyz\\");
  r += expect_result_case_unmatch ("\\\\AbCdEfABCabc", "\\ABcdEFabcABC");

  return r;
}


/* return zero if succeed, one otherwise */
static unsigned int
expect_result_caseless_unmatch_n (const char *const quoted,
                                  const size_t quoted_len,
                                  const char *const unquoted,
                                  const size_t unquoted_len,
                                  const unsigned int line_num)
{
  unsigned int ret2;
  unsigned int ret3;

  mhd_assert (NULL != quoted);
  mhd_assert (NULL != unquoted);

  /* The check: MHD_str_equal_quoted_bin_n () */
  ret2 = 0;
  if (MHD_str_equal_quoted_bin_n (quoted, quoted_len, unquoted, unquoted_len))
  {
    fprintf (stderr,
             "'MHD_str_equal_quoted_bin_n ()' FAILED: Wrong result:\n");
    /* This does NOT print part of the string after binary zero */
    fprintf (stderr,
             "\tRESULT  : MHD_str_equal_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> true\n"
             "\tEXPECTED: MHD_str_equal_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> false\n",
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len,
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
    ret2 = 1;
  }

  /* The check: MHD_str_equal_quoted_bin_n () */
  ret3 = 0;
  if (MHD_str_equal_caseless_quoted_bin_n (quoted, quoted_len, unquoted,
                                           unquoted_len))
  {
    fprintf (stderr,
             "'MHD_str_equal_caseless_quoted_bin_n ()' FAILED: Wrong result:\n");
    /* This does NOT print part of the string after binary zero */
    fprintf (stderr,
             "\tRESULT  : MHD_str_equal_caseless_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> true\n"
             "\tEXPECTED: MHD_str_equal_caseless_quoted_bin_n('%.*s', %u, "
             "'%.*s', %u) -> false\n",
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len,
             (int) quoted_len, quoted, (unsigned) quoted_len,
             (int) unquoted_len, unquoted, (unsigned) unquoted_len);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
    ret3 = 1;
  }

  return ret2 + ret3;
}


#define expect_result_caseless_unmatch(q,u) \
    expect_result_caseless_unmatch_n(q,MHD_STATICSTR_LEN_(q),\
                                     u,MHD_STATICSTR_LEN_(u),__LINE__)


static unsigned int
check_unmatch_caseless (void)
{
  unsigned int r = 0; /**< The number of errors */

  /* Matched sequence except invalid backslash at the end */
  r += expect_result_caseless_unmatch ("a\\", "A");
  r += expect_result_caseless_unmatch ("abC\\", "abc");
  r += expect_result_caseless_unmatch ("a\0" "Bc\\", "a\0" "bc");
  r += expect_result_caseless_unmatch ("abc\\\"\\", "ABC\"");
  r += expect_result_caseless_unmatch ("\\\"\\", "\"");
  r += expect_result_caseless_unmatch ("\\\"ABC\\", "\"abc");
  r += expect_result_caseless_unmatch ("Abc\\\\\\", "abC\\");
  r += expect_result_caseless_unmatch ("\\\\\\", "\\");
  r += expect_result_caseless_unmatch ("\\\\aBc\\", "\\abC");
  /* Difference at binary zero */
  r += expect_result_caseless_unmatch ("a\0", "A");
  r += expect_result_caseless_unmatch ("A", "a\0");
  r += expect_result_caseless_unmatch ("abC\0", "abc");
  r += expect_result_caseless_unmatch ("abc", "ABc\0");
  r += expect_result_caseless_unmatch ("a\0" "bC\0", "a\0" "bc");
  r += expect_result_caseless_unmatch ("a\0" "bc", "A\0" "bc\0");
  r += expect_result_caseless_unmatch ("ABC\\\"\0", "abc\"");
  r += expect_result_caseless_unmatch ("abc\\\"", "ABC\"\0");
  r += expect_result_caseless_unmatch ("\\\"aBc\0", "\"abc");
  r += expect_result_caseless_unmatch ("\\\"Abc", "\"abc\0");
  r += expect_result_caseless_unmatch ("\\\\\\\\\\\\\\\\\0", "\\\\\\\\");
  r += expect_result_caseless_unmatch ("\\\\\\\\\\\\\\\\", "\\\\\\\\\0");
  r += expect_result_caseless_unmatch ("\\\\\\\\\\\\\0" "\\\\", "\\\\\\\\");
  r += expect_result_caseless_unmatch ("\\\\\\\\\\\\\\\\", "\\\\\\\0" "\\");
  r += expect_result_caseless_unmatch ("\0" "aBc", "abc");
  r += expect_result_caseless_unmatch ("abc", "\0" "abC");
  r += expect_result_caseless_unmatch ("\0" "abc", "0abc");
  r += expect_result_caseless_unmatch ("0abc", "\0" "aBc");
  r += expect_result_caseless_unmatch ("xyZ", "xy" "\0" "z");
  r += expect_result_caseless_unmatch ("Xy" "\0" "z", "xyz");
  /* Difference after binary zero */
  r += expect_result_caseless_unmatch ("abc\0" "1", "aBC\0" "2");
  r += expect_result_caseless_unmatch ("a\0" "bcX", "a\0" "bcy");
  r += expect_result_caseless_unmatch ("\0" "abc\\\"2", "\0" "Abc\"1");
  r += expect_result_caseless_unmatch ("\0" "Abc1\\\"", "\0" "abc2\"");
  r += expect_result_caseless_unmatch ("\0" "\\\"c", "\0" "\"d");
  r += expect_result_caseless_unmatch ("\\\"ab" "\0" "1C", "\"ab" "\0" "2C");
  r += expect_result_caseless_unmatch ("a\0" "BCDef2", "a\0" "bcdef1");
  r += expect_result_caseless_unmatch ("a\0" "bc2def", "a\0" "BC1def");
  r += expect_result_caseless_unmatch ("a\0" "1bcdeF", "a\0" "2bcdef");
  r += expect_result_caseless_unmatch ("abcde\0" "f2", "ABCDE\0" "f1");
  r += expect_result_caseless_unmatch ("\\\"ab" "\0" "XC", "\"ab" "\0" "yC");
  r += expect_result_caseless_unmatch ("a\0" "BCDefY", "a\0" "bcdefx");
  r += expect_result_caseless_unmatch ("a\0" "bczdef", "a\0" "BCXdef");
  r += expect_result_caseless_unmatch ("a\0" "YbcdeF", "a\0" "zbcdef");
  r += expect_result_caseless_unmatch ("abcde\0" "fy", "ABCDE\0" "fX");

  return r;
}


int
main (int argc, char *argv[])
{
  unsigned int errcount = 0;
  (void) argc; (void) argv; /* Unused. Silent compiler warning. */
  errcount += check_match ();
  errcount += check_quote_failed ();
  errcount += check_match_caseless ();
  errcount += check_invalid ();
  errcount += check_unmatch ();
  errcount += check_unmatch_case ();
  errcount += check_unmatch_caseless ();
  if (0 == errcount)
    printf ("All tests were passed without errors.\n");
  return errcount == 0 ? 0 : 1;
}