Case insensitive header cleanup. Also cleanup and additions to parse_test

client_http.hpp

@@ -12,6 +12,26 @@
 #include <mutex>
 #include <type_traits>
 
+#ifndef CASE_INSENSITIVE_EQUALS_AND_HASH
+#define CASE_INSENSITIVE_EQUALS_AND_HASH
+//Based on http://www.boost.org/doc/libs/1_60_0/doc/html/unordered/hash_equality.html
+class case_insensitive_equals {
+public:
+  bool operator()(const std::string &key1, const std::string &key2) const {
+    return boost::algorithm::iequals(key1, key2);
+  }
+};
+class case_insensitive_hash {
+public:
+  size_t operator()(const std::string &key) const {
+    std::size_t seed=0;
+    for(auto &c: key)
+      boost::hash_combine(seed, std::tolower(c));
+    return seed;
+  }
+};
+#endif
+
 namespace SimpleWeb {
     template <class socket_type>
     class Client;
@@ -24,29 +44,12 @@ namespace SimpleWeb {
         class Response {
             friend class ClientBase<socket_type>;
             friend class Client<socket_type>;
-            
-            //Based on http://www.boost.org/doc/libs/1_60_0/doc/html/unordered/hash_equality.html
-            class iequal_to {
-            public:
-              bool operator()(const std::string &key1, const std::string &key2) const {
-                return boost::algorithm::iequals(key1, key2);
-              }
-            };
-            class ihash {
-            public:
-              size_t operator()(const std::string &key) const {
-                std::size_t seed=0;
-                for(auto &c: key)
-                  boost::hash_combine(seed, std::tolower(c));
-                return seed;
-              }
-            };
         public:
             std::string http_version, status_code;
 
             std::istream content;
 
-            std::unordered_multimap<std::string, std::string, ihash, iequal_to> header;
+            std::unordered_multimap<std::string, std::string, case_insensitive_hash, case_insensitive_equals> header;
             
         private:
             boost::asio::streambuf content_buffer;

server_http.hpp

@@ -11,6 +11,26 @@
 #include <iostream>
 #include <sstream>
 
+#ifndef CASE_INSENSITIVE_EQUALS_AND_HASH
+#define CASE_INSENSITIVE_EQUALS_AND_HASH
+//Based on http://www.boost.org/doc/libs/1_60_0/doc/html/unordered/hash_equality.html
+class case_insensitive_equals {
+public:
+  bool operator()(const std::string &key1, const std::string &key2) const {
+    return boost::algorithm::iequals(key1, key2);
+  }
+};
+class case_insensitive_hash {
+public:
+  size_t operator()(const std::string &key) const {
+    std::size_t seed=0;
+    for(auto &c: key)
+      boost::hash_combine(seed, std::tolower(c));
+    return seed;
+  }
+};
+#endif
+
 // Late 2017 TODO: remove the following checks and always use std::regex
 #ifdef USE_BOOST_REGEX
 #include <boost/regex.hpp>
@@ -74,29 +94,12 @@ namespace SimpleWeb {
         class Request {
             friend class ServerBase<socket_type>;
             friend class Server<socket_type>;
-            
-            //Based on http://www.boost.org/doc/libs/1_60_0/doc/html/unordered/hash_equality.html
-            class iequal_to {
-            public:
-              bool operator()(const std::string &key1, const std::string &key2) const {
-                return boost::algorithm::iequals(key1, key2);
-              }
-            };
-            class ihash {
-            public:
-              size_t operator()(const std::string &key) const {
-                std::size_t seed=0;
-                for(auto &c: key)
-                  boost::hash_combine(seed, std::tolower(c));
-                return seed;
-              }
-            };
         public:
             std::string method, path, http_version;
 
             Content content;
 
-            std::unordered_multimap<std::string, std::string, ihash, iequal_to> header;
+            std::unordered_multimap<std::string, std::string, case_insensitive_hash, case_insensitive_equals> header;
 
             REGEX_NS::smatch path_match;
             
@@ -338,7 +341,7 @@ namespace SimpleWeb {
                             if(line[value_start]==' ')
                                 value_start++;
                             if(value_start<line.size())
-                                request->header.insert(std::make_pair(line.substr(0, param_end), line.substr(value_start, line.size()-value_start-1)));
+                                request->header.emplace(line.substr(0, param_end), line.substr(value_start, line.size()-value_start-1));
                         }
     
                         getline(request->content, line);

tests/parse_test.cpp

@@ -1,18 +1,18 @@
 #include "server_http.hpp"
 #include "client_http.hpp"
 #include <iostream>
+#include <cassert>
 
 using namespace std;
 using namespace SimpleWeb;
 
 class ServerTest : public ServerBase<HTTP> {
 public:
-    ServerTest() : 
+    ServerTest() : ServerBase<HTTP>::ServerBase(8080) {}
-            ServerBase<HTTP>::ServerBase(8080) {}
             
     void accept() {}
     
-    bool parse_request_test() {
+    void parse_request_test() {
         HTTP socket(*io_service);
         std::shared_ptr<Request> request(new Request(socket));
         
@@ -20,28 +20,34 @@ public:
         stream << "GET /test/ HTTP/1.1\r\n";
         stream << "TestHeader: test\r\n";
         stream << "TestHeader2:test2\r\n";
+        stream << "TestHeader3:test3a\r\n";
+        stream << "TestHeader3:test3b\r\n";
         stream << "\r\n";
         
-        if(!parse_request(request))
+        assert(parse_request(request));
-            return 0;
         
-        if(request->method!="GET")
+        assert(request->method=="GET");
-            return 0;
+        assert(request->path=="/test/");
-        if(request->path!="/test/")
+        assert(request->http_version=="1.1");
-            return 0;
-        if(request->http_version!="1.1")
-            return 0;
         
-        if(request->header.size()!=2)
+        assert(request->header.size()==4);
-            return 0;
         auto header_it=request->header.find("TestHeader");
-        if(header_it==request->header.end() || header_it->second!="test")
+        assert(header_it!=request->header.end() && header_it->second=="test");
-            return 0;
         header_it=request->header.find("TestHeader2");
-        if(header_it==request->header.end() || header_it->second!="test2")
+        assert(header_it!=request->header.end() && header_it->second=="test2");
-            return 0;
         
-        return 1;
+        header_it=request->header.find("testheader");
+        assert(header_it!=request->header.end() && header_it->second=="test");
+        header_it=request->header.find("testheader2");
+        assert(header_it!=request->header.end() && header_it->second=="test2");
+        
+        auto range=request->header.equal_range("testheader3");
+        auto first=range.first;
+        auto second=first;
+        ++second;
+        assert(range.first!=request->header.end() && range.second!=request->header.end() &&
+               ((first->second=="test3a" && second->second=="test3b") ||
+                (first->second=="test3b" && second->second=="test3a")));
     }
 };
 
@@ -51,51 +57,50 @@ public:
     
     void connect() {}
     
-    bool constructor_parse_test1() {
+    void constructor_parse_test1() {
-        if(host!="test.org")
+        assert(host=="test.org");
-            return 0;
+        assert(port==8080);
-        if(port!=8080)
-            return 0;
-        
-        return 1;
     }
     
-    bool constructor_parse_test2() {
+    void constructor_parse_test2() {
-        if(host!="test.org")
+        assert(host=="test.org");
-            return 0;
+        assert(port==80);
-        if(port!=80)
-            return 0;
-        
-        return 1;
     }
     
-    bool parse_response_header_test() {
+    void parse_response_header_test() {
         std::shared_ptr<Response> response(new Response());
         
         ostream stream(&response->content_buffer);
         stream << "HTTP/1.1 200 OK\r\n";
         stream << "TestHeader: test\r\n";
         stream << "TestHeader2:test2\r\n";
+        stream << "TestHeader3:test3a\r\n";
+        stream << "TestHeader3:test3b\r\n";
         stream << "\r\n";
         
         parse_response_header(response);
         
-        if(response->http_version!="1.1")
+        assert(response->http_version=="1.1");
-            return 0;
+        assert(response->status_code=="200 OK");
-        if(response->status_code!="200 OK")
-            return 0;
-        
-        if(response->header.size()!=2)
-            return 0;
         
+        assert(response->header.size()==4);
         auto header_it=response->header.find("TestHeader");
-        if(header_it==response->header.end() || header_it->second!="test")
+        assert(header_it!=response->header.end() && header_it->second=="test");
-          return 0;
         header_it=response->header.find("TestHeader2");
-        if(header_it==response->header.end() || header_it->second!="test2")
+        assert(header_it!=response->header.end() && header_it->second=="test2");
-          return 0;
         
-        return 1;
+        header_it=response->header.find("testheader");
+        assert(header_it!=response->header.end() && header_it->second=="test");
+        header_it=response->header.find("testheader2");
+        assert(header_it!=response->header.end() && header_it->second=="test2");
+        
+        auto range=response->header.equal_range("testheader3");
+        auto first=range.first;
+        auto second=first;
+        ++second;
+        assert(range.first!=response->header.end() && range.second!=response->header.end() &&
+               ((first->second=="test3a" && second->second=="test3b") ||
+                (first->second=="test3b" && second->second=="test3a")));
     }
 };
 
@@ -103,27 +108,13 @@ int main() {
     ServerTest serverTest;
     serverTest.io_service=std::make_shared<boost::asio::io_service>();
     
-    if(!serverTest.parse_request_test()) {
+    serverTest.parse_request_test();
-        cerr << "FAIL Server::parse_request" << endl;
-        return 1;
-    }
     
     ClientTest clientTest("test.org:8080");
-    if(!clientTest.constructor_parse_test1()) {
+    clientTest.constructor_parse_test1();
-        cerr << "FAIL Client::Client" << endl;
-        return 1;
-    }
     
     ClientTest clientTest2("test.org");
-    if(!clientTest2.constructor_parse_test2()) {
+    clientTest2.constructor_parse_test2();
-        cerr << "FAIL Client::Client" << endl;
-        return 1;
-    }
     
-    if(!clientTest2.parse_response_header_test()) {
+    clientTest2.parse_response_header_test();
-        cerr << "FAIL Client::parse_response_header" << endl;
-        return 1;
-    }
-    
-    return 0;
 }