Adding upstream version 1:0.5.47.upstream/1%0.5.47

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1839 insertions, 0 deletions

diff --git a/test/test_utils.cpp b/test/test_utils.cpp
new file mode 100644
index 0000000..8eb1352
--- /dev/null
+++ b/test/test_utils.cpp
@@ -0,0 +1,1839 @@
+/***************************************************************************
+ * Copyright (c) 2009-2010 Open Information Security Foundation
+ * Copyright (c) 2010-2013 Qualys, Inc.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+
+ * - Neither the name of the Qualys, Inc. nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ***************************************************************************/
+
+/**
+ * @file
+ * @brief Tests for various utility functions.
+ *
+ * @author Craig Forbes <cforbes@qualys.com>
+ * @author Ivan Ristic <ivanr@webkreator.com>
+ */
+
+#include <iostream>
+#include <gtest/gtest.h>
+#include <htp/htp_private.h>
+
+TEST(Base64, Single) {
+    EXPECT_EQ(62, htp_base64_decode_single('+'));
+    EXPECT_EQ(63, htp_base64_decode_single('/'));
+    EXPECT_EQ(-1, htp_base64_decode_single(','));
+    EXPECT_EQ(-1, htp_base64_decode_single(0));
+    EXPECT_EQ(-1, htp_base64_decode_single('~'));
+    EXPECT_EQ(26, htp_base64_decode_single('a'));
+    EXPECT_EQ(0, htp_base64_decode_single('A'));
+}
+
+TEST(Base64, Decode) {
+    const char *input = "dGhpcyBpcyBhIHRlc3QuLg==";
+    bstr *out = htp_base64_decode_mem(input, strlen(input));
+    EXPECT_EQ(0, bstr_cmp_c(out, "this is a test.."));
+    bstr_free(out);
+}
+
+TEST(UtilTest, Separator) {
+    EXPECT_EQ(0, htp_is_separator('a'));
+    EXPECT_EQ(0, htp_is_separator('^'));
+    EXPECT_EQ(0, htp_is_separator('-'));
+    EXPECT_EQ(0, htp_is_separator('_'));
+    EXPECT_EQ(0, htp_is_separator('&'));
+    EXPECT_EQ(1, htp_is_separator('('));
+    EXPECT_EQ(1, htp_is_separator('\\'));
+    EXPECT_EQ(1, htp_is_separator('/'));
+    EXPECT_EQ(1, htp_is_separator('='));
+    EXPECT_EQ(1, htp_is_separator('\t'));
+}
+
+TEST(UtilTest, Text) {
+    EXPECT_EQ(1, htp_is_text('\t'));
+    EXPECT_EQ(1, htp_is_text('a'));
+    EXPECT_EQ(1, htp_is_text('~'));
+    EXPECT_EQ(1, htp_is_text(' '));
+    EXPECT_EQ(0, htp_is_text('\n'));
+    EXPECT_EQ(0, htp_is_text('\r'));
+    EXPECT_EQ(0, htp_is_text('\r'));
+    EXPECT_EQ(0, htp_is_text(31));
+}
+
+TEST(UtilTest, Token) {
+    EXPECT_EQ(1, htp_is_token('a'));
+    EXPECT_EQ(1, htp_is_token('&'));
+    EXPECT_EQ(1, htp_is_token('+'));
+    EXPECT_EQ(0, htp_is_token('\t'));
+    EXPECT_EQ(0, htp_is_token('\n'));
+}
+
+TEST(UtilTest, Chomp) {
+    char data[100];
+    size_t len;
+    int result;
+
+    strcpy(data, "test\r\n");
+    len = strlen(data);
+    result = htp_chomp((unsigned char *) data, &len);
+    EXPECT_EQ(2, result);
+    EXPECT_EQ(4, len);
+
+    strcpy(data, "test\r\n\n");
+    len = strlen(data);
+    result = htp_chomp((unsigned char *) data, &len);
+    EXPECT_EQ(2, result);
+    EXPECT_EQ(4, len);
+
+    strcpy(data, "test\r\n\r\n");
+    len = strlen(data);
+    result = htp_chomp((unsigned char *) data, &len);
+    EXPECT_EQ(2, result);
+    EXPECT_EQ(4, len);
+
+    strcpy(data, "te\nst");
+    len = strlen(data);
+    result = htp_chomp((unsigned char *) data, &len);
+    EXPECT_EQ(0, result);
+    EXPECT_EQ(5, len);
+
+    strcpy(data, "foo\n");
+    len = strlen(data);
+    result = htp_chomp((unsigned char *) data, &len);
+    EXPECT_EQ(1, result);
+    EXPECT_EQ(3, len);
+
+    strcpy(data, "arfarf");
+    len = strlen(data);
+    result = htp_chomp((unsigned char *) data, &len);
+    EXPECT_EQ(0, result);
+    EXPECT_EQ(6, len);
+
+    strcpy(data, "");
+    len = strlen(data);
+    result = htp_chomp((unsigned char *) data, &len);
+    EXPECT_EQ(0, result);
+    EXPECT_EQ(0, len);
+}
+
+TEST(UtilTest, Space) {
+    EXPECT_EQ(0, htp_is_space('a'));
+    EXPECT_EQ(1, htp_is_space(' '));
+    EXPECT_EQ(1, htp_is_space('\f'));
+    EXPECT_EQ(1, htp_is_space('\n'));
+    EXPECT_EQ(1, htp_is_space('\r'));
+    EXPECT_EQ(1, htp_is_space('\t'));
+    EXPECT_EQ(1, htp_is_space('\v'));
+}
+
+TEST(UtilTest, Method) {
+    bstr *method = bstr_dup_c("GET");
+
+    EXPECT_EQ(HTP_M_GET, htp_convert_method_to_number(method));
+
+    bstr_free(method);
+}
+
+TEST(UtilTest, IsLineEmpty) {
+    char data[100];
+    strcpy(data, "arfarf");
+    EXPECT_EQ(0, htp_is_line_empty((unsigned char*) data, 6));
+
+    strcpy(data, "\r\n");
+    EXPECT_EQ(1, htp_is_line_empty((unsigned char*) data, 2));
+    strcpy(data, "\r");
+    EXPECT_EQ(1, htp_is_line_empty((unsigned char*) data, 1));
+    EXPECT_EQ(0, htp_is_line_empty((unsigned char*) data, 0));
+
+}
+
+TEST(UtilTest, IsLineWhitespace) {
+    char data[100];
+    strcpy(data, "arfarf");
+    EXPECT_EQ(0, htp_is_line_whitespace((unsigned char*) data, 6));
+
+    strcpy(data, "\r\n");
+    EXPECT_EQ(1, htp_is_line_whitespace((unsigned char*) data, 2));
+    strcpy(data, "\r");
+    EXPECT_EQ(1, htp_is_line_whitespace((unsigned char*) data, 1));
+    EXPECT_EQ(1, htp_is_line_whitespace((unsigned char*) data, 0));
+}
+
+TEST(UtilTest, ParsePositiveIntegerWhitespace) {
+    EXPECT_EQ(123, htp_parse_positive_integer_whitespace(
+            (unsigned char*) "123   ", 6, 10));
+    EXPECT_EQ(123, htp_parse_positive_integer_whitespace(
+            (unsigned char*) "   123", 6, 10));
+    EXPECT_EQ(123, htp_parse_positive_integer_whitespace(
+            (unsigned char*) "   123   ", 9, 10));
+    EXPECT_EQ(-1, htp_parse_positive_integer_whitespace(
+            (unsigned char*) "a123", 4, 10));
+    EXPECT_EQ(-1001, htp_parse_positive_integer_whitespace(
+            (unsigned char*) "   \t", 4, 10));
+    EXPECT_EQ(-1002, htp_parse_positive_integer_whitespace(
+            (unsigned char*) "123b ", 5, 10));
+
+    EXPECT_EQ(-1, htp_parse_positive_integer_whitespace(
+            (unsigned char*) "   a123   ", 9, 10));
+    EXPECT_EQ(-1002, htp_parse_positive_integer_whitespace(
+            (unsigned char*) "   123b   ", 9, 10));
+
+    EXPECT_EQ(0x123, htp_parse_positive_integer_whitespace(
+            (unsigned char*) "   123   ", 9, 16));
+}
+
+TEST(UtilTest, ParseContentLength) {
+    bstr *str = bstr_dup_c("134");
+
+    EXPECT_EQ(134, htp_parse_content_length(str, NULL));
+
+    bstr_free(str);
+}
+
+TEST(UtilTest, ParseChunkedLength) {
+    EXPECT_EQ(0x12a5, htp_parse_chunked_length((unsigned char*) "12a5", 4, NULL));
+}
+
+TEST(UtilTest, IsLineFolded) {
+    EXPECT_EQ(-1, htp_connp_is_line_folded((unsigned char*) "", 0));
+    EXPECT_EQ(1, htp_connp_is_line_folded((unsigned char*) "\tline", 5));
+    EXPECT_EQ(1, htp_connp_is_line_folded((unsigned char*) " line", 5));
+    EXPECT_EQ(0, htp_connp_is_line_folded((unsigned char*) "line ", 5));
+}
+
+static void free_htp_uri_t(htp_uri_t **urip) {
+    htp_uri_t *uri = *urip;
+
+    if (uri == NULL) {
+        return;
+    }
+    bstr_free(uri->scheme);
+    bstr_free(uri->username);
+    bstr_free(uri->password);
+    bstr_free(uri->hostname);
+    bstr_free(uri->port);
+    bstr_free(uri->path);
+    bstr_free(uri->query);
+    bstr_free(uri->fragment);
+
+    free(uri);
+    *urip = NULL;
+}
+
+struct uri_expected {
+    const char *scheme;
+    const char *username;
+    const char *password;
+    const char *hostname;
+    const char *port;
+    const char *path;
+    const char *query;
+    const char *fragment;
+};
+
+struct uri_test {
+    const char *uri;
+    uri_expected expected;
+};
+
+bool bstr_equal_c(const bstr *b, const char *c) {
+    if ((c == NULL) || (b == NULL)) {
+        return (c == NULL) && (b == NULL);
+    } else {
+        return (0 == bstr_cmp_c(b, c));
+    }
+}
+
+void append_message(std::ostream & o,
+        const char *label, const char *expected, bstr *actual) {
+    o << label << " missmatch: ";
+    if (expected != NULL) {
+        o << "'" << expected << "'";
+    } else {
+        o << "<NULL>";
+    }
+    o << " != ";
+    if (actual != NULL) {
+        o << "'";
+        o.write((const char *) bstr_ptr(actual), bstr_len(actual));
+        o << "'";
+    } else {
+        o << "<NULL>";
+    }
+    o << std::endl;
+}
+
+static ::testing::AssertionResult UriIsExpected(const char *expected_var,
+        const char *actual_var,
+        const uri_expected &expected,
+        const htp_uri_t *actual) {
+    std::stringstream msg;
+    bool equal = true;
+
+    if (!bstr_equal_c(actual->scheme, expected.scheme)) {
+        equal = false;
+        append_message(msg, "scheme", expected.scheme, actual->scheme);
+    }
+
+    if (!bstr_equal_c(actual->username, expected.username)) {
+        equal = false;
+        append_message(msg, "username", expected.username, actual->username);
+    }
+
+    if (!bstr_equal_c(actual->password, expected.password)) {
+        equal = false;
+        append_message(msg, "password", expected.password, actual->password);
+    }
+
+    if (!bstr_equal_c(actual->hostname, expected.hostname)) {
+        equal = false;
+        append_message(msg, "hostname", expected.hostname, actual->hostname);
+    }
+
+    if (!bstr_equal_c(actual->port, expected.port)) {
+        equal = false;
+        append_message(msg, "port", expected.port, actual->port);
+    }
+
+    if (!bstr_equal_c(actual->path, expected.path)) {
+        equal = false;
+        append_message(msg, "path", expected.path, actual->path);
+    }
+
+    if (!bstr_equal_c(actual->query, expected.query)) {
+        equal = false;
+        append_message(msg, "query", expected.query, actual->query);
+    }
+
+    if (!bstr_equal_c(actual->fragment, expected.fragment)) {
+        equal = false;
+        append_message(msg, "fragment", expected.fragment, actual->fragment);
+    }
+
+    if (equal) {
+        return ::testing::AssertionSuccess();
+    } else {
+        return ::testing::AssertionFailure() << msg.str();
+    }
+}
+
+struct uri_test uri_tests[] = {
+    {"http://user:pass@www.example.com:1234/path1/path2?a=b&c=d#frag",
+        {"http", "user", "pass", "www.example.com", "1234", "/path1/path2", "a=b&c=d", "frag"}},
+    {"http://host.com/path",
+        {"http", NULL, NULL, "host.com", NULL, "/path", NULL, NULL}},
+    {"http://",
+        {"http", NULL, NULL, NULL, NULL, "//", NULL, NULL}},
+    {"/path",
+        {NULL, NULL, NULL, NULL, NULL, "/path", NULL, NULL}},
+    {"://",
+        {"", NULL, NULL, NULL, NULL, "//", NULL, NULL}},
+    {"",
+        {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL}},
+    {"http://user@host.com",
+        {"http", "user", NULL, "host.com", NULL, "", NULL, NULL}},
+    {NULL,
+        { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }}
+};
+
+TEST(UtilTest, HtpParseUri) {
+    bstr *input = NULL;
+    htp_uri_t *uri = NULL;
+    uri_test *test;
+
+    input = bstr_dup_c("");
+    EXPECT_EQ(HTP_OK, htp_parse_uri(input, &uri));
+    bstr_free(input);
+    free_htp_uri_t(&uri);
+
+    test = uri_tests;
+    while (test->uri != NULL) {
+        input = bstr_dup_c(test->uri);
+        EXPECT_EQ(HTP_OK, htp_parse_uri(input, &uri));
+        EXPECT_PRED_FORMAT2(UriIsExpected, test->expected, uri)
+                << "Failed URI = " << test->uri << std::endl;
+
+        bstr_free(input);
+        free_htp_uri_t(&uri);
+        ++test;
+    }
+}
+
+TEST(UtilTest, ParseHostPort1) {
+    bstr *i = bstr_dup_c("www.example.com");
+    bstr *host;
+    int port;
+    int flag = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &flag));
+
+    ASSERT_TRUE(bstr_cmp(i, host) == 0);
+    ASSERT_EQ(-1, port);
+    ASSERT_EQ(0, flag);
+
+    bstr_free(host);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort2) {
+    bstr *i = bstr_dup_c(" www.example.com ");
+    bstr *e = bstr_dup_c("www.example.com");
+    bstr *host = NULL;
+    int port;
+    int flag = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &flag));
+
+    ASSERT_TRUE(host != NULL);
+    ASSERT_TRUE(bstr_cmp(e, host) == 0);
+    ASSERT_EQ(-1, port);
+    ASSERT_EQ(0, flag);
+
+    bstr_free(host);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort3) {
+    bstr *i = bstr_dup_c(" www.example.com:8001 ");
+    bstr *e = bstr_dup_c("www.example.com");
+    bstr *host = NULL;
+    int port;
+    int flag = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &flag));
+
+    ASSERT_TRUE(host != NULL);
+    ASSERT_TRUE(bstr_cmp(e, host) == 0);
+    ASSERT_EQ(8001, port);
+    ASSERT_EQ(0, flag);
+
+    bstr_free(host);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort4) {
+    bstr *i = bstr_dup_c(" www.example.com :  8001 ");
+    bstr *e = bstr_dup_c("www.example.com");
+    bstr *host = NULL;
+    int port;
+    int flag = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &flag));
+
+    ASSERT_TRUE(host != NULL);
+    ASSERT_TRUE(bstr_cmp(e, host) == 0);
+    ASSERT_EQ(8001, port);
+    ASSERT_EQ(0, flag);
+
+    bstr_free(host);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort5) {
+    bstr *i = bstr_dup_c("www.example.com.");
+    bstr *e = bstr_dup_c("www.example.com.");
+    bstr *host = NULL;
+    int port;
+    int flag = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &flag));
+
+    ASSERT_TRUE(host != NULL);
+    ASSERT_TRUE(bstr_cmp(e, host) == 0);
+    ASSERT_EQ(-1, port);
+    ASSERT_EQ(0, flag);
+
+    bstr_free(host);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort6) {
+    bstr *i = bstr_dup_c("www.example.com.:8001");
+    bstr *e = bstr_dup_c("www.example.com.");
+    bstr *host = NULL;
+    int port;
+    int flag = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &flag));
+
+    ASSERT_TRUE(host != NULL);
+    ASSERT_TRUE(bstr_cmp(e, host) == 0);
+    ASSERT_EQ(8001, port);
+    ASSERT_EQ(0, flag);
+
+    bstr_free(host);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort7) {
+    bstr *i = bstr_dup_c("www.example.com:");
+    bstr *e = bstr_dup_c("www.example.com");
+    bstr *host = NULL;
+    int port;
+    int flag = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &flag));
+
+    ASSERT_TRUE(host != NULL);
+    ASSERT_TRUE(bstr_cmp(e, host) == 0);
+    ASSERT_EQ(-1, port);
+    ASSERT_EQ(1, flag);
+
+    bstr_free(host);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort8) {
+    bstr *i = bstr_dup_c("www.example.com:ff");
+    bstr *e = bstr_dup_c("www.example.com");
+    bstr *host = NULL;
+    int port;
+    int flag = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &flag));
+
+    ASSERT_TRUE(host != NULL);
+    ASSERT_TRUE(bstr_cmp(e, host) == 0);
+    ASSERT_EQ(-1, port);
+    ASSERT_EQ(1, flag);
+
+    bstr_free(host);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort9) {
+    bstr *i = bstr_dup_c("www.example.com:0");
+    bstr *e = bstr_dup_c("www.example.com");
+    bstr *host = NULL;
+    int port;
+    int flag = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &flag));
+
+    ASSERT_TRUE(host != NULL);
+    ASSERT_TRUE(bstr_cmp(e, host) == 0);
+    ASSERT_EQ(-1, port);
+    ASSERT_EQ(1, flag);
+
+    bstr_free(host);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort10) {
+    bstr *i = bstr_dup_c("www.example.com:65536");
+    bstr *e = bstr_dup_c("www.example.com");
+    bstr *host = NULL;
+    int port;
+    int flag = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &flag));
+
+    ASSERT_TRUE(host != NULL);
+    ASSERT_TRUE(bstr_cmp(e, host) == 0);
+    ASSERT_EQ(-1, port);
+    ASSERT_EQ(1, flag);
+
+    bstr_free(host);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort11) {
+    bstr *i = bstr_dup_c("[::1]:8080");
+    bstr *e = bstr_dup_c("[::1]");
+    bstr *host = NULL;
+    int port;
+    int invalid = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &invalid));
+
+    ASSERT_TRUE(host != NULL);
+    ASSERT_TRUE(bstr_cmp(e, host) == 0);
+    ASSERT_EQ(8080, port);
+    ASSERT_EQ(0, invalid);
+
+    bstr_free(host);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort12) {
+    bstr *i = bstr_dup_c("[::1]:");
+    bstr *e = bstr_dup_c("[::1]");
+    bstr *host = NULL;
+    int port;
+    int invalid = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &invalid));
+
+    ASSERT_TRUE(host != NULL);
+    ASSERT_TRUE(bstr_cmp(e, host) == 0);
+    ASSERT_EQ(-1, port);
+    ASSERT_EQ(1, invalid);
+
+    bstr_free(host);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort13) {
+    bstr *i = bstr_dup_c("[::1]x");
+    bstr *e = bstr_dup_c("[::1]");
+    bstr *host = NULL;
+    int port;
+    int invalid = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &invalid));
+
+    ASSERT_TRUE(host != NULL);
+    ASSERT_TRUE(bstr_cmp(e, host) == 0);
+    ASSERT_EQ(-1, port);
+    ASSERT_EQ(1, invalid);
+
+    bstr_free(host);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseHostPort14) {
+    bstr *i = bstr_dup_c("[::1");
+    bstr *host = NULL;
+    int port;
+    int invalid = 0;
+
+    ASSERT_EQ(HTP_OK, htp_parse_hostport(i, &host, NULL, &port, &invalid));
+
+    ASSERT_TRUE(host == NULL);
+    ASSERT_EQ(-1, port);
+    ASSERT_EQ(1, invalid);
+
+    bstr_free(host);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseContentType1) {
+    bstr *i = bstr_dup_c("multipart/form-data");
+    bstr *e = bstr_dup_c("multipart/form-data");
+    bstr *ct = NULL;
+
+    ASSERT_EQ(HTP_OK, htp_parse_ct_header(i, &ct));
+
+    ASSERT_TRUE(ct != NULL);
+    ASSERT_TRUE(bstr_cmp(e, ct) == 0);
+
+    bstr_free(ct);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseContentType2) {
+    bstr *i = bstr_dup_c("multipart/form-data;boundary=X");
+    bstr *e = bstr_dup_c("multipart/form-data");
+    bstr *ct = NULL;
+
+    ASSERT_EQ(HTP_OK, htp_parse_ct_header(i, &ct));
+
+    ASSERT_TRUE(ct != NULL);
+    ASSERT_TRUE(bstr_cmp(e, ct) == 0);
+
+    bstr_free(ct);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseContentType3) {
+    bstr *i = bstr_dup_c("multipart/form-data boundary=X");
+    bstr *e = bstr_dup_c("multipart/form-data");
+    bstr *ct = NULL;
+
+    ASSERT_EQ(HTP_OK, htp_parse_ct_header(i, &ct));
+
+    ASSERT_TRUE(ct != NULL);
+    ASSERT_TRUE(bstr_cmp(e, ct) == 0);
+
+    bstr_free(ct);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseContentType4) {
+    bstr *i = bstr_dup_c("multipart/form-data,boundary=X");
+    bstr *e = bstr_dup_c("multipart/form-data");
+    bstr *ct = NULL;
+
+    ASSERT_EQ(HTP_OK, htp_parse_ct_header(i, &ct));
+
+    ASSERT_TRUE(ct != NULL);
+    ASSERT_TRUE(bstr_cmp(e, ct) == 0);
+
+    bstr_free(ct);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseContentType5) {
+    bstr *i = bstr_dup_c("multipart/FoRm-data");
+    bstr *e = bstr_dup_c("multipart/form-data");
+    bstr *ct = NULL;
+
+    ASSERT_EQ(HTP_OK, htp_parse_ct_header(i, &ct));
+
+    ASSERT_TRUE(ct != NULL);
+    ASSERT_TRUE(bstr_cmp(e, ct) == 0);
+
+    bstr_free(ct);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ParseContentType6) {
+    bstr *i = bstr_dup_c("multipart/form-data\t boundary=X");
+    bstr *e = bstr_dup_c("multipart/form-data\t");
+    bstr *ct = NULL;
+
+    ASSERT_EQ(HTP_OK, htp_parse_ct_header(i, &ct));
+
+    ASSERT_TRUE(ct != NULL);
+    ASSERT_TRUE(bstr_cmp(e, ct) == 0);
+
+    bstr_free(ct);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST(UtilTest, ValidateHostname1) {
+    bstr *i = bstr_dup_c("www.example.com");
+    ASSERT_EQ(1, htp_validate_hostname(i));
+    bstr_free(i);
+}
+
+TEST(UtilTest, ValidateHostname2) {
+    bstr *i = bstr_dup_c(".www.example.com");
+    ASSERT_EQ(0, htp_validate_hostname(i));
+    bstr_free(i);
+}
+
+TEST(UtilTest, ValidateHostname3) {
+    bstr *i = bstr_dup_c("www..example.com");
+    ASSERT_EQ(0, htp_validate_hostname(i));
+    bstr_free(i);
+}
+
+TEST(UtilTest, ValidateHostname4) {
+    bstr *i = bstr_dup_c("www.example.com..");
+    ASSERT_EQ(0, htp_validate_hostname(i));
+    bstr_free(i);
+}
+
+TEST(UtilTest, ValidateHostname5) {
+    bstr *i = bstr_dup_c("www example com");
+    ASSERT_EQ(0, htp_validate_hostname(i));
+    bstr_free(i);
+}
+
+TEST(UtilTest, ValidateHostname6) {
+    bstr *i = bstr_dup_c("");
+    ASSERT_EQ(0, htp_validate_hostname(i));
+    bstr_free(i);
+}
+
+TEST(UtilTest, ValidateHostname7) {
+    // Label over 63 characters.
+    bstr *i = bstr_dup_c("www.exampleexampleexampleexampleexampleexampleexampleexampleexampleexample.com");
+    ASSERT_EQ(0, htp_validate_hostname(i));
+    bstr_free(i);
+}
+
+TEST(UtilTest, ValidateHostname8) {
+    bstr *i = bstr_dup_c("www.ExAmplE-1984.com");
+    ASSERT_EQ(1, htp_validate_hostname(i));
+    bstr_free(i);
+}
+
+class DecodingTest : public testing::Test {
+protected:
+
+    virtual void SetUp() {
+        testing::Test::SetUp();
+
+        cfg = htp_config_create();
+        connp = htp_connp_create(cfg);
+        htp_connp_open(connp, "127.0.0.1", 32768, "127.0.0.1", 80, NULL);
+        tx = htp_connp_tx_create(connp);
+    }
+
+    virtual void TearDown() {
+        htp_connp_destroy_all(connp);
+        htp_config_destroy(cfg);
+
+        testing::Test::TearDown();
+    }
+
+    htp_connp_t *connp;
+
+    htp_cfg_t *cfg;
+
+    htp_tx_t *tx;
+};
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace1_Identity) {
+    bstr *i = bstr_dup_c("/dest");
+    bstr *e = bstr_dup_c("/dest");
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace2_Urlencoded) {
+    bstr *i = bstr_dup_c("/%64est");
+    bstr *e = bstr_dup_c("/dest");
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace3_UrlencodedInvalidPreserve) {
+    bstr *i = bstr_dup_c("/%xxest");
+    bstr *e = bstr_dup_c("/%xxest");
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PRESERVE_PERCENT);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace4_UrlencodedInvalidRemove) {
+    bstr *i = bstr_dup_c("/%xxest");
+    bstr *e = bstr_dup_c("/xxest");
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_REMOVE_PERCENT);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace5_UrlencodedInvalidDecode) {
+    bstr *i = bstr_dup_c("/%}9est");
+    bstr *e = bstr_dup_c("/iest");
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PROCESS_INVALID);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace6_UrlencodedInvalidNotEnoughBytes) {
+    bstr *i = bstr_dup_c("/%a");
+    bstr *e = bstr_dup_c("/%a");
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace7_UrlencodedInvalidNotEnoughBytes) {
+    bstr *i = bstr_dup_c("/%");
+    bstr *e = bstr_dup_c("/%");
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace8_Uencoded) {
+    bstr *i = bstr_dup_c("/%u0064");
+    bstr *e = bstr_dup_c("/d");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace9_UencodedDoNotDecode) {
+    bstr *i = bstr_dup_c("/%u0064");
+    bstr *e = bstr_dup_c("/%u0064");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 0);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PRESERVE_PERCENT);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace10_UencodedInvalidNotEnoughBytes) {
+    bstr *i = bstr_dup_c("/%u006");
+    bstr *e = bstr_dup_c("/%u006");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PROCESS_INVALID);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace11_UencodedInvalidPreserve) {
+    bstr *i = bstr_dup_c("/%u006");
+    bstr *e = bstr_dup_c("/%u006");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PRESERVE_PERCENT);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace12_UencodedInvalidRemove) {
+    bstr *i = bstr_dup_c("/%uXXXX");
+    bstr *e = bstr_dup_c("/uXXXX");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_REMOVE_PERCENT);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace13_UencodedInvalidDecode) {
+    bstr *i = bstr_dup_c("/%u00}9");
+    bstr *e = bstr_dup_c("/i");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PROCESS_INVALID);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace14_UencodedInvalidPreserve) {
+    bstr *i = bstr_dup_c("/%u00");
+    bstr *e = bstr_dup_c("/%u00");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PRESERVE_PERCENT);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace15_UencodedInvalidPreserve) {
+    bstr *i = bstr_dup_c("/%u0");
+    bstr *e = bstr_dup_c("/%u0");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PRESERVE_PERCENT);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace16_UencodedInvalidPreserve) {
+    bstr *i = bstr_dup_c("/%u");
+    bstr *e = bstr_dup_c("/%u");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PRESERVE_PERCENT);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace17_UrlencodedNul) {
+    bstr *i = bstr_dup_c("/%00");
+    bstr *e = bstr_dup_mem("/\0", 2);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace18_UrlencodedNulTerminates) {
+    bstr *i = bstr_dup_c("/%00ABC");
+    bstr *e = bstr_dup_c("/");
+    htp_config_set_nul_encoded_terminates(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace19_RawNulTerminates) {
+    bstr *i = bstr_dup_mem("/\0ABC", 5);
+    bstr *e = bstr_dup_c("/");
+    htp_config_set_nul_raw_terminates(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodeUrlencodedInplace20_UencodedBestFit) {
+    bstr *i = bstr_dup_c("/%u0107");
+    bstr *e = bstr_dup_c("/c");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_tx_urldecode_params_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace1_UrlencodedInvalidNotEnoughBytes) {
+    bstr *i = bstr_dup_c("/%a");
+    bstr *e = bstr_dup_c("/%a");
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PROCESS_INVALID);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace2_UencodedInvalidNotEnoughBytes) {
+    bstr *i = bstr_dup_c("/%uX");
+    bstr *e = bstr_dup_c("/%uX");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PROCESS_INVALID);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace3_UencodedValid) {
+    bstr *i = bstr_dup_c("/%u0107");
+    bstr *e = bstr_dup_c("/c");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PROCESS_INVALID);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace4_UencodedInvalidNotHexDigits_Remove) {
+    bstr *i = bstr_dup_c("/%uXXXX");
+    bstr *e = bstr_dup_c("/uXXXX");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_REMOVE_PERCENT);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace5_UencodedInvalidNotHexDigits_Preserve) {
+    bstr *i = bstr_dup_c("/%uXXXX");
+    bstr *e = bstr_dup_c("/%uXXXX");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PRESERVE_PERCENT);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace6_UencodedInvalidNotHexDigits_Process) {
+    bstr *i = bstr_dup_c("/%u00}9");
+    bstr *e = bstr_dup_c("/i");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PROCESS_INVALID);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace7_UencodedNul) {
+    bstr *i = bstr_dup_c("/%u0000");
+    bstr *e = bstr_dup_mem("/\0", 2);
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PROCESS_INVALID);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_ENCODED_NUL);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace8_UencodedNotEnough_Remove) {
+    bstr *i = bstr_dup_c("/%uXXX");
+    bstr *e = bstr_dup_c("/uXXX");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_REMOVE_PERCENT);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace9_UencodedNotEnough_Preserve) {
+    bstr *i = bstr_dup_c("/%uXXX");
+    bstr *e = bstr_dup_c("/%uXXX");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PRESERVE_PERCENT);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace10_UrlencodedNul) {
+    bstr *i = bstr_dup_c("/%00123");
+    bstr *e = bstr_dup_mem("/\000123", 5);
+    htp_decode_path_inplace(tx, i);    
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_ENCODED_NUL);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace11_UrlencodedNul_Terminates) {
+    bstr *i = bstr_dup_c("/%00123");
+    bstr *e = bstr_dup_mem("/", 1);
+    htp_config_set_nul_encoded_terminates(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_decode_path_inplace(tx, i);    
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_ENCODED_NUL);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace12_EncodedSlash) {
+    bstr *i = bstr_dup_c("/one%2ftwo");
+    bstr *e = bstr_dup_c("/one%2ftwo");
+    htp_config_set_path_separators_decode(cfg, HTP_DECODER_DEFAULTS, 0);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_ENCODED_SEPARATOR);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace13_EncodedSlash_Decode) {
+    bstr *i = bstr_dup_c("/one%2ftwo");
+    bstr *e = bstr_dup_c("/one/two");
+    htp_config_set_path_separators_decode(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_ENCODED_SEPARATOR);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace14_Urlencoded_Invalid_Preserve) {
+    bstr *i = bstr_dup_c("/%HH");
+    bstr *e = bstr_dup_c("/%HH");
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PRESERVE_PERCENT);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace15_Urlencoded_Invalid_Remove) {
+    bstr *i = bstr_dup_c("/%HH");
+    bstr *e = bstr_dup_c("/HH");
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_REMOVE_PERCENT);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace16_Urlencoded_Invalid_Process) {
+    bstr *i = bstr_dup_c("/%}9");
+    bstr *e = bstr_dup_c("/i");
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PROCESS_INVALID);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace17_Urlencoded_NotEnough_Remove) {
+    bstr *i = bstr_dup_c("/%H");
+    bstr *e = bstr_dup_c("/H");
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_REMOVE_PERCENT);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace18_Urlencoded_NotEnough_Preserve) {
+    bstr *i = bstr_dup_c("/%H");
+    bstr *e = bstr_dup_c("/%H");
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PRESERVE_PERCENT);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace19_Urlencoded_NotEnough_Process) {
+    bstr *i = bstr_dup_c("/%H");
+    bstr *e = bstr_dup_c("/%H");
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_DEFAULTS, HTP_URL_DECODE_PROCESS_INVALID);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    ASSERT_TRUE(tx->flags & HTP_PATH_INVALID_ENCODING);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace20_RawNul1) {
+    bstr *i = bstr_dup_mem("/\000123", 5);
+    bstr *e = bstr_dup_c("/");
+    htp_config_set_nul_raw_terminates(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);    
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace21_RawNul1) {
+    bstr *i = bstr_dup_mem("/\000123", 5);
+    bstr *e = bstr_dup_mem("/\000123", 5);
+    htp_config_set_nul_raw_terminates(cfg, HTP_DECODER_DEFAULTS, 0);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace22_ConvertBackslash1) {
+    bstr *i = bstr_dup_c("/one\\two");
+    bstr *e = bstr_dup_c("/one/two");
+    htp_config_set_backslash_convert_slashes(cfg, HTP_DECODER_DEFAULTS, 1);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, DecodePathInplace23_ConvertBackslash2) {
+    bstr *i = bstr_dup_c("/one\\two");
+    bstr *e = bstr_dup_c("/one\\two");
+    htp_config_set_backslash_convert_slashes(cfg, HTP_DECODER_DEFAULTS, 0);
+    htp_decode_path_inplace(tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+TEST_F(DecodingTest, InvalidUtf8) {
+    bstr *i = bstr_dup_c("\xf1.");
+    bstr *e = bstr_dup_c("?.");
+    htp_config_set_utf8_convert_bestfit(cfg, HTP_DECODER_URL_PATH, 1);
+    htp_utf8_decode_path_inplace(cfg, tx, i);
+    ASSERT_TRUE(bstr_cmp(i, e) == 0);
+    bstr_free(e);
+    bstr_free(i);
+}
+
+class UrlencodedParser : public testing::Test {
+protected:
+
+    virtual void SetUp() {
+        cfg = htp_config_create();
+        connp = htp_connp_create(cfg);
+        htp_connp_open(connp, "127.0.0.1", 32768, "127.0.0.1", 80, NULL);
+        tx = htp_connp_tx_create(connp);
+        urlenp = htp_urlenp_create(tx);
+    }
+
+    virtual void TearDown() {
+        htp_urlenp_destroy(urlenp);
+        htp_connp_destroy_all(connp);
+        htp_config_destroy(cfg);
+    }
+
+    htp_connp_t *connp;
+
+    htp_cfg_t *cfg;
+
+    htp_tx_t *tx;
+
+    htp_urlenp_t *urlenp;
+};
+
+TEST_F(UrlencodedParser, Empty) {
+    htp_urlenp_parse_complete(urlenp, "", 0);
+
+    ASSERT_EQ(0, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, EmptyKey1) {
+    htp_urlenp_parse_complete(urlenp, "&", 1);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "", 0);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, EmptyKey2) {
+    htp_urlenp_parse_complete(urlenp, "=&", 2);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "", 0);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, EmptyKey3) {
+    htp_urlenp_parse_complete(urlenp, "=1&", 3);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "", 0);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, bstr_cmp_c(p, "1"));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, EmptyKeyAndValue) {
+    htp_urlenp_parse_complete(urlenp, "=", 1);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "", 0);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, OnePairEmptyValue) {
+    htp_urlenp_parse_complete(urlenp, "p=", 2);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "p", 1);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, OnePair) {
+    htp_urlenp_parse_complete(urlenp, "p=1", 3);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "p", 1);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, bstr_cmp_c(p, "1"));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, TwoPairs) {
+    htp_urlenp_parse_complete(urlenp, "p=1&q=2", 7);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "p", 1);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, bstr_cmp_c(p, "1"));
+
+    bstr *q = (bstr *) htp_table_get_mem(urlenp->params, "q", 1);
+    ASSERT_TRUE(q != NULL);
+    ASSERT_EQ(0, bstr_cmp_c(q, "2"));
+
+    ASSERT_EQ(2, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, KeyNoValue1) {
+    htp_urlenp_parse_complete(urlenp, "p", 1);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "p", 1);
+    ASSERT_TRUE(p != NULL);
+
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, KeyNoValue2) {
+    htp_urlenp_parse_complete(urlenp, "p&", 2);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "p", 1);
+    ASSERT_TRUE(p != NULL);
+
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, KeyNoValue3) {
+    htp_urlenp_parse_complete(urlenp, "p&q", 3);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "p", 1);
+    ASSERT_TRUE(p != NULL);
+
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    bstr *q = (bstr *) htp_table_get_mem(urlenp->params, "q", 1);
+    ASSERT_TRUE(q != NULL);
+    ASSERT_EQ(0, bstr_cmp_c(q, ""));
+
+    ASSERT_EQ(2, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, KeyNoValue4) {
+    htp_urlenp_parse_complete(urlenp, "p&q=2", 5);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "p", 1);
+    ASSERT_TRUE(p != NULL);
+
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    bstr *q = (bstr *) htp_table_get_mem(urlenp->params, "q", 1);
+    ASSERT_TRUE(q != NULL);
+    ASSERT_EQ(0, bstr_cmp_c(q, "2"));
+
+    ASSERT_EQ(2, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, Partial1) {
+    htp_urlenp_parse_partial(urlenp, "p", 1);
+    htp_urlenp_finalize(urlenp);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "p", 1);
+    ASSERT_TRUE(p != NULL);
+
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, Partial2) {
+    htp_urlenp_parse_partial(urlenp, "p", 1);
+    htp_urlenp_parse_partial(urlenp, "x", 1);
+    htp_urlenp_finalize(urlenp);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "px", 2);
+    ASSERT_TRUE(p != NULL);
+
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, Partial3) {
+    htp_urlenp_parse_partial(urlenp, "p", 1);
+    htp_urlenp_parse_partial(urlenp, "x&", 2);
+    htp_urlenp_finalize(urlenp);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "px", 2);
+    ASSERT_TRUE(p != NULL);
+
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, Partial4) {
+    htp_urlenp_parse_partial(urlenp, "p", 1);
+    htp_urlenp_parse_partial(urlenp, "=", 1);
+    htp_urlenp_finalize(urlenp);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "p", 1);
+    ASSERT_TRUE(p != NULL);
+
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, Partial5) {
+    htp_urlenp_parse_partial(urlenp, "p", 1);
+    htp_urlenp_parse_partial(urlenp, "", 0);
+    htp_urlenp_parse_partial(urlenp, "", 0);
+    htp_urlenp_parse_partial(urlenp, "", 0);
+    htp_urlenp_finalize(urlenp);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "p", 1);
+    ASSERT_TRUE(p != NULL);
+
+    ASSERT_EQ(0, bstr_cmp_c(p, ""));
+
+    ASSERT_EQ(1, htp_table_size(urlenp->params));
+}
+
+TEST_F(UrlencodedParser, Partial6) {
+    htp_urlenp_parse_partial(urlenp, "px", 2);
+    htp_urlenp_parse_partial(urlenp, "n", 1);
+    htp_urlenp_parse_partial(urlenp, "", 0);
+    htp_urlenp_parse_partial(urlenp, "=", 1);
+    htp_urlenp_parse_partial(urlenp, "1", 1);
+    htp_urlenp_parse_partial(urlenp, "2", 1);
+    htp_urlenp_parse_partial(urlenp, "&", 1);
+    htp_urlenp_parse_partial(urlenp, "qz", 2);
+    htp_urlenp_parse_partial(urlenp, "n", 1);
+    htp_urlenp_parse_partial(urlenp, "", 0);
+    htp_urlenp_parse_partial(urlenp, "=", 1);
+    htp_urlenp_parse_partial(urlenp, "2", 1);
+    htp_urlenp_parse_partial(urlenp, "3", 1);
+    htp_urlenp_parse_partial(urlenp, "&", 1);
+    htp_urlenp_finalize(urlenp);
+
+    bstr *p = (bstr *) htp_table_get_mem(urlenp->params, "pxn", 3);
+    ASSERT_TRUE(p != NULL);
+
+    ASSERT_EQ(0, bstr_cmp_c(p, "12"));
+
+    bstr *q = (bstr *) htp_table_get_mem(urlenp->params, "qzn", 3);
+    ASSERT_TRUE(p != NULL);
+
+    ASSERT_EQ(0, bstr_cmp_c(q, "23"));
+
+    ASSERT_EQ(2, htp_table_size(urlenp->params));
+}
+
+TEST(List, Misc) {
+    htp_list_t *l = htp_list_create(16);
+
+    htp_list_push(l, (void *) "1");
+    htp_list_push(l, (void *) "2");
+    htp_list_push(l, (void *) "3");
+
+    ASSERT_EQ(3, htp_list_size(l));
+
+    char *p = (char *) htp_list_pop(l);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("3", p));
+
+    ASSERT_EQ(2, htp_list_size(l));
+
+    p = (char *) htp_list_shift(l);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("1", p));
+
+    ASSERT_EQ(1, htp_list_size(l));
+
+    p = (char *) htp_list_shift(l);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("2", p));
+
+    p = (char *) htp_list_shift(l);
+    ASSERT_TRUE(p == NULL);
+
+    p = (char *) htp_list_pop(l);
+    ASSERT_TRUE(p == NULL);
+
+    htp_list_destroy(l);
+}
+
+TEST(List, Misc2) {
+    htp_list_t *l = htp_list_create(1);
+
+    htp_list_push(l, (void *) "1");
+
+    char *p = (char *) htp_list_shift(l);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("1", p));
+
+    htp_list_push(l, (void *) "2");
+
+    p = (char *) htp_list_shift(l);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("2", p));
+
+    ASSERT_EQ(0, htp_list_size(l));
+
+    htp_list_destroy(l);
+}
+
+TEST(List, Misc3) {
+    htp_list_t *l = htp_list_create(2);
+
+    htp_list_push(l, (void *) "1");
+    htp_list_push(l, (void *) "2");
+
+    char *p = (char *) htp_list_shift(l);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("1", p));
+
+    htp_list_push(l, (void *) "3");
+
+    p = (char *) htp_list_get(l, 1);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("3", p));
+
+    ASSERT_EQ(2, htp_list_size(l));
+
+    htp_list_replace(l, 1, (void *) "4");
+
+    p = (char *) htp_list_pop(l);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("4", p));
+
+    htp_list_destroy(l);
+}
+
+TEST(List, Expand1) {
+    htp_list_t *l = htp_list_create(2);
+
+    htp_list_push(l, (void *) "1");
+    htp_list_push(l, (void *) "2");
+
+    ASSERT_EQ(2, htp_list_size(l));
+
+    htp_list_push(l, (void *) "3");
+
+    ASSERT_EQ(3, htp_list_size(l));
+
+    char *p = (char *) htp_list_get(l, 0);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("1", p));
+
+    p = (char *) htp_list_get(l, 1);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("2", p));
+
+    p = (char *) htp_list_get(l, 2);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("3", p));
+
+    htp_list_destroy(l);
+}
+
+TEST(List, Expand2) {
+    htp_list_t *l = htp_list_create(2);
+
+    htp_list_push(l, (void *) "1");
+    htp_list_push(l, (void *) "2");
+
+    ASSERT_EQ(2, htp_list_size(l));
+
+    htp_list_shift(l);
+
+    ASSERT_EQ(1, htp_list_size(l));
+
+    htp_list_push(l, (void *) "3");
+    htp_list_push(l, (void *) "4");
+
+    ASSERT_EQ(3, htp_list_size(l));
+
+    char *p = (char *) htp_list_get(l, 0);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("2", p));
+
+    p = (char *) htp_list_get(l, 1);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("3", p));
+
+    p = (char *) htp_list_get(l, 2);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("4", p));
+
+    htp_list_destroy(l);
+}
+
+TEST(Table, Misc) {
+    htp_table_t *t = htp_table_create(2);
+
+    bstr *pkey = bstr_dup_c("p");
+    bstr *qkey = bstr_dup_c("q");
+
+    htp_table_addk(t, pkey, "1");
+    htp_table_addk(t, qkey, "2");
+
+    char *p = (char *) htp_table_get_mem(t, "z", 1);
+    ASSERT_TRUE(p == NULL);
+
+    p = (char *) htp_table_get(t, pkey);
+    ASSERT_TRUE(p != NULL);
+    ASSERT_EQ(0, strcmp("1", p));
+
+    htp_table_clear_ex(t);
+
+    bstr_free(qkey);
+    bstr_free(pkey);
+
+    htp_table_destroy(t);
+}
+
+TEST(Util, ExtractQuotedString) {
+    bstr *s;
+    size_t end_offset;
+
+    htp_status_t rc = htp_extract_quoted_string_as_bstr((unsigned char *) "\"test\"", 6, &s, &end_offset);
+    ASSERT_EQ(HTP_OK, rc);
+    ASSERT_TRUE(s != NULL);
+    ASSERT_EQ(0, bstr_cmp_c(s, "test"));
+    ASSERT_EQ(5, end_offset);
+    bstr_free(s);
+
+    rc = htp_extract_quoted_string_as_bstr((unsigned char *) "\"te\\\"st\"", 8, &s, &end_offset);
+    ASSERT_EQ(HTP_OK, rc);
+    ASSERT_TRUE(s != NULL);
+    ASSERT_EQ(0, bstr_cmp_c(s, "te\"st"));
+    ASSERT_EQ(7, end_offset);
+    bstr_free(s);
+}
+
+TEST(Util, NormalizeUriPath) {
+    bstr *s = NULL;
+
+    s = bstr_dup_c("/a/b/c/./../../g");
+    htp_normalize_uri_path_inplace(s);
+    ASSERT_EQ(0, bstr_cmp_c(s, "/a/g"));
+    bstr_free(s);
+
+    s = bstr_dup_c("mid/content=5/../6");
+    htp_normalize_uri_path_inplace(s);
+    ASSERT_EQ(0, bstr_cmp_c(s, "mid/6"));
+    bstr_free(s);
+
+    s = bstr_dup_c("./one");
+    htp_normalize_uri_path_inplace(s);    
+    ASSERT_EQ(0, bstr_cmp_c(s, "one"));
+    bstr_free(s);
+    
+    s = bstr_dup_c("../one");
+    htp_normalize_uri_path_inplace(s);    
+    ASSERT_EQ(0, bstr_cmp_c(s, "one"));
+    bstr_free(s);
+
+    s = bstr_dup_c(".");
+    htp_normalize_uri_path_inplace(s);    
+    ASSERT_EQ(0, bstr_cmp_c(s, ""));
+    bstr_free(s);
+
+    s = bstr_dup_c("..");
+    htp_normalize_uri_path_inplace(s);    
+    ASSERT_EQ(0, bstr_cmp_c(s, ""));
+    bstr_free(s);
+    
+    s = bstr_dup_c("one/.");
+    htp_normalize_uri_path_inplace(s);    
+    ASSERT_EQ(0, bstr_cmp_c(s, "one"));
+    bstr_free(s);
+    
+    s = bstr_dup_c("one/..");
+    htp_normalize_uri_path_inplace(s);    
+    ASSERT_EQ(0, bstr_cmp_c(s, ""));
+    bstr_free(s);
+
+    s = bstr_dup_c("one/../");
+    htp_normalize_uri_path_inplace(s);    
+    ASSERT_EQ(0, bstr_cmp_c(s, ""));
+    bstr_free(s);    
+}
+
+TEST_F(UrlencodedParser, UrlDecode1) {
+    bstr *s = NULL;
+    uint64_t flags;
+    
+    s = bstr_dup_c("/one/tw%u006f/three/%u123");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_URLENCODED, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_URLENCODED, HTP_URL_DECODE_PRESERVE_PERCENT);
+    htp_urldecode_inplace(cfg, HTP_DECODER_URLENCODED, s, &flags);
+    ASSERT_EQ(0, bstr_cmp_c(s, "/one/two/three/%u123"));
+    bstr_free(s);
+
+    s = bstr_dup_c("/one/tw%u006f/three/%uXXXX");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_URLENCODED, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_URLENCODED, HTP_URL_DECODE_PRESERVE_PERCENT);
+    htp_urldecode_inplace(cfg, HTP_DECODER_URLENCODED, s, &flags);
+    ASSERT_EQ(0, bstr_cmp_c(s, "/one/two/three/%uXXXX"));
+    bstr_free(s);
+
+    s = bstr_dup_c("/one/tw%u006f/three/%u123");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_URLENCODED, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_URLENCODED, HTP_URL_DECODE_REMOVE_PERCENT);
+    htp_urldecode_inplace(cfg, HTP_DECODER_URLENCODED, s, &flags);
+    ASSERT_EQ(0, bstr_cmp_c(s, "/one/two/three/u123"));
+    bstr_free(s);
+
+    s = bstr_dup_c("/one/tw%u006f/three/%3");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_URLENCODED, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_URLENCODED, HTP_URL_DECODE_REMOVE_PERCENT);
+    htp_urldecode_inplace(cfg, HTP_DECODER_URLENCODED, s, &flags);
+    ASSERT_EQ(0, bstr_cmp_c(s, "/one/two/three/3"));
+    bstr_free(s);
+
+    s = bstr_dup_c("/one/tw%u006f/three/%3");
+    htp_config_set_u_encoding_decode(cfg, HTP_DECODER_URLENCODED, 1);
+    htp_config_set_url_encoding_invalid_handling(cfg, HTP_DECODER_URLENCODED, HTP_URL_DECODE_PROCESS_INVALID);
+    htp_urldecode_inplace(cfg, HTP_DECODER_URLENCODED, s, &flags);
+    ASSERT_EQ(0, bstr_cmp_c(s, "/one/two/three/%3"));
+    bstr_free(s);
+}
+
+TEST(UtilTest, HeaderHasToken) {
+    char data[100];
+
+    // Basic
+    strcpy(data, "chunked");
+    EXPECT_EQ(HTP_OK, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+
+    // Negative
+    strcpy(data, "notchunked");
+    EXPECT_EQ(HTP_ERROR, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+    strcpy(data, "chunkednot");
+    EXPECT_EQ(HTP_ERROR, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+    strcpy(data, "chunk,ed");
+    EXPECT_EQ(HTP_ERROR, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+    strcpy(data, "chunk ed");
+    EXPECT_EQ(HTP_ERROR, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+
+    // Positive
+    strcpy(data, " notchunked , chunked , yetanother");
+    EXPECT_EQ(HTP_OK, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+    strcpy(data, "chunked,yetanother");
+    EXPECT_EQ(HTP_OK, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+    strcpy(data, "not,chunked");
+    EXPECT_EQ(HTP_OK, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+    strcpy(data, "chunk,chunked");
+    EXPECT_EQ(HTP_OK, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+    strcpy(data, " chunked");
+    EXPECT_EQ(HTP_OK, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+    strcpy(data, "chunked ");
+    EXPECT_EQ(HTP_OK, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+    strcpy(data, "chunked,");
+    EXPECT_EQ(HTP_OK, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+    strcpy(data, ",chunked");
+    EXPECT_EQ(HTP_OK, htp_header_has_token((unsigned char*) data, strlen(data), (unsigned char *)"chunked"));
+}