Clang format slam.

net/quic/iovector_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/quic/iovector.h"
 
 #include <string.h>
 
 #include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::string;
 
 namespace net {
 namespace test {
 namespace {
 
 const char* const test_data[] = {
-  "test string 1, a medium size one.",
-  "test string2",
-  "test string      3, a looooooooooooong loooooooooooooooong string"
-};
+    "test string 1, a medium size one.", "test string2",
+    "test string      3, a looooooooooooong loooooooooooooooong string"};
 
 TEST(IOVectorTest, CopyConstructor) {
   IOVector iov1;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
     iov1.Append(const_cast<char*>(test_data[i]), strlen(test_data[i]));
   }
   IOVector iov2 = iov1;
   EXPECT_EQ(iov2.Size(), iov1.Size());
   for (size_t i = 0; i < iov2.Size(); ++i) {
     EXPECT_TRUE(iov2.iovec()[i].iov_base == iov1.iovec()[i].iov_base);
@@ skipping 46 matching lines @@
   iov2 = iov.iovec();
   ASSERT_TRUE(iov2 != NULL);
   for (size_t i = 0; i < iov.Size(); ++i) {
     ASSERT_TRUE(test_data[i] == iov2[i].iov_base);
     ASSERT_EQ(strlen(test_data[i]), iov2[i].iov_len);
   }
 }
 
 TEST(IOVectorTest, AppendIovec) {
   IOVector iov;
-  const struct iovec test_iov[] = {
-    {const_cast<char*>("foo"), 3},
-    {const_cast<char*>("bar"), 3},
-    {const_cast<char*>("buzzzz"), 6}
-  };
+  const struct iovec test_iov[] = {{const_cast<char*>("foo"), 3},
+                                   {const_cast<char*>("bar"), 3},
+                                   {const_cast<char*>("buzzzz"), 6}};
   iov.AppendIovec(test_iov, ARRAYSIZE_UNSAFE(test_iov));
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_iov); ++i) {
     EXPECT_EQ(test_iov[i].iov_base, iov.iovec()[i].iov_base);
     EXPECT_EQ(test_iov[i].iov_len, iov.iovec()[i].iov_len);
   }
 
   // Test AppendIovecAtMostBytes.
   iov.Clear();
   // Stop in the middle of a block.
-  EXPECT_EQ(5u, iov.AppendIovecAtMostBytes(test_iov, ARRAYSIZE_UNSAFE(test_iov),
-                                           5));
+  EXPECT_EQ(
+      5u, iov.AppendIovecAtMostBytes(test_iov, ARRAYSIZE_UNSAFE(test_iov), 5));
   EXPECT_EQ(5u, iov.TotalBufferSize());
   iov.Append(static_cast<char*>(test_iov[1].iov_base) + 2, 1);
   // Make sure the boundary case, where max_bytes == size of block also works.
   EXPECT_EQ(6u, iov.AppendIovecAtMostBytes(&test_iov[2], 1, 6));
   ASSERT_LE(ARRAYSIZE_UNSAFE(test_iov), static_cast<size_t>(iov.Size()));
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_iov); ++i) {
     EXPECT_EQ(test_iov[i].iov_base, iov.iovec()[i].iov_base);
     EXPECT_EQ(test_iov[i].iov_len, iov.iovec()[i].iov_len);
   }
 }
@@ skipping 159 matching lines @@
   ASSERT_EQ(2u, iov2.Size());
   EXPECT_EQ(&a[0], iov2.iovec()[0].iov_base);
   EXPECT_EQ(1u, iov2.iovec()[0].iov_len);
   EXPECT_EQ(&b[0], iov2.iovec()[1].iov_base);
   EXPECT_EQ(1u, iov2.iovec()[1].iov_len);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net