/*
  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_auth_parse.c
 * @brief  Unit tests for request's 'Authorization" headers parsing
 * @author Karlson2k (Evgeny Grin)
 */

#include "mhd_options.h"
#include <string.h>
#include <stdio.h>
#include "gen_auth.h"
#ifdef BAUTH_SUPPORT
#include "basicauth.h"
#endif /* BAUTH_SUPPORT */
#ifdef DAUTH_SUPPORT
#include "digestauth.h"
#endif /* DAUTH_SUPPORT */
#include "mhd_assert.h"
#include "internal.h"
#include "connection.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_ */


#if defined(HAVE___FUNC__)
#define externalErrorExit(ignore) \
    _externalErrorExit_func(NULL, __func__, __LINE__)
#define externalErrorExitDesc(errDesc) \
    _externalErrorExit_func(errDesc, __func__, __LINE__)
#define mhdErrorExit(ignore) \
    _mhdErrorExit_func(NULL, __func__, __LINE__)
#define mhdErrorExitDesc(errDesc) \
    _mhdErrorExit_func(errDesc, __func__, __LINE__)
#elif defined(HAVE___FUNCTION__)
#define externalErrorExit(ignore) \
    _externalErrorExit_func(NULL, __FUNCTION__, __LINE__)
#define externalErrorExitDesc(errDesc) \
    _externalErrorExit_func(errDesc, __FUNCTION__, __LINE__)
#define mhdErrorExit(ignore) \
    _mhdErrorExit_func(NULL, __FUNCTION__, __LINE__)
#define mhdErrorExitDesc(errDesc) \
    _mhdErrorExit_func(errDesc, __FUNCTION__, __LINE__)
#else
#define externalErrorExit(ignore) _externalErrorExit_func(NULL, NULL, __LINE__)
#define externalErrorExitDesc(errDesc) \
  _externalErrorExit_func(errDesc, NULL, __LINE__)
#define mhdErrorExit(ignore) _mhdErrorExit_func(NULL, NULL, __LINE__)
#define mhdErrorExitDesc(errDesc) _mhdErrorExit_func(errDesc, NULL, __LINE__)
#endif


_MHD_NORETURN static void
_externalErrorExit_func (const char *errDesc, const char *funcName, int lineNum)
{
  if ((NULL != errDesc) && (0 != errDesc[0]))
    fprintf (stderr, "%s", errDesc);
  else
    fprintf (stderr, "System or external library call failed");
  if ((NULL != funcName) && (0 != funcName[0]))
    fprintf (stderr, " in %s", funcName);
  if (0 < lineNum)
    fprintf (stderr, " at line %d", lineNum);

  fprintf (stderr, ".\nLast errno value: %d (%s)\n", (int) errno,
           strerror (errno));
#ifdef MHD_WINSOCK_SOCKETS
  fprintf (stderr, "WSAGetLastError() value: %d\n", (int) WSAGetLastError ());
#endif /* MHD_WINSOCK_SOCKETS */
  fflush (stderr);
  exit (99);
}


_MHD_NORETURN static void
_mhdErrorExit_func (const char *errDesc, const char *funcName, int lineNum)
{
  if ((NULL != errDesc) && (0 != errDesc[0]))
    fprintf (stderr, "%s", errDesc);
  else
    fprintf (stderr, "MHD unexpected error");
  if ((NULL != funcName) && (0 != funcName[0]))
    fprintf (stderr, " in %s", funcName);
  if (0 < lineNum)
    fprintf (stderr, " at line %d", lineNum);

  fprintf (stderr, ".\nLast errno value: %d (%s)\n", (int) errno,
           strerror (errno));

  fflush (stderr);
  exit (8);
}


/* Declarations for local replacements of MHD functions */
/* None, headers are included */

/* Local replacements implementations */

void *
MHD_connection_alloc_memory_ (struct MHD_Connection *connection,
                              size_t size)
{
  void *ret;
  if (NULL == connection)
    mhdErrorExitDesc ("'connection' parameter is NULL");
  /* Use 'read_buffer' just as a flag */
  if (NULL != connection->read_buffer)
  {
    /* Use 'write_buffer' just as a flag */
    if (NULL != connection->write_buffer)
      mhdErrorExitDesc ("Unexpected third memory allocation, " \
                        "while previous allocations was not freed");
  }
  /* Just use simple "malloc()" here */
  ret = malloc (size);
  if (NULL == ret)
    externalErrorExit ();

  /* Track up to two allocations */
  if (NULL == connection->read_buffer)
    connection->read_buffer = (char *) ret;
  else
    connection->write_buffer = (char *) ret;
  return ret;
}


/**
 * Static variable to avoid additional malloc()/free() pairs
 */
static struct MHD_Connection conn;

void
MHD_DLOG (const struct MHD_Daemon *daemon,
          const char *format,
          ...)
{
  (void) daemon;
  if (NULL == conn.rq.last)
  {
    fprintf (stderr, "Unexpected call of 'MHD_LOG(), format is '%s'.\n",
             format);
    fprintf (stderr, "'Authorization' header value: '%s'.\n",
             (NULL == conn.rq.headers_received) ?
             "NULL" : (conn.rq.headers_received->value));
    mhdErrorExit ();
  }
  conn.rq.last = NULL; /* Clear the flag */
  return;
}


/**
 * Static variable to avoid additional malloc()/free() pairs
 */
static struct MHD_HTTP_Req_Header req_header;

static void
test_global_init (void)
{
  memset (&conn, 0, sizeof(conn));
  memset (&req_header, 0, sizeof(req_header));
}


/**
 * Add "Authorization" client test header.
 *
 * @param hdr the pointer to the headr value, must be valid until end of
 *            checking of this header
 * @param hdr_len the length of the @a hdr
 * @note The function is NOT thread-safe
 */
