Clang format slam.

net/quic/quic_data_writer_test.cc

 // Copyright (c) 2012 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/quic_data_writer.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 33 matching lines @@
   EXPECT_EQ(11, kUFloat16MantissaBits);
   EXPECT_EQ(12, kUFloat16MantissaEffectiveBits);
   EXPECT_EQ(GG_UINT64_C(0x3FFC0000000), kUFloat16MaxValue);
 }
 
 TEST(QuicDataWriterTest, WriteUFloat16) {
   struct TestCase {
     uint64 decoded;
     uint16 encoded;
   };
-  TestCase test_cases[] = {
-    // Small numbers represent themselves.
-    { 0, 0 }, { 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 }, { 5, 5 }, { 6, 6 },
-    { 7, 7 }, { 15, 15 }, { 31, 31 }, { 42, 42 }, { 123, 123 }, { 1234, 1234 },
-    // Check transition through 2^11.
-    { 2046, 2046 }, { 2047, 2047 }, { 2048, 2048 }, { 2049, 2049 },
-    // Running out of mantissa at 2^12.
-    { 4094, 4094 }, { 4095, 4095 }, { 4096, 4096 }, { 4097, 4096 },
-    { 4098, 4097 }, { 4099, 4097 }, { 4100, 4098 }, { 4101, 4098 },
-    // Check transition through 2^13.
-    { 8190, 6143 }, { 8191, 6143 }, { 8192, 6144 }, { 8193, 6144 },
-    { 8194, 6144 }, { 8195, 6144 }, { 8196, 6145 }, { 8197, 6145 },
-    // Half-way through the exponents.
-    { 0x7FF8000, 0x87FF }, { 0x7FFFFFF, 0x87FF }, { 0x8000000, 0x8800 },
-    { 0xFFF0000, 0x8FFF }, { 0xFFFFFFF, 0x8FFF }, { 0x10000000, 0x9000 },
-    // Transition into the largest exponent.
-    { 0x1FFFFFFFFFE, 0xF7FF}, { 0x1FFFFFFFFFF, 0xF7FF},
-    { 0x20000000000, 0xF800}, { 0x20000000001, 0xF800},
-    { 0x2003FFFFFFE, 0xF800}, { 0x2003FFFFFFF, 0xF800},
-    { 0x20040000000, 0xF801}, { 0x20040000001, 0xF801},
-    // Transition into the max value and clamping.
-    { 0x3FF80000000, 0xFFFE}, { 0x3FFBFFFFFFF, 0xFFFE},
-    { 0x3FFC0000000, 0xFFFF}, { 0x3FFC0000001, 0xFFFF},
-    { 0x3FFFFFFFFFF, 0xFFFF}, { 0x40000000000, 0xFFFF},
-    { 0xFFFFFFFFFFFFFFFF, 0xFFFF},
+  TestCase test_cases[] = {// Small numbers represent themselves.
+                           {0, 0},
+                           {1, 1},
+                           {2, 2},
+                           {3, 3},
+                           {4, 4},
+                           {5, 5},
+                           {6, 6},
+                           {7, 7},
+                           {15, 15},
+                           {31, 31},
+                           {42, 42},
+                           {123, 123},
+                           {1234, 1234},
+                           // Check transition through 2^11.
+                           {2046, 2046},
+                           {2047, 2047},
+                           {2048, 2048},
+                           {2049, 2049},
+                           // Running out of mantissa at 2^12.
+                           {4094, 4094},
+                           {4095, 4095},
+                           {4096, 4096},
+                           {4097, 4096},
+                           {4098, 4097},
+                           {4099, 4097},
+                           {4100, 4098},
+                           {4101, 4098},
+                           // Check transition through 2^13.
+                           {8190, 6143},
+                           {8191, 6143},
+                           {8192, 6144},
+                           {8193, 6144},
+                           {8194, 6144},
+                           {8195, 6144},
+                           {8196, 6145},
+                           {8197, 6145},
+                           // Half-way through the exponents.
+                           {0x7FF8000, 0x87FF},
+                           {0x7FFFFFF, 0x87FF},
+                           {0x8000000, 0x8800},
+                           {0xFFF0000, 0x8FFF},
+                           {0xFFFFFFF, 0x8FFF},
+                           {0x10000000, 0x9000},
+                           // Transition into the largest exponent.
+                           {0x1FFFFFFFFFE, 0xF7FF},
+                           {0x1FFFFFFFFFF, 0xF7FF},
+                           {0x20000000000, 0xF800},
+                           {0x20000000001, 0xF800},
+                           {0x2003FFFFFFE, 0xF800},
+                           {0x2003FFFFFFF, 0xF800},
+                           {0x20040000000, 0xF801},
+                           {0x20040000001, 0xF801},
+                           // Transition into the max value and clamping.
+                           {0x3FF80000000, 0xFFFE},
+                           {0x3FFBFFFFFFF, 0xFFFE},
+                           {0x3FFC0000000, 0xFFFF},
+                           {0x3FFC0000001, 0xFFFF},
+                           {0x3FFFFFFFFFF, 0xFFFF},
+                           {0x40000000000, 0xFFFF},
+                           {0xFFFFFFFFFFFFFFFF, 0xFFFF},
   };
   int num_test_cases = sizeof(test_cases) / sizeof(test_cases[0]);
 
   for (int i = 0; i < num_test_cases; ++i) {
     QuicDataWriter writer(2);
     EXPECT_TRUE(writer.WriteUFloat16(test_cases[i].decoded));
     scoped_ptr<char[]> data(writer.take());
     EXPECT_EQ(test_cases[i].encoded, *reinterpret_cast<uint16*>(data.get()));
   }
 }
 
 TEST(QuicDataWriterTest, ReadUFloat16) {
   struct TestCase {
     uint64 decoded;
     uint16 encoded;
   };
   TestCase test_cases[] = {
-    // There are fewer decoding test cases because encoding truncates, and
-    // decoding returns the smallest expansion.
-    // Small numbers represent themselves.
-    { 0, 0 }, { 1, 1 }, { 2, 2 }, { 3, 3 }, { 4, 4 }, { 5, 5 }, { 6, 6 },
-    { 7, 7 }, { 15, 15 }, { 31, 31 }, { 42, 42 }, { 123, 123 }, { 1234, 1234 },
-    // Check transition through 2^11.
-    { 2046, 2046 }, { 2047, 2047 }, { 2048, 2048 }, { 2049, 2049 },
-    // Running out of mantissa at 2^12.
-    { 4094, 4094 }, { 4095, 4095 }, { 4096, 4096 },
-    { 4098, 4097 }, { 4100, 4098 },
-    // Check transition through 2^13.
-    { 8190, 6143 }, { 8192, 6144 }, { 8196, 6145 },
-    // Half-way through the exponents.
-    { 0x7FF8000, 0x87FF }, { 0x8000000, 0x8800 },
-    { 0xFFF0000, 0x8FFF }, { 0x10000000, 0x9000 },
-    // Transition into the largest exponent.
-    { 0x1FFE0000000, 0xF7FF}, { 0x20000000000, 0xF800},
-    { 0x20040000000, 0xF801},
-    // Transition into the max value.
-    { 0x3FF80000000, 0xFFFE}, { 0x3FFC0000000, 0xFFFF},
+      // There are fewer decoding test cases because encoding truncates, and
+      // decoding returns the smallest expansion.
+      // Small numbers represent themselves.
+      {0, 0},
+      {1, 1},
+      {2, 2},
+      {3, 3},
+      {4, 4},
+      {5, 5},
+      {6, 6},
+      {7, 7},
+      {15, 15},
+      {31, 31},
+      {42, 42},
+      {123, 123},
+      {1234, 1234},
+      // Check transition through 2^11.
+      {2046, 2046},
+      {2047, 2047},
+      {2048, 2048},
+      {2049, 2049},
+      // Running out of mantissa at 2^12.
+      {4094, 4094},
+      {4095, 4095},
+      {4096, 4096},
+      {4098, 4097},
+      {4100, 4098},
+      // Check transition through 2^13.
+      {8190, 6143},
+      {8192, 6144},
+      {8196, 6145},
+      // Half-way through the exponents.
+      {0x7FF8000, 0x87FF},
+      {0x8000000, 0x8800},
+      {0xFFF0000, 0x8FFF},
+      {0x10000000, 0x9000},
+      // Transition into the largest exponent.
+      {0x1FFE0000000, 0xF7FF},
+      {0x20000000000, 0xF800},
+      {0x20040000000, 0xF801},
+      // Transition into the max value.
+      {0x3FF80000000, 0xFFFE},
+      {0x3FFC0000000, 0xFFFF},
   };
   int num_test_cases = sizeof(test_cases) / sizeof(test_cases[0]);
 
   for (int i = 0; i < num_test_cases; ++i) {
     QuicDataReader reader(reinterpret_cast<char*>(&test_cases[i].encoded), 2);
     uint64 value;
     EXPECT_TRUE(reader.ReadUFloat16(&value));
     EXPECT_EQ(test_cases[i].decoded, value);
   }
 }
@@ skipping 17 matching lines @@
       EXPECT_GT(previous_value * 1005, value * 1000);
     // Check we're always within the promised range.
     EXPECT_LT(value, GG_UINT64_C(0x3FFC0000000));
     previous_value = value;
     QuicDataWriter writer(6);
     EXPECT_TRUE(writer.WriteUFloat16(value - 1));
     EXPECT_TRUE(writer.WriteUFloat16(value));
     EXPECT_TRUE(writer.WriteUFloat16(value + 1));
     scoped_ptr<char[]> data(writer.take());
     // Check minimal decoding (previous decoding has previous encoding).
-    EXPECT_EQ(i-1, *reinterpret_cast<uint16*>(data.get()));
+    EXPECT_EQ(i - 1, *reinterpret_cast<uint16*>(data.get()));
     // Check roundtrip.
     EXPECT_EQ(i, *reinterpret_cast<uint16*>(data.get() + 2));
     // Check next decoding.
-    EXPECT_EQ(i < 4096? i+1 : i, *reinterpret_cast<uint16*>(data.get() + 4));
+    EXPECT_EQ(i < 4096 ? i + 1 : i, *reinterpret_cast<uint16*>(data.get() + 4));
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net