New new versions of Starts/EndsWith and SplitString in net

net/server/http_server_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 252 matching lines @@
 
 TEST_F(HttpServerTest, Request) {
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   client.Send("GET /test HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   ASSERT_EQ("GET", GetRequest(0).method);
   ASSERT_EQ("/test", GetRequest(0).path);
   ASSERT_EQ("", GetRequest(0).data);
   ASSERT_EQ(0u, GetRequest(0).headers.size());
-  ASSERT_TRUE(
-      base::StartsWithASCII(GetRequest(0).peer.ToString(), "127.0.0.1", true));
+  ASSERT_TRUE(base::StartsWith(GetRequest(0).peer.ToString(), "127.0.0.1",
+                               base::CompareCase::SENSITIVE));
 }
 
 TEST_F(HttpServerTest, RequestWithHeaders) {
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   const char* const kHeaders[][3] = {
       {"Header", ": ", "1"},
       {"HeaderWithNoWhitespace", ":", "1"},
       {"HeaderWithWhitespace", "   :  \t   ", "1 1 1 \t  "},
       {"HeaderWithColon", ": ", "1:1"},
@@ skipping 150 matching lines @@
 
 TEST_F(HttpServerTest, Send200) {
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   client.Send("GET /test HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   server_->Send200(GetConnectionId(0), "Response!", "text/plain");
 
   std::string response;
   ASSERT_TRUE(client.ReadResponse(&response));
-  ASSERT_TRUE(base::StartsWithASCII(response, "HTTP/1.1 200 OK", true));
-  ASSERT_TRUE(base::EndsWith(response, "Response!", true));
+  ASSERT_TRUE(base::StartsWith(response, "HTTP/1.1 200 OK",
+                               base::CompareCase::SENSITIVE));
+  ASSERT_TRUE(
+      base::EndsWith(response, "Response!", base::CompareCase::SENSITIVE));
 }
 
 TEST_F(HttpServerTest, SendRaw) {
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   client.Send("GET /test HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   server_->SendRaw(GetConnectionId(0), "Raw Data ");
   server_->SendRaw(GetConnectionId(0), "More Data");
   server_->SendRaw(GetConnectionId(0), "Third Piece of Data");
@@ skipping 127 matching lines @@
       "Content-Length: %" PRIuS "\r\n\r\n%s",
       body.length(),
       body.c_str()));
   ASSERT_TRUE(RunUntilRequestsReceived(1));
   ASSERT_EQ(body, GetRequest(0).data);
 
   int client_connection_id = GetConnectionId(0);
   server_->Send200(client_connection_id, "Content for /test", "text/plain");
   std::string response1;
   ASSERT_TRUE(client.ReadResponse(&response1));
-  ASSERT_TRUE(base::StartsWithASCII(response1, "HTTP/1.1 200 OK", true));
-  ASSERT_TRUE(base::EndsWith(response1, "Content for /test", true));
+  ASSERT_TRUE(base::StartsWith(response1, "HTTP/1.1 200 OK",
+                               base::CompareCase::SENSITIVE));
+  ASSERT_TRUE(base::EndsWith(response1, "Content for /test",
+                             base::CompareCase::SENSITIVE));
 
   client.Send("GET /test2 HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(2));
   ASSERT_EQ("/test2", GetRequest(1).path);
 
   ASSERT_EQ(client_connection_id, GetConnectionId(1));
   server_->Send404(client_connection_id);
   std::string response2;
   ASSERT_TRUE(client.ReadResponse(&response2));
-  ASSERT_TRUE(base::StartsWithASCII(response2, "HTTP/1.1 404 Not Found", true));
+  ASSERT_TRUE(base::StartsWith(response2, "HTTP/1.1 404 Not Found",
+                               base::CompareCase::SENSITIVE));
 
   client.Send("GET /test3 HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(3));
   ASSERT_EQ("/test3", GetRequest(2).path);
 
   ASSERT_EQ(client_connection_id, GetConnectionId(2));
   server_->Send200(client_connection_id, "Content for /test3", "text/plain");
   std::string response3;
   ASSERT_TRUE(client.ReadResponse(&response3));
-  ASSERT_TRUE(base::StartsWithASCII(response3, "HTTP/1.1 200 OK", true));
-  ASSERT_TRUE(base::EndsWith(response3, "Content for /test3", true));
+  ASSERT_TRUE(base::StartsWith(response3, "HTTP/1.1 200 OK",
+                               base::CompareCase::SENSITIVE));
+  ASSERT_TRUE(base::EndsWith(response3, "Content for /test3",
+                             base::CompareCase::SENSITIVE));
 }
 
 class CloseOnConnectHttpServerTest : public HttpServerTest {
  public:
   void OnConnect(int connection_id) override {
     connection_ids_.push_back(connection_id);
     server_->Close(connection_id);
   }
 
  protected:
   std::vector<int> connection_ids_;
 };
 
 TEST_F(CloseOnConnectHttpServerTest, ServerImmediatelyClosesConnection) {
   TestHttpClient client;
   ASSERT_EQ(OK, client.ConnectAndWait(server_address_));
   client.Send("GET / HTTP/1.1\r\n\r\n");
   ASSERT_FALSE(RunUntilRequestsReceived(1));
   ASSERT_EQ(1ul, connection_ids_.size());
   ASSERT_EQ(0ul, requests_.size());
 }
 
 }  // namespace
 
 }  // namespace net