// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// Date 2014/10/24 16:44:30

#include <gtest/gtest.h>
#include <google/protobuf/descriptor.h>

#include "brpc/server.h"
#include "brpc/details/http_message.h"
#include "brpc/policy/http_rpc_protocol.h"
#include "echo.pb.h"

namespace brpc {

DECLARE_bool(allow_chunked_length);
DECLARE_bool(allow_http_1_1_request_without_host);

int main(int argc, char* argv[]) {
    testing::InitGoogleTest(&argc, argv);
    GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
    brpc::FLAGS_allow_http_1_1_request_without_host = true;
    return RUN_ALL_TESTS();
}

namespace policy {
Server::MethodProperty*
FindMethodPropertyByURI(const std::string& uri_path, const Server* server,
                        std::string* unknown_method_str);
bool ParseHttpServerAddress(butil::EndPoint *point, const char *server_addr_and_port);
}}

namespace {
using brpc::policy::FindMethodPropertyByURI;
using brpc::policy::ParseHttpServerAddress;

TEST(HttpMessageTest, http_method) {
    ASSERT_STREQ("DELETE", brpc::HttpMethod2Str(brpc::HTTP_METHOD_DELETE));
    ASSERT_STREQ("GET", brpc::HttpMethod2Str(brpc::HTTP_METHOD_GET));
    ASSERT_STREQ("POST", brpc::HttpMethod2Str(brpc::HTTP_METHOD_POST));
    ASSERT_STREQ("PUT", brpc::HttpMethod2Str(brpc::HTTP_METHOD_PUT));

    brpc::HttpMethod m;
    ASSERT_TRUE(brpc::Str2HttpMethod("DELETE", &m));
    ASSERT_EQ(brpc::HTTP_METHOD_DELETE, m);
    ASSERT_TRUE(brpc::Str2HttpMethod("GET", &m));
    ASSERT_EQ(brpc::HTTP_METHOD_GET, m);
    ASSERT_TRUE(brpc::Str2HttpMethod("POST", &m));
    ASSERT_EQ(brpc::HTTP_METHOD_POST, m);
    ASSERT_TRUE(brpc::Str2HttpMethod("PUT", &m));
    ASSERT_EQ(brpc::HTTP_METHOD_PUT, m);

    // case-insensitive
    ASSERT_TRUE(brpc::Str2HttpMethod("DeLeTe", &m));
    ASSERT_EQ(brpc::HTTP_METHOD_DELETE, m);
    ASSERT_TRUE(brpc::Str2HttpMethod("get", &m));
    ASSERT_EQ(brpc::HTTP_METHOD_GET, m);

    // non-existed
    ASSERT_FALSE(brpc::Str2HttpMethod("DEL", &m));
    ASSERT_FALSE(brpc::Str2HttpMethod("DELETE ", &m));
    ASSERT_FALSE(brpc::Str2HttpMethod("GOT", &m));
}

TEST(HttpMessageTest, eof) {
    GFLAGS_NAMESPACE::SetCommandLineOption("verbose", "100");
    const char* http_request = 
        "GET /CloudApiControl/HttpServer/telematics/v3/weather?location=%E6%B5%B7%E5%8D%97%E7%9C%81%E7%9B%B4%E8%BE%96%E5%8E%BF%E7%BA%A7%E8%A1%8C%E6%94%BF%E5%8D%95%E4%BD%8D&output=json&ak=0l3FSP6qA0WbOzGRaafbmczS HTTP/1.1\r\n"
        "X-Host: api.map.baidu.com\r\n"
        "X-Forwarded-Proto: http\r\n"
        "Host: api.map.baidu.com\r\n"
        "User-Agent: IME/Android/4.4.2/N80.QHD.LT.X10.V3/N80.QHD.LT.X10.V3.20150812.031915\r\n"
        "Accept: application/json\r\n"
        "Accept-Charset: UTF-8,*;q=0.5\r\n"
        "Accept-Encoding: deflate,sdch\r\n"
        "Accept-Language: zh-CN,en-US;q=0.8,zh;q=0.6\r\n"
        "Bfe-Atk: NORMAL_BROWSER\r\n"
        "Bfe_logid: 8767802212038413243\r\n"
        "Bfeip: 10.26.124.40\r\n"
        "CLIENTIP: 119.29.102.26\r\n"
        "CLIENTPORT: 59863\r\n"
        "Cache-Control: max-age=0\r\n"
        "Content-Type: application/json;charset=utf8\r\n"
        "X-Forwarded-For: 119.29.102.26\r\n"
        "X-Forwarded-Port: 59863\r\n"
        "X-Ime-Imei: 35629601890905\r\n"
        "X_BD_LOGID: 3959476981\r\n"
        "X_BD_LOGID64: 16815814797661447369\r\n"
        "X_BD_PRODUCT: map\r\n"
        "X_BD_SUBSYS: apimap\r\n";
    butil::IOBuf buf;
    buf.append(http_request);
    brpc::HttpMessage http_message;
    ASSERT_EQ((ssize_t)buf.size(), http_message.ParseFromIOBuf(buf));
    ASSERT_EQ(2, http_message.ParseFromArray("\r\n", 2));
    ASSERT_TRUE(http_message.Completed());
}


TEST(HttpMessageTest, request_sanity) {
    const char *http_request = 
        "POST /path/file.html?sdfsdf=sdfs&sldf1=sdf HTTP/12.34\r\n"
        "From: someuser@jmarshall.com\r\n"
        "User-Agent: HTTPTool/1.0  \r\n"  // intended ending spaces
        "Content-Type: json\r\n"
        "Content-Length: 19\r\n"
        "Log-ID: 456\r\n"
        "Host: myhost\r\n"
        "Correlation-ID: 123\r\n"
        "Authorization: test\r\n"
        "Accept: */*\r\n"
        "\r\n"
        "Message Body sdfsdf\r\n"
    ;
    brpc::HttpMessage http_message;
    ASSERT_EQ((ssize_t)strlen(http_request), 
              http_message.ParseFromArray(http_request, strlen(http_request)));
    const brpc::HttpHeader& header = http_message.header();
    // Check all keys
    ASSERT_EQ("json", header.content_type());
    ASSERT_TRUE(header.GetHeader("HOST"));
    ASSERT_EQ("myhost", *header.GetHeader("host"));
    ASSERT_TRUE(header.GetHeader("CORRELATION-ID"));
    ASSERT_EQ("123", *header.GetHeader("CORRELATION-ID"));
    ASSERT_TRUE(header.GetHeader("User-Agent"));
    ASSERT_EQ("HTTPTool/1.0  ", *header.GetHeader("User-Agent"));
    ASSERT_TRUE(header.GetHeader("Host"));
    ASSERT_EQ("myhost", *header.GetHeader("Host"));
    ASSERT_TRUE(header.GetHeader("Accept"));
    ASSERT_EQ("*/*", *header.GetHeader("Accept"));
    
    ASSERT_EQ(1, header.major_version());
    ASSERT_EQ(34, header.minor_version());
    ASSERT_EQ(brpc::HTTP_METHOD_POST, header.method());
    ASSERT_EQ(brpc::HTTP_STATUS_OK, header.status_code());
    ASSERT_STREQ("OK", header.reason_phrase());

    ASSERT_TRUE(header.GetHeader("log-id"));
    ASSERT_EQ("456", *header.GetHeader("log-id"));
    ASSERT_TRUE(NULL != header.GetHeader("Authorization"));
    ASSERT_EQ("test", *header.GetHeader("Authorization"));
}

TEST(HttpMessageTest, response_sanity) {
    const char *http_response = 
        "HTTP/12.34 410 GoneBlah\r\n"
        "From: someuser@jmarshall.com\r\n"
        "User-Agent: HTTPTool/1.0  \r\n"  // intended ending spaces
        "Content-Type: json2\r\n"
        "Content-Length: 19\r\n"
        "Log-ID: 456\r\n"
        "Host: myhost\r\n"
        "Correlation-ID: 123\r\n"
        "Authorization: test\r\n"
        "Accept: */*\r\n"
        "\r\n"
        "Message Body sdfsdf\r\n"
    ;
    brpc::HttpMessage http_message;
    ASSERT_EQ((ssize_t)strlen(http_response), 
              http_message.ParseFromArray(http_response, strlen(http_response)));
    // Check all keys
    const brpc::HttpHeader& header = http_message.header();
    ASSERT_EQ("json2", header.content_type());
    ASSERT_TRUE(header.GetHeader("HOST"));
    ASSERT_EQ("myhost", *header.GetHeader("host"));
    ASSERT_TRUE(header.GetHeader("CORRELATION-ID"));
    ASSERT_EQ("123", *header.GetHeader("CORRELATION-ID"));
    ASSERT_TRUE(header.GetHeader("User-Agent"));
    ASSERT_EQ("HTTPTool/1.0  ", *header.GetHeader("User-Agent"));
    ASSERT_TRUE(header.GetHeader("Host"));
    ASSERT_EQ("myhost", *header.GetHeader("Host"));
    ASSERT_TRUE(header.GetHeader("Accept"));
    ASSERT_EQ("*/*", *header.GetHeader("Accept"));
    
    ASSERT_EQ(1, header.major_version());
    ASSERT_EQ(34, header.minor_version());
    // method is undefined for response, in our case, it's set to 0.
    ASSERT_EQ(brpc::HTTP_METHOD_DELETE, header.method());
    ASSERT_EQ(brpc::HTTP_STATUS_GONE, header.status_code());
    ASSERT_STREQ(brpc::HttpReasonPhrase(header.status_code()), /*not GoneBlah*/
                 header.reason_phrase());
    
    ASSERT_TRUE(header.GetHeader("log-id"));
    ASSERT_EQ("456", *header.GetHeader("log-id"));
    ASSERT_TRUE(header.GetHeader("Authorization"));
    ASSERT_EQ("test", *header.GetHeader("Authorization"));
}

TEST(HttpMessageTest, bad_format) {
    const char *http_request =
        "slkdjflksdf skldjf\r\n";
    brpc::HttpMessage http_message;
    ASSERT_EQ(-1, http_message.ParseFromArray(http_request, strlen(http_request)));
}

TEST(HttpMessageTest, incompleted_request_line) {
    const char *http_request = "GE" ;
    brpc::HttpMessage http_message;
    ASSERT_TRUE(http_message.ParseFromArray(http_request, strlen(http_request)) >= 0);
    ASSERT_FALSE(http_message.Completed());
}

TEST(HttpMessageTest, parse_from_iobuf) {
    const size_t content_length = 8192;
    char header[1024];
    snprintf(header, sizeof(header),
            "GET /service/method?key1=value1&key2=value2&key3=value3 HTTP/1.1\r\n"
            "Content-Type: text/plain\r\n"
            "Content-Length: %lu\r\n"
            "\r\n",
            content_length);
    butil::IOBuf content;
    for (size_t i = 0; i < content_length; ++i) {
        content.push_back('2');
    }
    butil::IOBuf request;
    request.append(header);
    request.append(content);

    brpc::HttpMessage http_message;
    ASSERT_TRUE(http_message.ParseFromIOBuf(request) >= 0);
    ASSERT_TRUE(http_message.Completed());
    ASSERT_EQ(content, http_message.body());
    ASSERT_EQ(content, http_message.body().to_string());
    ASSERT_EQ("text/plain", http_message.header().content_type());
}


TEST(HttpMessageTest, parse_http_head_response) {
    char response1[1024] = "HTTP/1.1 200 OK\r\n"
                          "Content-Type: text/plain\r\n"
                          "Content-Length: 1024\r\n"
                          "\r\n";
    butil::IOBuf request;
    request.append(response1);

    brpc::HttpMessage http_message(false, brpc::HTTP_METHOD_HEAD);
    ASSERT_TRUE(http_message.ParseFromIOBuf(request) >= 0);
    ASSERT_TRUE(http_message.Completed()) << http_message.stage();
    ASSERT_EQ("text/plain", http_message.header().content_type());
    const std::string* content_length = http_message.header().GetHeader("Content-Length");
    ASSERT_NE(nullptr, content_length);
    ASSERT_EQ("1024", *content_length);


    char response2[1024] = "HTTP/1.1 200 OK\r\n"
                           "Content-Type: text/plain\r\n"
                           "Transfer-Encoding: chunked\r\n"
                           "\r\n";
    butil::IOBuf request2;
    request2.append(response2);
    brpc::HttpMessage http_message2(false, brpc::HTTP_METHOD_HEAD);
    ASSERT_TRUE(http_message2.ParseFromIOBuf(request2) >= 0);
    ASSERT_TRUE(http_message2.Completed()) << http_message2.stage();
    ASSERT_EQ("text/plain", http_message2.header().content_type());
    const std::string* transfer_encoding = http_message2.header().GetHeader("Transfer-Encoding");
    ASSERT_NE(nullptr, transfer_encoding);
    ASSERT_EQ("chunked", *transfer_encoding);
}

TEST(HttpMessageTest, parse_http_cookie) {
    const char* http_request =
        "GET /CloudApiControl HTTP/1.1\r\n"
        "Host: api.map.baidu.com\r\n"
        "Accept: application/json\r\n"
        "cookie: a=1\r\n"
        "Cookie: b=2\r\n"
        "\r\n";
    butil::IOBuf buf;
    buf.append(http_request);
    brpc::HttpMessage http_message;
    ASSERT_EQ((ssize_t)buf.size(), http_message.ParseFromIOBuf(buf));
    ASSERT_TRUE(http_message.Completed());

    const std::string* cookie
        = http_message.header().GetHeader("cookie");
    ASSERT_NE(nullptr, cookie);
    ASSERT_EQ("a=1; b=2", *cookie);
}

TEST(HttpMessageTest, parse_http_set_cookie) {
    char response[1024] = "HTTP/1.1 200 OK\r\n"
                          "Content-Type: text/plain\r\n"
                          "Content-Length: 1024\r\n"
                          "set-cookie: a=1\r\n"
                          "Set-Cookie: b=2\r\n"
                          "\r\n";
    butil::IOBuf request;
    request.append(response);
    brpc::HttpMessage http_message(false, brpc::HTTP_METHOD_HEAD);
    ASSERT_TRUE(http_message.ParseFromIOBuf(request) >= 0);
    ASSERT_TRUE(http_message.Completed()) << http_message.stage();

    const std::string* set_cookie = http_message.header().GetHeader("set-cookie");
    ASSERT_NE(nullptr, set_cookie);
    ASSERT_EQ("a=1", *set_cookie);
    std::vector<const std::string*> all_set_cookie
        = http_message.header().GetAllSetCookieHeader();
    for (const std::string* sc : all_set_cookie) {
        ASSERT_NE(nullptr, sc);
        if (set_cookie == sc) {
            ASSERT_EQ("a=1", *sc);
        } else {
            ASSERT_EQ("b=2", *sc);
        }
        if (http_message.header().IsSetCookie(*sc)) {
        }
    }
    int set_cookie_value1_count = 0;
    int set_cookie_value2_count = 0;
    for (auto iter = http_message.header().HeaderBegin();
         iter != http_message.header().HeaderEnd(); ++iter) {
        if (!http_message.header().IsSetCookie(iter->first)) {
            continue;
        }
        if (iter->second == "b=2") {
            ++set_cookie_value2_count;
        } else if (iter->second == "a=1") {
            ++set_cookie_value1_count;
        }
    }
    ASSERT_EQ(1, set_cookie_value1_count);
    ASSERT_EQ(1, set_cookie_value2_count);
}

TEST(HttpMessageTest, cl_and_te) {
    // https://datatracker.ietf.org/doc/html/rfc2616#section-14.41
    // If multiple encodings have been applied to an entity, the transfer-
    // codings MUST be listed in the order in which they were applied.
    const char* request_buf1 = "POST /chunked_w_content_length HTTP/1.1\r\n"
                               "Content-Length: 10\r\n"
                               "Transfer-Encoding: gzip,chunked\r\n"
                               "\r\n"
                               "5; ilovew3;whattheluck=aretheseparametersfor\r\nhello\r\n"
                               "6; blahblah; blah\r\n world\r\n"
                               "0\r\n"
                               "\r\n";
    butil::IOBuf request1;
    request1.append(request_buf1);

    const char* request_buf2 = "POST /chunked_w_content_length HTTP/1.1\r\n"
                               "Content-Length: 19\r\n"
                               "Transfer-Encoding: chunked,gzip\r\n"
                               "\r\n"
                               "Message Body sdfsdf";
    butil::IOBuf request2;
    request2.append(request_buf2);

    const char* response_buf1 = "HTTP/1.1 200 OK\r\n"
                                "Content-Length: 10\r\n"
                                "Transfer-Encoding: gzip,chunked\r\n"
                                "\r\n"
                                "5; ilovew3;whattheluck=aretheseparametersfor\r\nhello\r\n"
                                "6; blahblah; blah\r\n world\r\n"
                                "0\r\n"
                                "\r\n";
    butil::IOBuf response1;
    response1.append(response_buf1);

    const char* response_buf2 = "HTTP/1.1 200 OK\r\n"
                                "Content-Length: 19\r\n"
                                "Transfer-Encoding: chunked,gzip\r\n"
                                "\r\n"
                                "Message Body sdfsdf";
    butil::IOBuf response2;
    response2.append(response_buf2);

    brpc::FLAGS_allow_chunked_length = false;
    {
        brpc::HttpMessage http_message;
        ASSERT_EQ(http_message.ParseFromIOBuf(request1), -1)
                        << http_message._parser;
    }
    {
        brpc::HttpMessage http_message;
        ASSERT_EQ(http_message.ParseFromIOBuf(request2), -1)
                        << http_message._parser;
    }
    {
        brpc::HttpMessage http_message;
        ASSERT_EQ(http_message.ParseFromIOBuf(response1), -1)
                        << http_message._parser;
    }
    {
        brpc::HttpMessage http_message;
        ASSERT_EQ(http_message.ParseFromIOBuf(response2), -1)
                        << http_message._parser;
    }

    brpc::FLAGS_allow_chunked_length = true;
    {
        brpc::HttpMessage http_message;
        ASSERT_EQ(http_message.ParseFromIOBuf(request1), request1.size())
                        << http_message._parser;
    }
    {
        brpc::HttpMessage http_message;
        ASSERT_EQ(http_message.ParseFromIOBuf(request2), -1)
                        << http_message._parser;
    }
    {
        brpc::HttpMessage http_message;
        ASSERT_EQ(http_message.ParseFromIOBuf(response1), response1.size())
                        << http_message._parser;
    }
    {
        brpc::HttpMessage http_message;
        ASSERT_EQ(http_message.ParseFromIOBuf(response2), -1)
                        << http_message._parser;
    }
}

TEST(HttpMessageTest, find_method_property_by_uri) {
    brpc::Server server;
    ASSERT_EQ(0, server.AddService(new test::EchoService(),
                                   brpc::SERVER_OWNS_SERVICE));
    ASSERT_EQ(0, server.Start(9237, NULL));
    std::string unknown_method;
    brpc::Server::MethodProperty* mp = NULL;
              
    mp = FindMethodPropertyByURI("", &server, NULL);
    ASSERT_TRUE(mp);
    ASSERT_EQ("index", mp->method->service()->name());

    mp = FindMethodPropertyByURI("/", &server, NULL);
    ASSERT_TRUE(mp);
    ASSERT_EQ("index", mp->method->service()->name());

    mp = FindMethodPropertyByURI("//", &server, NULL);
    ASSERT_TRUE(mp);
    ASSERT_EQ("index", mp->method->service()->name());

    mp = FindMethodPropertyByURI("flags", &server, &unknown_method);
    ASSERT_TRUE(mp);
    ASSERT_EQ("flags", mp->method->service()->name());
    
    mp = FindMethodPropertyByURI("/flags/port", &server, &unknown_method);
    ASSERT_TRUE(mp);
    ASSERT_EQ("flags", mp->method->service()->name());
    ASSERT_EQ("port", unknown_method);
    
    mp = FindMethodPropertyByURI("/flags/foo/bar", &server, &unknown_method);
    ASSERT_TRUE(mp);
    ASSERT_EQ("flags", mp->method->service()->name());
    ASSERT_EQ("foo/bar", unknown_method);
    
    mp = FindMethodPropertyByURI("/brpc.flags/$*",
                                 &server, &unknown_method);
    ASSERT_TRUE(mp);
    ASSERT_EQ("flags", mp->method->service()->name());
    ASSERT_EQ("$*", unknown_method);

    mp = FindMethodPropertyByURI("EchoService/Echo", &server, &unknown_method);
    ASSERT_TRUE(mp);
    ASSERT_EQ("test.EchoService.Echo", mp->method->full_name());
    
    mp = FindMethodPropertyByURI("/EchoService/Echo",
                                 &server, &unknown_method);
    ASSERT_TRUE(mp);
    ASSERT_EQ("test.EchoService.Echo", mp->method->full_name());
    
    mp = FindMethodPropertyByURI("/test.EchoService/Echo",
                                 &server, &unknown_method);
    ASSERT_TRUE(mp);
    ASSERT_EQ("test.EchoService.Echo", mp->method->full_name());
    
    mp = FindMethodPropertyByURI("/test.EchoService/no_such_method",
                                 &server, &unknown_method);
    ASSERT_FALSE(mp);
}

TEST(HttpMessageTest, http_header) {
    brpc::HttpHeader header;
    
    header.set_version(10, 100);
    ASSERT_EQ(10, header.major_version());
    ASSERT_EQ(100, header.minor_version());

    ASSERT_TRUE(header.content_type().empty());
    header.set_content_type("text/plain");
    ASSERT_EQ("text/plain", header.content_type());
    ASSERT_FALSE(header.GetHeader("content-type"));
    header.set_content_type("application/json");
    ASSERT_EQ("application/json", header.content_type());
    ASSERT_FALSE(header.GetHeader("content-type"));
    
    ASSERT_FALSE(header.GetHeader("key1"));
    header.AppendHeader("key1", "value1");
    const std::string* value = header.GetHeader("key1");
    ASSERT_TRUE(value && *value == "value1");
    header.AppendHeader("key1", "value2");
    value = header.GetHeader("key1");
    ASSERT_TRUE(value && *value == "value1,value2");
    header.SetHeader("key1", "value3");
    value = header.GetHeader("key1");
    ASSERT_TRUE(value && *value == "value3");
    header.RemoveHeader("key1");
    ASSERT_FALSE(header.GetHeader("key1"));

    ASSERT_FALSE(header.GetHeader(brpc::HttpHeader::COOKIE));
    header.AppendHeader(brpc::HttpHeader::COOKIE, "value1=1");
    value = header.GetHeader(brpc::HttpHeader::COOKIE);
    ASSERT_TRUE(value && *value == "value1=1");
    header.AppendHeader(brpc::HttpHeader::COOKIE, "value2=2");
    value = header.GetHeader(brpc::HttpHeader::COOKIE);
    ASSERT_TRUE(value && *value == "value1=1; value2=2");
    header.SetHeader(brpc::HttpHeader::COOKIE, "value3");
    value = header.GetHeader(brpc::HttpHeader::COOKIE);
    ASSERT_TRUE(value && *value == "value3");
    header.RemoveHeader(brpc::HttpHeader::COOKIE);
    ASSERT_FALSE(header.GetHeader(brpc::HttpHeader::COOKIE));

    std::string set_cookie_value1 = "a=1";
    std::string set_cookie_value2 = "b=2";
    std::string set_cookie_value3 = "c=3";
    ASSERT_FALSE(header.GetHeader(brpc::HttpHeader::SET_COOKIE));
    header.SetHeader(brpc::HttpHeader::SET_COOKIE, set_cookie_value1);
    value = header.GetHeader(brpc::HttpHeader::SET_COOKIE);
    ASSERT_TRUE(value && *value == set_cookie_value1);
    header.AppendHeader(brpc::HttpHeader::SET_COOKIE, set_cookie_value2);
    value = header.GetHeader(brpc::HttpHeader::SET_COOKIE);
    ASSERT_TRUE(value && *value == set_cookie_value1);
    header.SetHeader(brpc::HttpHeader::SET_COOKIE, set_cookie_value3);
    value = header.GetHeader(brpc::HttpHeader::SET_COOKIE);
    ASSERT_TRUE(value && *value == set_cookie_value3);
    std::vector<const std::string*> all_set_cookie
        = header.GetAllSetCookieHeader();
    ASSERT_EQ(2u, all_set_cookie.size());
    for (const std::string* sc : all_set_cookie) {
        ASSERT_TRUE(sc);
        ASSERT_TRUE(*sc == set_cookie_value2 || *sc == set_cookie_value3);
    }
    int set_cookie_value2_count = 0;
    int set_cookie_value3_count = 0;
    for (auto iter = header.HeaderBegin(); iter != header.HeaderEnd(); ++iter) {
        if (!header.IsSetCookie(brpc::HttpHeader::SET_COOKIE)) {
            continue;
        }
        if (iter->second == set_cookie_value2) {
            ++set_cookie_value2_count;
        } else if (iter->second == set_cookie_value3) {
            ++set_cookie_value3_count;
        }
    }
    ASSERT_EQ(1, set_cookie_value2_count);
    ASSERT_EQ(1, set_cookie_value3_count);
    header.RemoveHeader(brpc::HttpHeader::SET_COOKIE);
    ASSERT_FALSE(header.GetHeader(brpc::HttpHeader::SET_COOKIE));
    ASSERT_EQ(header._first_set_cookie, nullptr);

    ASSERT_EQ(brpc::HTTP_METHOD_GET, header.method());
    header.set_method(brpc::HTTP_METHOD_POST);
    ASSERT_EQ(brpc::HTTP_METHOD_POST, header.method());

    ASSERT_EQ(brpc::HTTP_STATUS_OK, header.status_code());
    ASSERT_STREQ(brpc::HttpReasonPhrase(header.status_code()),
                 header.reason_phrase());
    header.set_status_code(brpc::HTTP_STATUS_CONTINUE);
    ASSERT_EQ(brpc::HTTP_STATUS_CONTINUE, header.status_code());
    ASSERT_STREQ(brpc::HttpReasonPhrase(header.status_code()),
                 header.reason_phrase());
    
    header.set_status_code(brpc::HTTP_STATUS_GONE);
    ASSERT_EQ(brpc::HTTP_STATUS_GONE, header.status_code());
    ASSERT_STREQ(brpc::HttpReasonPhrase(header.status_code()),
                 header.reason_phrase());
}

TEST(HttpMessageTest, empty_url) {
    butil::EndPoint host;
    ASSERT_FALSE(ParseHttpServerAddress(&host, ""));
}

TEST(HttpMessageTest, serialize_http_request) {
    brpc::HttpHeader header;
    ASSERT_EQ(0u, header.HeaderCount());
    header.SetHeader("Foo", "Bar");
    ASSERT_EQ(1u, header.HeaderCount());
    header.set_method(brpc::HTTP_METHOD_POST);
    butil::EndPoint ep;
    ASSERT_EQ(0, butil::str2endpoint("127.0.0.1:1234", &ep));
    butil::IOBuf request;
    butil::IOBuf content;
    content.append("data");
    MakeRawHttpRequest(&request, &header, ep, &content);
    ASSERT_EQ("POST / HTTP/1.1\r\nContent-Length: 4\r\nHost: 127.0.0.1:1234\r\nFoo: Bar\r\nAccept: */*\r\nUser-Agent: brpc/1.0 curl/7.0\r\n\r\ndata", request);

    // user-set content-length is ignored.
    header.SetHeader("Content-Length", "100");
    MakeRawHttpRequest(&request, &header, ep, &content);
    ASSERT_EQ("POST / HTTP/1.1\r\nContent-Length: 4\r\nHost: 127.0.0.1:1234\r\nFoo: Bar\r\nAccept: */*\r\nUser-Agent: brpc/1.0 curl/7.0\r\n\r\ndata", request);

    // user-host overwrites passed-in remote_side
    header.SetHeader("Host", "MyHost: 4321");
    MakeRawHttpRequest(&request, &header, ep, &content);
    ASSERT_EQ("POST / HTTP/1.1\r\nContent-Length: 4\r\nFoo: Bar\r\nHost: MyHost: 4321\r\nAccept: */*\r\nUser-Agent: brpc/1.0 curl/7.0\r\n\r\ndata", request);

    // user-set accept
    header.SetHeader("accePT"/*intended uppercase*/, "blahblah");
    MakeRawHttpRequest(&request, &header, ep, &content);
    ASSERT_EQ("POST / HTTP/1.1\r\nContent-Length: 4\r\nFoo: Bar\r\naccePT: blahblah\r\nHost: MyHost: 4321\r\nUser-Agent: brpc/1.0 curl/7.0\r\n\r\ndata", request);

    // user-set UA
    header.SetHeader("user-AGENT", "myUA");
    MakeRawHttpRequest(&request, &header, ep, &content);
    ASSERT_EQ("POST / HTTP/1.1\r\nContent-Length: 4\r\nFoo: Bar\r\naccePT: blahblah\r\nHost: MyHost: 4321\r\nuser-AGENT: myUA\r\n\r\ndata", request);

    // user-set Authorization
    header.SetHeader("authorization", "myAuthString");
    MakeRawHttpRequest(&request, &header, ep, &content);
    ASSERT_EQ("POST / HTTP/1.1\r\nContent-Length: 4\r\nFoo: Bar\r\naccePT: blahblah\r\nHost: MyHost: 4321\r\nuser-AGENT: myUA\r\nauthorization: myAuthString\r\n\r\ndata", request);

    header.SetHeader("Transfer-Encoding", "chunked");
    MakeRawHttpRequest(&request, &header, ep, &content);
    ASSERT_EQ("POST / HTTP/1.1\r\nFoo: Bar\r\naccePT: blahblah\r\nTransfer-Encoding: chunked\r\nHost: MyHost: 4321\r\nuser-AGENT: myUA\r\nauthorization: myAuthString\r\n\r\ndata", request);

    // GET does not serialize content and user-set content-length is ignored.
    header.set_method(brpc::HTTP_METHOD_GET);
    header.SetHeader("Content-Length", "100");
    MakeRawHttpRequest(&request, &header, ep, &content);
    ASSERT_EQ("GET / HTTP/1.1\r\nFoo: Bar\r\naccePT: blahblah\r\nHost: MyHost: 4321\r\nuser-AGENT: myUA\r\nauthorization: myAuthString\r\n\r\n", request);
}

TEST(HttpMessageTest, serialize_http_response) {
    brpc::HttpHeader header;
    header.SetHeader("Foo", "Bar");
    header.set_method(brpc::HTTP_METHOD_POST);
    butil::IOBuf response;
    butil::IOBuf content;
    content.append("data");
    MakeRawHttpResponse(&response, &header, &content);
    ASSERT_EQ("HTTP/1.1 200 OK\r\nContent-Length: 4\r\nFoo: Bar\r\n\r\ndata", response)
        << butil::ToPrintable(response);
    // Content is cleared.
    CHECK(content.empty());

    // NULL content
    header.SetHeader("Content-Length", "100");
    MakeRawHttpResponse(&response, &header, NULL);
    ASSERT_EQ("HTTP/1.1 200 OK\r\nFoo: Bar\r\nContent-Length: 100\r\n\r\n", response)
        << butil::ToPrintable(response);

    header.SetHeader("Transfer-Encoding", "chunked");
    MakeRawHttpResponse(&response, &header, NULL);
    ASSERT_EQ("HTTP/1.1 200 OK\r\nFoo: Bar\r\nTransfer-Encoding: chunked\r\n\r\n", response)
                    << butil::ToPrintable(response);
    header.RemoveHeader("Transfer-Encoding");

    // User-set content-length is ignored.
    content.append("data2");
    MakeRawHttpResponse(&response, &header, &content);
    ASSERT_EQ("HTTP/1.1 200 OK\r\nContent-Length: 5\r\nFoo: Bar\r\n\r\ndata2", response)
        << butil::ToPrintable(response);

    header.SetHeader("Content-Length", "100");
    header.SetHeader("Transfer-Encoding", "chunked");
    MakeRawHttpResponse(&response, &header, NULL);
    ASSERT_EQ("HTTP/1.1 200 OK\r\nFoo: Bar\r\nTransfer-Encoding: chunked\r\n\r\n", response)
                    << butil::ToPrintable(response);
    header.RemoveHeader("Transfer-Encoding");

    // User-set content-length and transfer-encoding is ignored when status code is 204 or 1xx.
    // 204 No Content.
    header.SetHeader("Content-Length", "100");
    header.SetHeader("Transfer-Encoding", "chunked");
    header.set_status_code(brpc::HTTP_STATUS_NO_CONTENT);
    MakeRawHttpResponse(&response, &header, &content);
    ASSERT_EQ("HTTP/1.1 204 No Content\r\nFoo: Bar\r\n\r\n", response);
    // 101 Continue
    header.SetHeader("Content-Length", "100");
    header.SetHeader("Transfer-Encoding", "chunked");
    header.set_status_code(brpc::HTTP_STATUS_CONTINUE);
    MakeRawHttpResponse(&response, &header, &content);
    ASSERT_EQ("HTTP/1.1 100 Continue\r\nFoo: Bar\r\n\r\n", response)
        << butil::ToPrintable(response);

    // when request method is HEAD:
    // 1. There isn't user-set content-length, length of content is used.
    header.set_method(brpc::HTTP_METHOD_HEAD);
    header.set_status_code(brpc::HTTP_STATUS_OK);content.append("data2");
    MakeRawHttpResponse(&response, &header, &content);
    ASSERT_EQ("HTTP/1.1 200 OK\r\nContent-Length: 5\r\nFoo: Bar\r\n\r\n", response)
        << butil::ToPrintable(response);
    // 2. User-set content-length is not ignored .
    header.SetHeader("Content-Length", "100");
    MakeRawHttpResponse(&response, &header, &content);
    ASSERT_EQ("HTTP/1.1 200 OK\r\nFoo: Bar\r\nContent-Length: 100\r\n\r\n", response)
        << butil::ToPrintable(response);
}

TEST(HttpMessageTest, http_1_1_request_without_host) {
    brpc::FLAGS_allow_http_1_1_request_without_host = false;
    {
        butil::IOBuf request;
        request.append("GET /service/method HTTP/1.1\r\n"
                       "Content-Type: text/plain\r\n\r\n");

        brpc::HttpMessage http_message;
        ASSERT_TRUE(http_message.ParseFromIOBuf(request) < 0);
    }
    {
        butil::IOBuf request;
        request.append("GET http://baidu.com/service/method HTTP/1.1\r\n"
                       "Content-Type: text/plain\r\n\r\n");

        brpc::HttpMessage http_message;
        ASSERT_TRUE(http_message.ParseFromIOBuf(request) >= 0);
        ASSERT_TRUE(http_message.Completed());
        ASSERT_EQ("text/plain", http_message.header().content_type());
    }
    {
        butil::IOBuf request;
        request.append("GET /service/method HTTP/1.1\r\n"
                       "Content-Type: text/plain\r\n"
                       "Host: baidu.com\r\n\r\n");

        brpc::HttpMessage http_message;
        ASSERT_GE(http_message.ParseFromIOBuf(request), 0);
        ASSERT_GE(http_message.ParseFromArray(NULL, 0), 0);
        ASSERT_TRUE(http_message.Completed());
        ASSERT_EQ("text/plain", http_message.header().content_type());
    }
    brpc::FLAGS_allow_http_1_1_request_without_host = true;
}

} //namespace