Clang format slam.

net/tools/balsa/balsa_headers_test.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 "net/tools/balsa/balsa_headers.h"
 
 #include <iterator>
 #include <string>
 #include <vector>
 
@@ skipping 13 matching lines @@
     anotherBuffer_.reset(new BalsaBuffer);
   }
 
  protected:
   scoped_ptr<BalsaBuffer> buffer_;
   scoped_ptr<BalsaBuffer> anotherBuffer_;
 };
 
 namespace {
 
-class BalsaHeadersTest: public ::testing::Test {
+class BalsaHeadersTest : public ::testing::Test {
  public:
-  virtual void SetUp() OVERRIDE {
-    headers_.reset(new BalsaHeaders);
-  }
+  virtual void SetUp() OVERRIDE { headers_.reset(new BalsaHeaders); }
 
  protected:
   scoped_ptr<BalsaHeaders> headers_;
 };
 
 class StringBuffer {
  public:
-  void Write(const char* p, size_t size) {
-    string_ += std::string(p, size);
-  }
-  const std::string& string() {return string_;}
+  void Write(const char* p, size_t size) { string_ += std::string(p, size); }
+  const std::string& string() { return string_; }
 
  private:
   std::string string_;
 };
 
 TEST_F(BalsaBufferTest, EmptyBuffer) {
   ASSERT_EQ(1u, buffer_->num_blocks());
 }
 
 TEST_F(BalsaBufferTest, Write) {
@@ skipping 70 matching lines @@
 TEST_F(BalsaBufferTest, Swap) {
   buffer_->Write("hello", NULL);
 
   ASSERT_EQ(2u, buffer_->num_blocks());
   ASSERT_EQ(1u, anotherBuffer_->num_blocks());
 
   buffer_->Swap(anotherBuffer_.get());
 
   ASSERT_EQ(1u, buffer_->num_blocks());
   ASSERT_EQ(2u, anotherBuffer_->num_blocks());
-  ASSERT_EQ("hello",
-            StringPiece(anotherBuffer_->GetPtr(1),
-                        anotherBuffer_->bytes_used(1)));
+  ASSERT_EQ(
+      "hello",
+      StringPiece(anotherBuffer_->GetPtr(1), anotherBuffer_->bytes_used(1)));
 }
 
 TEST_F(BalsaBufferTest, CopyFrom) {
   buffer_->Write("hello", NULL);
 
   ASSERT_EQ(2u, buffer_->num_blocks());
   ASSERT_EQ(1u, anotherBuffer_->num_blocks());
 
   anotherBuffer_->CopyFrom(*buffer_);
 
   ASSERT_EQ(2u, buffer_->num_blocks());
   ASSERT_EQ(2u, anotherBuffer_->num_blocks());
   ASSERT_EQ("hello", StringPiece(buffer_->GetPtr(1), buffer_->bytes_used(1)));
-  ASSERT_EQ("hello",
-            StringPiece(anotherBuffer_->GetPtr(1),
-                        anotherBuffer_->bytes_used(1)));
+  ASSERT_EQ(
+      "hello",
+      StringPiece(anotherBuffer_->GetPtr(1), anotherBuffer_->bytes_used(1)));
 }
 
 TEST_F(BalsaHeadersTest, AppendHeader) {
   headers_->AppendHeader("key1", "value1");
   headers_->AppendHeader("key2", "value2");
   headers_->AppendHeader("key3", "value3");
   headers_->AppendHeader("key3", "value3.1");
   headers_->AppendHeader("key3", "value3.2");
 
-  ASSERT_EQ(5, std::distance(headers_->header_lines_begin(),
-                             headers_->header_lines_end()));
+  ASSERT_EQ(5,
+            std::distance(headers_->header_lines_begin(),
+                          headers_->header_lines_end()));
   ASSERT_EQ("value1", headers_->GetHeader("key1"));
   ASSERT_EQ("value2", headers_->GetHeader("key2"));
   ASSERT_EQ("value3", headers_->GetHeader("key3"));
 
   std::vector<base::StringPiece> v1, v2, v3;
   std::string s1, s2, s3;
   headers_->GetAllOfHeader("key1", &v1);
   headers_->GetAllOfHeader("key2", &v2);
   headers_->GetAllOfHeader("key3", &v3);
   headers_->GetAllOfHeaderAsString("key1", &s1);
@@ skipping 10 matching lines @@
   ASSERT_EQ("value3.2", v3[2]);
   ASSERT_EQ("value1", s1);
   ASSERT_EQ("value2", s2);
   ASSERT_EQ("value3,value3.1,value3.2", s3);
 }
 
 TEST_F(BalsaHeadersTest, ReplaceOrAppendHeader) {
   headers_->ReplaceOrAppendHeader("key1", "value1");
   headers_->ReplaceOrAppendHeader("key1", "value2");
 
-  ASSERT_EQ(1, std::distance(headers_->header_lines_begin(),
-                             headers_->header_lines_end()));
+  ASSERT_EQ(1,
+            std::distance(headers_->header_lines_begin(),
+                          headers_->header_lines_end()));
   ASSERT_EQ("value2", headers_->GetHeader("key1"));
 
   std::vector<base::StringPiece> v;
   headers_->GetAllOfHeader("key1", &v);
 
   ASSERT_EQ(1u, v.size());
   ASSERT_EQ("value2", v[0]);
 }
 
 TEST_F(BalsaHeadersTest, AppendToHeader) {
   headers_->AppendToHeader("key1", "value1");
   headers_->AppendToHeader("keY1", "value2");
 
-  ASSERT_EQ(1, std::distance(headers_->header_lines_begin(),
-                             headers_->header_lines_end()));
+  ASSERT_EQ(1,
+            std::distance(headers_->header_lines_begin(),
+                          headers_->header_lines_end()));
   ASSERT_EQ("value1,value2", headers_->GetHeader("key1"));
 
   std::vector<base::StringPiece> v;
   std::string s;
   headers_->GetAllOfHeader("key1", &v);
   headers_->GetAllOfHeaderAsString("keY1", &s);
 
   ASSERT_EQ(1u, v.size());
   ASSERT_EQ("value1,value2", v[0]);
   ASSERT_EQ("value1,value2", s);
 }
 
 TEST_F(BalsaHeadersTest, PrepentToHeader) {
   headers_->PrependToHeader("key1", "value1");
   headers_->PrependToHeader("key1", "value2");
 
-  ASSERT_EQ(1, std::distance(headers_->header_lines_begin(),
-                             headers_->header_lines_end()));
+  ASSERT_EQ(1,
+            std::distance(headers_->header_lines_begin(),
+                          headers_->header_lines_end()));
   ASSERT_EQ("value2,value1", headers_->GetHeader("key1"));
 
   std::vector<base::StringPiece> v;
   std::string s;
   headers_->GetAllOfHeader("key1", &v);
   headers_->GetAllOfHeaderAsString("key1", &s);
 
   ASSERT_EQ(1u, v.size());
   ASSERT_EQ("value2,value1", v[0]);
   ASSERT_EQ("value2,value1", s);
@@ skipping 64 matching lines @@
 }
 
 TEST_F(BalsaHeadersTest, RemoveAllOfHeader) {
   headers_->AppendHeader("key1", "value1");
   headers_->AppendHeader("key2", "value2");
   headers_->AppendHeader("key1", "value1.1");
   headers_->AppendHeader("key3", "value3");
   headers_->AppendHeader("key1", "value1.2");
   headers_->AppendHeader("kEY1", "value1.3");
 
-  ASSERT_EQ(6, std::distance(headers_->header_lines_begin(),
-                             headers_->header_lines_end()));
+  ASSERT_EQ(6,
+            std::distance(headers_->header_lines_begin(),
+                          headers_->header_lines_end()));
   headers_->RemoveAllOfHeader("key1");
-  ASSERT_EQ(2, std::distance(headers_->header_lines_begin(),
-                             headers_->header_lines_end()));
+  ASSERT_EQ(2,
+            std::distance(headers_->header_lines_begin(),
+                          headers_->header_lines_end()));
 }
 
 TEST_F(BalsaHeadersTest, RemoveAllHeadersWithPrefix) {
   headers_->AppendHeader("1key", "value1");
   headers_->AppendHeader("2key", "value2");
   headers_->AppendHeader("1kEz", "value1.1");
   headers_->AppendHeader("key3", "value3");
   headers_->AppendHeader("1KEEjkladf", "value1.2");
 
-  ASSERT_EQ(5, std::distance(headers_->header_lines_begin(),
-                             headers_->header_lines_end()));
+  ASSERT_EQ(5,
+            std::distance(headers_->header_lines_begin(),
+                          headers_->header_lines_end()));
   headers_->RemoveAllHeadersWithPrefix("1ke");
-  ASSERT_EQ(2, std::distance(headers_->header_lines_begin(),
-                             headers_->header_lines_end()));
+  ASSERT_EQ(2,
+            std::distance(headers_->header_lines_begin(),
+                          headers_->header_lines_end()));
 }
 
 TEST_F(BalsaHeadersTest, WriteRequestHeaderAndEndingToBuffer) {
   headers_->AppendHeader("key1", "value1");
   headers_->AppendHeader("key2", "value2");
   headers_->AppendHeader("key1", "value1.1");
 
   headers_->SetRequestFirstlineFromStringPieces("GET", "/", "HTTP/1.0");
 
-  std::string expected = "GET / HTTP/1.0\r\n"
+  std::string expected =
+      "GET / HTTP/1.0\r\n"
       "key1: value1\r\n"
       "key2: value2\r\n"
       "key1: value1.1\r\n\r\n";
   StringBuffer buffer;
   headers_->WriteHeaderAndEndingToBuffer(&buffer);
   ASSERT_EQ(expected, buffer.string());
 }
 
 TEST_F(BalsaHeadersTest, WriteResponseHeaderAndEndingToBuffer) {
   headers_->AppendHeader("key1", "value1");
   headers_->AppendHeader("key2", "value2");
   headers_->AppendHeader("key1", "value1.1");
 
   headers_->SetResponseFirstlineFromStringPieces("HTTP/1.0", "200", "OK");
 
-  std::string expected = "HTTP/1.0 200 OK\r\n"
+  std::string expected =
+      "HTTP/1.0 200 OK\r\n"
       "key1: value1\r\n"
       "key2: value2\r\n"
       "key1: value1.1\r\n\r\n";
   StringBuffer buffer;
   headers_->WriteHeaderAndEndingToBuffer(&buffer);
   ASSERT_EQ(expected, buffer.string());
 }
 
 TEST_F(BalsaHeadersTest, RequestFirstLine) {
   headers_->SetRequestFirstlineFromStringPieces("HEAD", "/path", "HTTP/1.1");
 
   ASSERT_EQ("HEAD /path HTTP/1.1", headers_->first_line());
   ASSERT_EQ("HEAD", headers_->request_method());
   ASSERT_EQ("/path", headers_->request_uri());
   ASSERT_EQ("HTTP/1.1", headers_->request_version());
 }
 
 TEST_F(BalsaHeadersTest, ResponseFirstLine) {
   headers_->SetRequestFirstlineFromStringPieces("HTTP/1.0", "403", "FORBIDDEN");
 
   ASSERT_EQ("HTTP/1.0 403 FORBIDDEN", headers_->first_line());
   ASSERT_EQ("HTTP/1.0", headers_->response_version());
   ASSERT_EQ("403", headers_->response_code());
   ASSERT_EQ("FORBIDDEN", headers_->response_reason_phrase());
 }
 
 }  // namespace
 
 }  // namespace net