static void
add_AuthHeader (const char *hdr, size_t hdr_len)
{
  if ((NULL != conn.rq.headers_received) ||
      (NULL != conn.rq.headers_received_tail))
    externalErrorExitDesc ("Connection's test headers are not empty already");
  if (NULL != hdr)
  {
    /* Skip initial whitespaces, emulate MHD's headers processing */
    while (' ' == hdr[0] || '\t' == hdr[0])
    {
      hdr++;
      hdr_len--;
    }
    req_header.header = MHD_HTTP_HEADER_AUTHORIZATION; /* Static string */
    req_header.header_size = MHD_STATICSTR_LEN_ (MHD_HTTP_HEADER_AUTHORIZATION);
    req_header.value = hdr;
    req_header.value_size = hdr_len;
    req_header.kind = MHD_HEADER_KIND;
    req_header.prev = NULL;
    req_header.next = NULL;
    conn.rq.headers_received = &req_header;
    conn.rq.headers_received_tail = &req_header;
  }
  else
  {
    conn.rq.headers_received = NULL;
    conn.rq.headers_received_tail = NULL;
  }
  conn.state = MHD_CONNECTION_FULL_REQ_RECEIVED; /* Should be a typical value */
}


#ifdef BAUTH_SUPPORT
/**
 * Parse previously added Basic Authorization client header and return
 * result of the parsing.
 *
 * Function performs basic checking of the parsing result
 * @return result of header parsing
 * @note The function is NOT thread-safe
 */
static const struct MHD_RqBAuth *
get_BAuthRqParams (void)
{
  const struct MHD_RqBAuth *res1;
  const struct MHD_RqBAuth *res2;
  /* Store pointer in some member unused in this test */
  res1 = MHD_get_rq_bauth_params_ (&conn);
  if (! conn.rq.bauth_tried)
    mhdErrorExitDesc ("'rq.bauth_tried' is not set");
  res2 = MHD_get_rq_bauth_params_ (&conn);
  if (res1 != res2)
    mhdErrorExitDesc ("MHD_get_rq_bauth_params_() returned another pointer " \
                      "when called for the second time");
  return res2;
}


#endif /* BAUTH_SUPPORT */

#ifdef DAUTH_SUPPORT
/**
 * Parse previously added Digest Authorization client header and return
 * result of the parsing.
 *
 * Function performs basic checking of the parsing result
 * @return result of header parsing
 * @note The function is NOT thread-safe
 */
static const struct MHD_RqDAuth *
get_DAuthRqParams (void)
{
  const struct MHD_RqDAuth *res1;
  const struct MHD_RqDAuth *res2;
  /* Store pointer in some member unused in this test */
  res1 = MHD_get_rq_dauth_params_ (&conn);
  if (! conn.rq.dauth_tried)
    mhdErrorExitDesc ("'rq.dauth_tried' is not set");
  res2 = MHD_get_rq_dauth_params_ (&conn);
  if (res1 != res2)
    mhdErrorExitDesc ("MHD_get_rq_bauth_params_() returned another pointer " \
                      "when called for the second time");
  return res2;
}


#endif /* DAUTH_SUPPORT */


static void
clean_AuthHeaders (void)
{
  conn.state = MHD_CONNECTION_INIT;
  free (conn.read_buffer);
  free (conn.write_buffer);

#ifdef BAUTH_SUPPORT
  conn.rq.bauth_tried = false;
#endif /* BAUTH_SUPPORT */
#ifdef DAUTH_SUPPORT
  conn.rq.dauth_tried = false;
#endif /* BAUTH_SUPPORT */

#ifdef BAUTH_SUPPORT
  if ((NULL != conn.rq.bauth) &&
      (conn.read_buffer != (const char *) conn.rq.bauth) &&
      (conn.write_buffer != (const char *) conn.rq.bauth))
    externalErrorExitDesc ("Memory allocation is not tracked as it should be");
  conn.rq.bauth = NULL;
#endif /* BAUTH_SUPPORT */
#ifdef DAUTH_SUPPORT
  if ((NULL != conn.rq.dauth) &&
      (conn.read_buffer != (const char *) conn.rq.dauth) &&
      (conn.write_buffer != (const char *) conn.rq.dauth))
    externalErrorExitDesc ("Memory allocation is not tracked as it should be");
  conn.rq.dauth = NULL;
#endif /* BAUTH_SUPPORT */

  conn.rq.headers_received = NULL;
  conn.rq.headers_received_tail = NULL;

  conn.read_buffer = NULL;
  conn.write_buffer = NULL;
  conn.rq.last = NULL;
}


enum MHD_TestAuthType
{
  MHD_TEST_AUTHTYPE_NONE,
  MHD_TEST_AUTHTYPE_BASIC,
  MHD_TEST_AUTHTYPE_DIGEST,
};


/* return zero if succeed, non-zero otherwise */
static unsigned int
expect_result_type_n (const char *hdr, size_t hdr_len,
                      const enum MHD_TestAuthType expected_type,
                      int expect_log,
                      unsigned int line_num)
{
  static char marker1[] = "Expected log call";
  unsigned int ret;

  ret = 0;
  add_AuthHeader (hdr, hdr_len);
  if (expect_log)
    conn.rq.last = marker1; /* Use like a flag */
  else
    conn.rq.last = NULL;
#ifdef BAUTH_SUPPORT
  if (MHD_TEST_AUTHTYPE_BASIC == expected_type)
  {
    if (NULL == get_BAuthRqParams ())
    {
      fprintf (stderr,
               "'Authorization' header parsing FAILED:\n"
               "Basic Authorization was not found, while it should be.\n");
      ret++;
    }
  }
  else
#endif /* BAUTH_SUPPORT */
#ifdef DAUTH_SUPPORT
  if (MHD_TEST_AUTHTYPE_DIGEST == expected_type)
  {
    if (NULL == get_DAuthRqParams ())
    {
      fprintf (stderr,
               "'Authorization' header parsing FAILED:\n"
               "Digest Authorization was not found, while it should be.\n");
      ret++;
    }
  }
  else
#endif /* BAUTH_SUPPORT */
  {
#ifdef BAUTH_SUPPORT
    if (NULL != get_BAuthRqParams ())
    {
      fprintf (stderr,
               "'Authorization' header parsing FAILED:\n"
               "Found Basic Authorization, while it should not be.\n");
      ret++;
    }
#endif /* BAUTH_SUPPORT */
#ifdef DAUTH_SUPPORT
    if (NULL != get_DAuthRqParams ())
    {
      fprintf (stderr,
               "'Authorization' header parsing FAILED:\n"
               "Found Digest Authorization, while it should not be.\n");
      ret++;
    }
#endif /* DAUTH_SUPPORT */
  }
#if defined(BAUTH_SUPPORT) && defined(DAUTH_SUPPORT)
  if (conn.rq.last)
  {
    fprintf (stderr,
             "'Authorization' header parsing ERROR:\n"
             "Log function must be called, but it was not.\n");
    ret++;
  }
#endif /* BAUTH_SUPPORT && DAUTH_SUPPORT */

  if (ret)
  {
    if (NULL == hdr)
      fprintf (stderr,
               "Input: Absence of 'Authorization' header.\n");
    else if (0 == hdr_len)
      fprintf (stderr,
               "Input: empty 'Authorization' header.\n");
    else
      fprintf (stderr,
               "Input Header: '%.*s'\n", (int) hdr_len, hdr);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
    ret = 1;
  }
  clean_AuthHeaders ();

  return ret;
}


#define expect_result_type(h,t,l) \
    expect_result_type_n(h,MHD_STATICSTR_LEN_(h),t,l,__LINE__)


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

  r += expect_result_type_n (NULL, 0, MHD_TEST_AUTHTYPE_NONE, 0, __LINE__);

  r += expect_result_type ("", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("    ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\t", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" \t", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\t ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\t \t", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" \t ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" \t \t", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\t \t ", MHD_TEST_AUTHTYPE_NONE, 0);

  r += expect_result_type ("Basic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type (" Basic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\tBasic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t Basic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type (" \tBasic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("    Basic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t\t\tBasic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t\t  \tBasic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t\t  \t Basic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("Basic ", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("Basic \t", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("Basic \t ", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("Basic 123", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("Basic \t123", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("Basic  abc ", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("bAsIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type (" bAsIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\tbAsIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t bAsIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type (" \tbAsIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("    bAsIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t\t\tbAsIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t\t  \tbAsIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t\t  \t bAsIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("bAsIC ", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("bAsIC \t", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("bAsIC \t ", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("bAsIC 123", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("bAsIC \t123", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("bAsIC  abc ", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("basic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type (" basic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\tbasic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t basic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type (" \tbasic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("    basic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t\t\tbasic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t\t  \tbasic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t\t  \t basic", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("basic ", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("basic \t", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("basic \t ", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("basic 123", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("basic \t123", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("basic  abc ", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("BASIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type (" BASIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\tBASIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t BASIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type (" \tBASIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("    BASIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t\t\tBASIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t\t  \tBASIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("\t\t  \t BASIC", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("BASIC ", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("BASIC \t", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("BASIC \t ", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("BASIC 123", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("BASIC \t123", MHD_TEST_AUTHTYPE_BASIC, 0);
  r += expect_result_type ("BASIC  abc ", MHD_TEST_AUTHTYPE_BASIC, 0);
  /* Only single token is allowed for 'Basic' Authorization */
  r += expect_result_type ("Basic a b", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic a\tb", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic a\tb", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic abc1 b", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic c abc1", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic c abc1 ", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic c abc1\t", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic c\tabc1\t", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic c abc1 b", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic zyx, b", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic zyx,b", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic zyx ,b", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic zyx;b", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Basic zyx; b", MHD_TEST_AUTHTYPE_NONE, 1);

  r += expect_result_type ("Basic2", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" Basic2", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" Basic2 ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\tBasic2", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\t Basic2", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" \tBasic2", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("    Basic2", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\t\t\tBasic2", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\t\t  \tBasic2", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\t\t  \t Basic2", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("Basic2 ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("Basic2 \t", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("Basic2 \t ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("Basic2 123", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("Basic2 \t123", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("Basic2  abc ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("BasicBasic", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" BasicBasic", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\tBasicBasic", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\t BasicBasic", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" \tBasicBasic", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("BasicBasic ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("BasicBasic \t", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("BasicBasic \t\t", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("BasicDigest", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" BasicDigest", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("BasicDigest ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("Basic\0", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\0" "Basic", MHD_TEST_AUTHTYPE_NONE, 0);

  r += expect_result_type ("Digest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type (" Digest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\tDigest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t Digest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type (" \tDigest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("    Digest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t\t\tDigest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t\t  \tDigest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t\t  \t Digest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest \t", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest \t ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\tDigest ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("  Digest \t", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t \tDigest \t ", MHD_TEST_AUTHTYPE_DIGEST, 0);

  r += expect_result_type ("digEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type (" digEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\tdigEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t digEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type (" \tdigEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("    digEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t\t\tdigEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t\t  \tdigEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t\t  \t digEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("digEST ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("digEST \t", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("digEST \t ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\tdigEST ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("  digEST \t", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t \tdigEST \t ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("digest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type (" digest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\tdigest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t digest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type (" \tdigest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("    digest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t\t\tdigest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t\t  \tdigest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t\t  \t digest", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("digest ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("digest \t", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("digest \t ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\tdigest ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("  digest \t", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t \tdigest \t ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("DIGEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type (" DIGEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\tDIGEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t DIGEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type (" \tDIGEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("    DIGEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t\t\tDIGEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t\t  \tDIGEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t\t  \t DIGEST", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("DIGEST ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("DIGEST \t", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("DIGEST \t ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\tDIGEST ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("  DIGEST \t", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("\t \tDIGEST \t ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ,", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ,\t", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ,  ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest   ,  ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ,\t, ,\t, ,\t, ,", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ,\t,\t,\t,\t,\t,\t,", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest a=b", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest a=\"b\"", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest nc=1", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest nc=\"1\"", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest a=b ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest a=\"b\" ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest nc=1 ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest nc=\"1\" ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest a = b", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest a\t=\t\"b\"", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest nc =1", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest nc= \"1\"", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest a=\tb ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest a = \"b\" ", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest nc\t\t\t= 1 ", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest nc   =\t\t\t\"1\" ", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest nc =1,,,,", MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest nc =1  ,,,,", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ,,,,nc= \"1 \"", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ,,,,  nc= \" 1\"", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ,,,, nc= \"1\",,,,", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ,,,, nc= \"1\"  ,,,,", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ,,,, nc= \"1\"  ,,,,", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ,,,, nc= \"1\"  ,,,,", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);
  r += expect_result_type ("Digest ,,,, nc= \"1\"  ,,,,,", \
                           MHD_TEST_AUTHTYPE_DIGEST, 0);

  r += expect_result_type ("Digest nc", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest   nc", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc  ", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc  ,", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc  , ", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest \tnc\t  ", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest \tnc\t  ", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc,", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc,uri", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=1,uri", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=1,uri   ", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=1,uri,", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=1, uri,", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=1,uri   ,", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=1,uri   , ", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  /* Binary zero */
  r += expect_result_type ("Digest nc=1\0", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=1\0" " ", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=1\t\0", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=\0" "1", MHD_TEST_AUTHTYPE_NONE, 1);
  /* Semicolon */
  r += expect_result_type ("Digest nc=1;", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=1; ", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=;1", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc;=1", MHD_TEST_AUTHTYPE_NONE, 1);
  /* The equal sign alone */
  r += expect_result_type ("Digest =", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest   =", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest   =  ", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest ,=", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest , =", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest ,= ", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest , = ", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=1,=", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=1, =", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=bar,=", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=bar, =", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  /* Unclosed quotation */
  r += expect_result_type ("Digest nc=\"", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=\"abc", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=\"   ", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=\"abc   ", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=\"   abc", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=\"   abc", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=\"\\", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=\"\\\"", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=\"  \\\"", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=\"\\\"  ", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=\"  \\\"  ", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc=\"\\\"\\\"\\\"\\\"", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc= \"", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc= \"abc", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc= \"   ", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc= \"abc   ", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc= \"   abc", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc= \"   abc", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc= \"\\", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc= \"\\\"", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc= \"  \\\"", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc= \"\\\"  ", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc= \"  \\\"  ", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest nc= \"\\\"\\\"\\\"\\\"", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\"", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\"bar", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\"   ", MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\"bar   ", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\"   bar", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\"   bar", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo= \"   bar", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\",   bar", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\"   bar,", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\"\\\"", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\"  \\\"", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\"\\\"  ", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\"  \\\"  ", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest foo=\"\\\"\\\"\\\"\\\"", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  /* Full set of parameters with semicolon inside */
  r += expect_result_type ("Digest username=\"test@example.com\", " \
                           "realm=\"users@example.com\", nonce=\"32141232413abcde\", " \
                           "uri=\"/example\", qop=auth, nc=00000001; cnonce=\"0a4f113b\", " \
                           "response=\"6629fae49393a05397450978507c4ef1\", " \
                           "opaque=\"sadfljk32sdaf\"", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest username=\"test@example.com\", " \
                           "realm=\"users@example.com\", nonce=\"32141232413abcde\", " \
                           "uri=\"/example\", qop=auth, nc=00000001;cnonce=\"0a4f113b\", " \
                           "response=\"6629fae49393a05397450978507c4ef1\", " \
                           "opaque=\"sadfljk32sdaf\"", \
                           MHD_TEST_AUTHTYPE_NONE, 1);
  r += expect_result_type ("Digest username;=\"test@example.com\", " \
                           "realm=\"users@example.com\", nonce=\"32141232413abcde\", " \
                           "uri=\"/example\", qop=auth, nc=00000001, cnonce=\"0a4f113b\", " \
                           "response=\"6629fae49393a05397450978507c4ef1\", " \
                           "opaque=\"sadfljk32sdaf\"", \
                           MHD_TEST_AUTHTYPE_NONE, 1);

  r += expect_result_type ("Digest2", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("2Digest", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("Digest" "a", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("a" "Digest", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" Digest2", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" 2Digest", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" Digest" "a", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" a" "Digest", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("Digest2 ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("2Digest ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("Digest" "a", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("a" "Digest ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("DigestBasic", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("DigestBasic ", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type (" DigestBasic", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("DigestBasic" "a", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("Digest" "\0", MHD_TEST_AUTHTYPE_NONE, 0);
  r += expect_result_type ("\0" "Digest", MHD_TEST_AUTHTYPE_NONE, 0);
  return r;
}


#ifdef BAUTH_SUPPORT

/* return zero if succeed, 1 otherwise */
static unsigned int
expect_basic_n (const char *hdr, size_t hdr_len,
                const char *tkn, size_t tkn_len,
                unsigned int line_num)
{
  const struct MHD_RqBAuth *h;
  unsigned int ret;

  mhd_assert (NULL != hdr);
  mhd_assert (0 != hdr_len);

  add_AuthHeader (hdr, hdr_len);
  h = get_BAuthRqParams ();
  if (NULL == h)
    mhdErrorExitDesc ("'MHD_get_rq_bauth_params_()' returned NULL");
  ret = 1;
  if (tkn_len != h->token68.len)
    fprintf (stderr,
             "'Authorization' header parsing FAILED:\n"
             "Wrong token length:\tRESULT[%u]: %.*s\tEXPECTED[%u]: %.*s\n",
             (unsigned) h->token68.len,
             (int) h->token68.len,
             h->token68.str ?
             h->token68.str : "(NULL)",
             (unsigned) tkn_len, (int) tkn_len, tkn ? tkn : "(NULL)");
  else if ( ((NULL == tkn) != (NULL == h->token68.str)) ||
            ((NULL != tkn) &&
             (0 != memcmp (tkn, h->token68.str, tkn_len))) )
    fprintf (stderr,
             "'Authorization' header parsing FAILED:\n"
             "Wrong token string:\tRESULT[%u]: %.*s\tEXPECTED[%u]: %.*s\n",
             (unsigned) h->token68.len,
             (int) h->token68.len,
             h->token68.str ?
             h->token68.str : "(NULL)",
             (unsigned) tkn_len, (int) tkn_len, tkn ? tkn : "(NULL)");
  else
    ret = 0;
  if (0 != ret)
  {
    fprintf (stderr,
             "Input Header: '%.*s'\n", (int) hdr_len, hdr);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
  }
  clean_AuthHeaders ();

  return ret;
}


#define expect_basic(h,t) \
    expect_basic_n(h,MHD_STATICSTR_LEN_(h),t,MHD_STATICSTR_LEN_(t),__LINE__)

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

  r += expect_basic ("Basic a", "a");
  r += expect_basic ("Basic    a", "a");
  r += expect_basic ("Basic \ta", "a");
  r += expect_basic ("Basic \ta\t", "a");
  r += expect_basic ("Basic \ta ", "a");
  r += expect_basic ("Basic  a ", "a");
  r += expect_basic ("Basic \t a\t ", "a");
  r += expect_basic ("Basic \t abc\t ", "abc");
  r += expect_basic ("Basic 2143sdfa4325sdfgfdab354354314SDSDFc", \
                     "2143sdfa4325sdfgfdab354354314SDSDFc");
  r += expect_basic ("Basic 2143sdfa4325sdfgfdab354354314SDSDFc  ", \
                     "2143sdfa4325sdfgfdab354354314SDSDFc");
  r += expect_basic ("Basic   2143sdfa4325sdfgfdab354354314SDSDFc", \
                     "2143sdfa4325sdfgfdab354354314SDSDFc");
  r += expect_basic ("Basic   2143sdfa4325sdfgfdab354354314SDSDFc  ", \
                     "2143sdfa4325sdfgfdab354354314SDSDFc");
  r += expect_basic ("  Basic 2143sdfa4325sdfgfdab354354314SDSDFc", \
                     "2143sdfa4325sdfgfdab354354314SDSDFc");
  r += expect_basic ("  Basic  2143sdfa4325sdfgfdab354354314SDSDFc", \
                     "2143sdfa4325sdfgfdab354354314SDSDFc");
  r += expect_basic ("  Basic 2143sdfa4325sdfgfdab354354314SDSDFc ", \
                     "2143sdfa4325sdfgfdab354354314SDSDFc");
  r += expect_basic ("  Basic  2143sdfa4325sdfgfdab354354314SDSDFc ", \
                     "2143sdfa4325sdfgfdab354354314SDSDFc");
  r += expect_basic ("  Basic  2143sdfa4325sdfgfdab354354314SDSDFc  ", \
                     "2143sdfa4325sdfgfdab354354314SDSDFc");
  r += expect_basic ("Basic -A.1-z~9+/=====", "-A.1-z~9+/=====");
  r += expect_basic ("  Basic   -A.1-z~9+/===== ", "-A.1-z~9+/=====");

  r += expect_basic_n ("Basic", MHD_STATICSTR_LEN_ ("Basic"), NULL, 0,__LINE__);
  r += expect_basic_n ("   Basic", MHD_STATICSTR_LEN_ ("   Basic"), NULL, 0,
                       __LINE__);
  r += expect_basic_n ("Basic   ", MHD_STATICSTR_LEN_ ("Basic   "), NULL, 0,
                       __LINE__);
  r += expect_basic_n ("Basic \t\t", MHD_STATICSTR_LEN_ ("Basic \t\t"), NULL, 0,
                       __LINE__);

  return r;
}


#endif /* BAUTH_SUPPORT */


#ifdef DAUTH_SUPPORT

/* return zero if succeed, 1 otherwise */
static unsigned int
cmp_dauth_param (const char *pname, const struct MHD_RqDAuthParam *param,
                 const char *expected_value)
{
  unsigned int ret;
  size_t expected_len;
  bool expected_quoted;
  mhd_assert (NULL != param);
  mhd_assert (NULL != pname);
  ret = 0;

  if (NULL == expected_value)
  {
    expected_len = 0;
    expected_quoted = false;
    if (NULL != param->value.str)
      ret = 1;
    else if (param->value.len != expected_len)
      ret = 1;
    else if (param->quoted != expected_quoted)
      ret = 1;
  }
  else
  {
    expected_len = strlen (expected_value);
    expected_quoted = (NULL != memchr (expected_value, '\\', expected_len));
    if (NULL == param->value.str)
      ret = 1;
    else if (param->value.len != expected_len)
      ret = 1;
    else if (param->quoted != expected_quoted)
      ret = 1;
    else if (0 != memcmp (param->value.str, expected_value, expected_len))
      ret = 1;
  }
  if (0 != ret)
  {
    fprintf (stderr, "Parameter '%s' parsed incorrectly:\n", pname);
    fprintf (stderr, "\tRESULT  :\tvalue.str: %.*s",
             (int) (param->value.str ? param->value.len : 6),
             param->value.str ? param->value.str : "(NULL)");
    fprintf (stderr, "\tvalue.len: %u",
             (unsigned) param->value.len);
    fprintf (stderr, "\tquoted: %s\n",
             (unsigned) param->quoted ? "true" : "false");
    fprintf (stderr, "\tEXPECTED:\tvalue.str: %.*s",
             (int) (expected_value ? expected_len : 6),
             expected_value ? expected_value : "(NULL)");
    fprintf (stderr, "\tvalue.len: %u",
             (unsigned) expected_len);
    fprintf (stderr, "\tquoted: %s\n",
             (unsigned) expected_quoted ? "true" : "false");
  }
  return ret;
}


/* return zero if succeed, 1 otherwise */
static unsigned int
expect_digest_n (const char *hdr, size_t hdr_len,
                 const char *nonce,
                 enum MHD_DigestAuthAlgo3 algo3,
                 const char *response,
                 const char *username,
                 const char *username_ext,
                 const char *realm,
                 const char *uri,
                 const char *qop_raw,
                 enum MHD_DigestAuthQOP qop,
                 const char *cnonce,
                 const char *nc,
                 int userhash,
                 unsigned int line_num)
{
  const struct MHD_RqDAuth *h;
  unsigned int ret;

  mhd_assert (NULL != hdr);
  mhd_assert (0 != hdr_len);

  add_AuthHeader (hdr, hdr_len);

  h = get_DAuthRqParams ();
  if (NULL == h)
    mhdErrorExitDesc ("'MHD_get_rq_dauth_params_()' returned NULL");
  ret = 0;

  ret += cmp_dauth_param ("nonce", &h->nonce, nonce);
  if (h->algo3 != algo3)
  {
    ret += 1;
    fprintf (stderr, "Parameter 'algorithm' detected incorrectly:\n");
    fprintf (stderr, "\tRESULT  :\t%u\n",
             (unsigned) h->algo3);
    fprintf (stderr, "\tEXPECTED:\t%u\n",
             (unsigned) algo3);
  }
  ret += cmp_dauth_param ("response", &h->response, response);
  ret += cmp_dauth_param ("username", &h->username, username);
  ret += cmp_dauth_param ("username_ext", &h->username_ext,
                          username_ext);
  ret += cmp_dauth_param ("realm", &h->realm, realm);
  ret += cmp_dauth_param ("uri", &h->uri, uri);
  ret += cmp_dauth_param ("qop", &h->qop_raw, qop_raw);
  if (h->qop != qop)
  {
    ret += 1;
    fprintf (stderr, "Parameter 'qop' detected incorrectly:\n");
    fprintf (stderr, "\tRESULT  :\t%u\n",
             (unsigned) h->qop);
    fprintf (stderr, "\tEXPECTED:\t%u\n",
             (unsigned) qop);
  }
  ret += cmp_dauth_param ("cnonce", &h->cnonce, cnonce);
  ret += cmp_dauth_param ("nc", &h->nc, nc);
  if (h->userhash != ! (! userhash))
  {
    ret += 1;
    fprintf (stderr, "Parameter 'userhash' parsed incorrectly:\n");
    fprintf (stderr, "\tRESULT  :\t%s\n",
             h->userhash ? "true" : "false");
    fprintf (stderr, "\tEXPECTED:\t%s\n",
             userhash ? "true" : "false");
  }
  if (0 != ret)
  {
    fprintf (stderr,
             "Input Header: '%.*s'\n", (int) hdr_len, hdr);
    fprintf (stderr,
             "The check is at line: %u\n\n", line_num);
  }
  clean_AuthHeaders ();

  return ret;
}


#define expect_digest(h,no,a,rs,un,ux,rm,ur,qr,qe,c,nc,uh) \
    expect_digest_n(h,MHD_STATICSTR_LEN_(h),\
                    no,a,rs,un,ux,rm,ur,qr,qe,c,nc,uh,__LINE__)

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

  r += expect_digest ("Digest", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest nc=1", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, NULL, \
                      MHD_DIGEST_AUTH_QOP_NONE, NULL, "1", 0);
  r += expect_digest ("Digest nc=\"1\"", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1", 0);
  r += expect_digest ("Digest nc=\"1\"   ", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1", 0);
  r += expect_digest ("Digest ,nc=\"1\"   ", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1", 0);
  r += expect_digest ("Digest nc=\"1\",   ", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1", 0);
  r += expect_digest ("Digest nc=\"1\" ,   ", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1", 0);
  r += expect_digest ("Digest nc=1,   ", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1", 0);
  r += expect_digest ("Digest nc=1 ,   ", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1", 0);
  r += expect_digest ("Digest ,,,nc=1,   ", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1", 0);
  r += expect_digest ("Digest ,,,nc=1 ,   ", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1", 0);
  r += expect_digest ("Digest ,,,nc=\"1 \",   ", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1 ", 0);
  r += expect_digest ("Digest nc=\"1 \"", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1 ", 0);
  r += expect_digest ("Digest nc=\"1 \" ,", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1 ", 0);
  r += expect_digest ("Digest nc=\"1 \", ", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1 ", 0);
  r += expect_digest ("Digest nc=\"1;\", ", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1;", 0);
  r += expect_digest ("Digest nc=\"1\\;\", ", NULL, MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, "1\\;", 0);

  r += expect_digest ("Digest userhash=false", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest userhash=\"false\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest userhash=foo", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest userhash=true", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 1);
  r += expect_digest ("Digest userhash=\"true\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 1);
  r += expect_digest ("Digest userhash=\"\\t\\r\\u\\e\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 1);
  r += expect_digest ("Digest userhash=TRUE", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 1);
  r += expect_digest ("Digest userhash=True", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 1);
  r += expect_digest ("Digest userhash = true", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL,  NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 1);
  r += expect_digest ("Digest userhash=True2", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest userhash=\" true\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL,  NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);

  r += expect_digest ("Digest algorithm=MD5", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=md5", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=Md5", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=mD5", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=\"MD5\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=\"\\M\\D\\5\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=\"\\m\\d\\5\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=SHA-256", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=sha-256", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=Sha-256", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=\"SHA-256\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=\"SHA\\-25\\6\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=\"shA-256\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=MD5-sess", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5_SESSION, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=MD5-SESS", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5_SESSION, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=md5-Sess", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5_SESSION, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=SHA-256-seSS", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_SHA256_SESSION, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=SHA-512-256", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_SHA512_256, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=SHA-512-256-sess", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_SHA512_256_SESSION, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=MD5-2", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_INVALID, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=MD5-sess2", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_INVALID, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=SHA-256-512", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_INVALID, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);
  r += expect_digest ("Digest algorithm=", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_INVALID, \
                      NULL, NULL, NULL, NULL, NULL, \
                      NULL, MHD_DIGEST_AUTH_QOP_NONE, NULL, NULL, 0);

  r += expect_digest ("Digest qop=auth", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, NULL, NULL, 0);
  r += expect_digest ("Digest qop=\"auth\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, NULL, NULL, 0);
  r += expect_digest ("Digest qop=Auth", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      "Auth", MHD_DIGEST_AUTH_QOP_AUTH, NULL, NULL, 0);
  r += expect_digest ("Digest qop=AUTH", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      "AUTH", MHD_DIGEST_AUTH_QOP_AUTH, NULL, NULL, 0);
  r += expect_digest ("Digest qop=\"\\A\\ut\\H\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      "\\A\\ut\\H", MHD_DIGEST_AUTH_QOP_AUTH, NULL, NULL, 0);
  r += expect_digest ("Digest qop=\"auth \"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      "auth ", MHD_DIGEST_AUTH_QOP_INVALID, NULL, NULL, 0);
  r += expect_digest ("Digest qop=auth-int", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      "auth-int", MHD_DIGEST_AUTH_QOP_AUTH_INT, NULL, NULL, 0);
  r += expect_digest ("Digest qop=\"auth-int\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      "auth-int", MHD_DIGEST_AUTH_QOP_AUTH_INT, NULL, NULL, 0);
  r += expect_digest ("Digest qop=\"auTh-iNt\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      "auTh-iNt", MHD_DIGEST_AUTH_QOP_AUTH_INT, NULL, NULL, 0);
  r += expect_digest ("Digest qop=\"auTh-iNt2\"", NULL, \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      NULL, NULL, NULL, NULL, NULL, \
                      "auTh-iNt2", MHD_DIGEST_AUTH_QOP_INVALID, NULL, NULL, 0);

  r += expect_digest ("Digest username=\"test@example.com\", " \
                      "realm=\"users@example.com\", " \
                      "nonce=\"32141232413abcde\", " \
                      "uri=\"/example\", qop=auth, nc=00000001, " \
                      "cnonce=\"0a4f113b\", " \
                      "response=\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\"sadfljk32sdaf\"", "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_MD5, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      NULL, "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, \
                      "0a4f113b", "00000001", 0);
  r += expect_digest ("Digest username=\"test@example.com\", " \
                      "realm=\"users@example.com\", algorithm=SHA-256, " \
                      "nonce=\"32141232413abcde\", " \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri=\"/example\", qop=auth, nc=00000001, " \
                      "cnonce=\"0a4f113b\", " \
                      "response=\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\"sadfljk32sdaf\"", "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest username=test@example.com, " \
                      "realm=users@example.com, algorithm=\"SHA-256-sess\", " \
                      "nonce=32141232413abcde, " \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri=/example, qop=\"auth\", nc=\"00000001\", " \
                      "cnonce=0a4f113b, " \
                      "response=6629fae49393a05397450978507c4ef1, " \
                      "opaque=sadfljk32sdaf", "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA256_SESSION, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest username = \"test@example.com\", " \
                      "realm\t=\t\"users@example.com\", algorithm\t= SHA-256, " \
                      "nonce\t= \"32141232413abcde\", " \
                      "username*\t=\tUTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri = \"/example\", qop = auth, nc\t=\t00000001, " \
                      "cnonce\t\t\t=   \"0a4f113b\", " \
                      "response  =\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\t\t\"sadfljk32sdaf\"", "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest username=\"test@example.com\"," \
                      "realm=\"users@example.com\",algorithm=SHA-512-256," \
                      "nonce=\"32141232413abcde\"," \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates," \
                      "uri=\"/example\",qop=auth,nc=00000001," \
                      "cnonce=\"0a4f113b\"," \
                      "response=\"6629fae49393a05397450978507c4ef1\"," \
                      "opaque=\"sadfljk32sdaf\"", "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA512_256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest username=\"test@example.com\"," \
                      "realm=\"users@example.com\",algorithm=SHA-256," \
                      "nonce=\"32141232413abcde\",asdf=asdffdsaf," \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates," \
                      "uri=\"/example\",qop=auth,nc=00000001,cnonce=\"0a4f113b\"," \
                      "response=\"6629fae49393a05397450978507c4ef1\"," \
                      "opaque=\"sadfljk32sdaf\"", "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest abc=zyx, username=\"test@example.com\", " \
                      "realm=\"users@example.com\", algorithm=SHA-256, " \
                      "nonce=\"32141232413abcde\", " \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri=\"/example\", qop=auth, nc=00000001, " \
                      "cnonce=\"0a4f113b\", " \
                      "response=\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\"sadfljk32sdaf\"", "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest abc=zyx,,,,,,,username=\"test@example.com\", " \
                      "realm=\"users@example.com\", algorithm=SHA-256, " \
                      "nonce=\"32141232413abcde\", " \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri=\"/example\", qop=auth, nc=00000001, " \
                      "cnonce=\"0a4f113b\", " \
                      "response=\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\"sadfljk32sdaf\"", "32141232413abcde",
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest abc=zyx,,,,,,,username=\"test@example.com\", " \
                      "realm=\"users@example.com\", algorithm=SHA-256, " \
                      "nonce=\"32141232413abcde\", " \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri=\"/example\", qop=auth, nc=00000001, "
                      "cnonce=\"0a4f113b\", " \
                      "response=\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\"sadfljk32sdaf\",,,,,", "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest abc=zyx,,,,,,,username=\"test@example.com\", " \
                      "realm=\"users@example.com\", algorithm=SHA-256, " \
                      "nonce=\"32141232413abcde\", " \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri=\"/example\", qop=auth, nc=00000001, " \
                      "cnonce=\"0a4f113b\", " \
                      "response=\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\"sadfljk32sdaf\",foo=bar", "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest abc=\"zyx\", username=\"test@example.com\", " \
                      "realm=\"users@example.com\", algorithm=SHA-256, " \
                      "nonce=\"32141232413abcde\", " \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri=\"/example\", qop=auth, nc=00000001, "
                      "cnonce=\"0a4f113b\", " \
                      "response=\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\"sadfljk32sdaf\",foo=bar", "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest abc=\"zyx, abc\", " \
                      "username=\"test@example.com\", " \
                      "realm=\"users@example.com\", algorithm=SHA-256, " \
                      "nonce=\"32141232413abcde\", " \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri=\"/example\", qop=auth, nc=00000001, "
                      "cnonce=\"0a4f113b\", " \
                      "response=\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\"sadfljk32sdaf\",foo=bar", "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest abc=\"zyx, abc=cde\", " \
                      "username=\"test@example.com\", " \
                      "realm=\"users@example.com\", algorithm=SHA-256, " \
                      "nonce=\"32141232413abcde\", " \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri=\"/example\", qop=auth, nc=00000001, " \
                      "cnonce=\"0a4f113b\", " \
                      "response=\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\"sadfljk32sdaf\",foo=bar", "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest abc=\"zyx, abc=cde\", " \
                      "username=\"test@example.com\", " \
                      "realm=\"users@example.com\", algorithm=SHA-256, " \
                      "nonce=\"32141232413abcde\", " \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri=\"/example\", qop=auth, nc=00000001, " \
                      "cnonce=\"0a4f113b\", " \
                      "response=\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\"sadfljk32sdaf\", foo=\"bar1, bar2\"", \
                      "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest abc=\"zyx, \\\\\"abc=cde\\\\\"\", " \
                      "username=\"test@example.com\", " \
                      "realm=\"users@example.com\", algorithm=SHA-256, " \
                      "nonce=\"32141232413abcde\", " \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri=\"/example\", qop=auth, nc=00000001, cnonce=\"0a4f113b\", " \
                      "response=\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\"sadfljk32sdaf\", foo=\"bar1, bar2\"", \
                      "32141232413abcde",
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);
  r += expect_digest ("Digest abc=\"zyx, \\\\\"abc=cde\\\\\"\", " \
                      "username=\"test@example.com\", " \
                      "realm=\"users@example.com\", algorithm=SHA-256, " \
                      "nonce=\"32141232413abcde\", " \
                      "username*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates, " \
                      "uri=\"/example\", qop=auth, nc=00000001, "
                      "cnonce=\"0a4f113b\", " \
                      "response=\"6629fae49393a05397450978507c4ef1\", " \
                      "opaque=\"sadfljk32sdaf\", foo=\",nc=02\"",
                      "32141232413abcde", \
                      MHD_DIGEST_AUTH_ALGO3_SHA256, \
                      "6629fae49393a05397450978507c4ef1", "test@example.com", \
                      "UTF-8''%c2%a3%20and%20%e2%82%ac%20rates", \
                      "users@example.com", "/example", \
                      "auth", MHD_DIGEST_AUTH_QOP_AUTH, "0a4f113b", \
                      "00000001", 0);

  return r;
}


#endif /* DAUTH_SUPPORT */

#define TEST_AUTH_STR "dXNlcjpwYXNz"

static unsigned int
check_two_auths (void)
{
  unsigned int ret;
  static struct MHD_HTTP_Req_Header h1;
  static struct MHD_HTTP_Req_Header h2;
  static struct MHD_HTTP_Req_Header h3;
#ifdef BAUTH_SUPPORT
  const struct MHD_RqBAuth *bauth;
#endif /* BAUTH_SUPPORT */
#ifdef DAUTH_SUPPORT
  const struct MHD_RqDAuth *dauth;
#endif /* DAUTH_SUPPORT */

  if ((NULL != conn.rq.headers_received) ||
      (NULL != conn.rq.headers_received_tail))
    externalErrorExitDesc ("Connection's test headers are not empty already");

  /* Init and use both Basic and Digest Auth headers */
  memset (&h1, 0, sizeof(h1));
  memset (&h2, 0, sizeof(h2));
  memset (&h3, 0, sizeof(h3));

  h1.kind = MHD_HEADER_KIND;
  h1.header = MHD_HTTP_HEADER_HOST; /* Just some random header */
  h1.header_size = MHD_STATICSTR_LEN_ (MHD_HTTP_HEADER_HOST);
  h1.value = "localhost";
  h1.value_size = strlen (h1.value);

  h2.kind = MHD_HEADER_KIND;
  h2.header = MHD_HTTP_HEADER_AUTHORIZATION;
  h2.header_size = MHD_STATICSTR_LEN_ (MHD_HTTP_HEADER_AUTHORIZATION);
  h2.value = "Basic " TEST_AUTH_STR;
  h2.value_size = strlen (h2.value);

  h3.kind = MHD_HEADER_KIND;
  h3.header = MHD_HTTP_HEADER_AUTHORIZATION;
  h3.header_size = MHD_STATICSTR_LEN_ (MHD_HTTP_HEADER_AUTHORIZATION);
  h3.value = "Digest cnonce=" TEST_AUTH_STR;
  h3.value_size = strlen (h3.value);

  conn.rq.headers_received = &h1;
  h1.next = &h2;
  h2.prev = &h1;
  h2.next = &h3;
  h3.prev = &h2;
  conn.rq.headers_received_tail = &h3;

  conn.state = MHD_CONNECTION_FULL_REQ_RECEIVED; /* Should be a typical value */

  ret = 0;
#ifdef BAUTH_SUPPORT
  bauth = get_BAuthRqParams ();
#endif /* BAUTH_SUPPORT */
#ifdef DAUTH_SUPPORT
  dauth = get_DAuthRqParams ();
#endif /* DAUTH_SUPPORT */
#ifdef BAUTH_SUPPORT
  if (NULL == bauth)
  {
    fprintf (stderr, "No Basic Authorization header detected. Line: %u\n",
             (unsigned int) __LINE__);
    ret++;
  }
  else if ((MHD_STATICSTR_LEN_ (TEST_AUTH_STR) != bauth->token68.len) ||
           (0 != memcmp (bauth->token68.str, TEST_AUTH_STR,
                         bauth->token68.len)))
  {
    fprintf (stderr, "Basic Authorization token does not match. Line: %u\n",
             (unsigned int) __LINE__);
    ret++;
  }
#endif /* BAUTH_SUPPORT */
#ifdef DAUTH_SUPPORT
  if (NULL == dauth)
  {
    fprintf (stderr, "No Digest Authorization header detected. Line: %u\n",
             (unsigned int) __LINE__);
    ret++;
  }
  else if ((MHD_STATICSTR_LEN_ (TEST_AUTH_STR) != dauth->cnonce.value.len) ||
           (0 != memcmp (dauth->cnonce.value.str, TEST_AUTH_STR,
                         dauth->cnonce.value.len)))
  {
    fprintf (stderr, "Digest Authorization 'cnonce' does not match. Line: %u\n",
             (unsigned int) __LINE__);
    ret++;
  }
#endif /* DAUTH_SUPPORT */

  /* Cleanup */
  conn.rq.headers_received = NULL;
  conn.rq.headers_received_tail = NULL;
  conn.state = MHD_CONNECTION_INIT;

  return ret;
}


int
main (int argc, char *argv[])
{
  unsigned int errcount = 0;
  (void) argc; (void) argv; /* Unused. Silent compiler warning. */
  test_global_init ();

  errcount += check_type ();
#ifdef BAUTH_SUPPORT
  errcount += check_basic ();
#endif /* BAUTH_SUPPORT */
#ifdef DAUTH_SUPPORT
  errcount += check_digest ();
#endif /* DAUTH_SUPPORT */
  errcount += check_two_auths ();
  if (0 == errcount)
    printf ("All tests were passed without errors.\n");
  return errcount == 0 ? 0 : 1;
}