Clang format slam.

net/filter/gzip_filter_unittest.cc

 // Copyright 2014 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 <fstream>
 #include <ostream>
 
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
@@ skipping 15 matching lines @@
 //   +---+---+---+---+---+---+---+---+---+---+
 //     ID1     \037
 //     ID2     \213
 //     CM      \010 (compression method == DEFLATE)
 //     FLG     \000 (special flags that we do not support)
 //     MTIME   Unix format modification time (0 means not available)
 //     XFL     2-4? DEFLATE flags
 //     OS      ???? Operating system indicator (255 means unknown)
 //
 // Header value we generate:
-const char kGZipHeader[] = { '\037', '\213', '\010', '\000', '\000',
-                             '\000', '\000', '\000', '\002', '\377' };
+const char kGZipHeader[] = {'\037', '\213', '\010', '\000', '\000',
+                            '\000', '\000', '\000', '\002', '\377'};
 
 enum EncodeMode {
-  ENCODE_GZIP,      // Wrap the deflate with a GZip header.
-  ENCODE_DEFLATE    // Raw deflate.
+  ENCODE_GZIP,    // Wrap the deflate with a GZip header.
+  ENCODE_DEFLATE  // Raw deflate.
 };
 
 }  // namespace
 
 namespace net {
 
 // These tests use the path service, which uses autoreleased objects on the
 // Mac, so this needs to be a PlatformTest.
 class GZipUnitTest : public PlatformTest {
  protected:
@@ skipping 12 matching lines @@
     file_path = file_path.AppendASCII("google.txt");
 
     // Read data from the file into buffer.
     ASSERT_TRUE(base::ReadFileToString(file_path, &source_buffer_));
 
     // Encode the data with deflate
     deflate_encode_buffer_ = new char[kDefaultBufferSize];
     ASSERT_TRUE(deflate_encode_buffer_ != NULL);
 
     deflate_encode_len_ = kDefaultBufferSize;
-    int code = CompressAll(ENCODE_DEFLATE , source_buffer(), source_len(),
-                           deflate_encode_buffer_, &deflate_encode_len_);
+    int code = CompressAll(ENCODE_DEFLATE,
+                           source_buffer(),
+                           source_len(),
+                           deflate_encode_buffer_,
+                           &deflate_encode_len_);
     ASSERT_TRUE(code == Z_STREAM_END);
     ASSERT_GT(deflate_encode_len_, 0);
     ASSERT_TRUE(deflate_encode_len_ <= kDefaultBufferSize);
 
     // Encode the data with gzip
     gzip_encode_buffer_ = new char[kDefaultBufferSize];
     ASSERT_TRUE(gzip_encode_buffer_ != NULL);
 
     gzip_encode_len_ = kDefaultBufferSize;
-    code = CompressAll(ENCODE_GZIP, source_buffer(), source_len(),
-                           gzip_encode_buffer_, &gzip_encode_len_);
+    code = CompressAll(ENCODE_GZIP,
+                       source_buffer(),
+                       source_len(),
+                       gzip_encode_buffer_,
+                       &gzip_encode_len_);
     ASSERT_TRUE(code == Z_STREAM_END);
     ASSERT_GT(gzip_encode_len_, 0);
     ASSERT_TRUE(gzip_encode_len_ <= kDefaultBufferSize);
   }
 
   virtual void TearDown() {
     delete[] deflate_encode_buffer_;
     deflate_encode_buffer_ = NULL;
 
     delete[] gzip_encode_buffer_;
     gzip_encode_buffer_ = NULL;
 
     PlatformTest::TearDown();
   }
 
   // Compress the data in source with deflate encoding and write output to the
   // buffer provided by dest. The function returns Z_OK if success, and returns
   // other zlib error code if fail.
   // The parameter mode specifies the encoding mechanism.
   // The dest buffer should be large enough to hold all the output data.
-  int CompressAll(EncodeMode mode, const char* source, int source_size,
-                  char* dest, int* dest_len) {
+  int CompressAll(EncodeMode mode,
+                  const char* source,
+                  int source_size,
+                  char* dest,
+                  int* dest_len) {
     z_stream zlib_stream;
     memset(&zlib_stream, 0, sizeof(zlib_stream));
     int code;
 
     // Initialize zlib
     if (mode == ENCODE_GZIP) {
-      code = deflateInit2(&zlib_stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
+      code = deflateInit2(&zlib_stream,
+                          Z_DEFAULT_COMPRESSION,
+                          Z_DEFLATED,
                           -MAX_WBITS,
                           8,  // DEF_MEM_LEVEL
                           Z_DEFAULT_STRATEGY);
     } else {
       code = deflateInit(&zlib_stream, Z_DEFAULT_COMPRESSION);
     }
 
     if (code != Z_OK)
       return code;
 
@@ skipping 39 matching lines @@
     char decode_buffer[kDefaultBufferSize];
     char* decode_next = decode_buffer;
     int decode_avail_size = kDefaultBufferSize;
 
     const char* encode_next = encoded_source;
     int encode_avail_size = encoded_source_len;
 
     int code = Filter::FILTER_OK;
     while (code != Filter::FILTER_DONE) {
       int encode_data_len;
-      encode_data_len = std::min(encode_avail_size,
-                                 filter->stream_buffer_size());
+      encode_data_len =
+          std::min(encode_avail_size, filter->stream_buffer_size());
       memcpy(filter->stream_buffer()->data(), encode_next, encode_data_len);
       filter->FlushStreamBuffer(encode_data_len);
       encode_next += encode_data_len;
       encode_avail_size -= encode_data_len;
 
       while (1) {
         int decode_data_len = std::min(decode_avail_size, output_buffer_size);
 
         code = filter->ReadData(decode_next, &decode_data_len);
         decode_next += decode_data_len;
@@ skipping 12 matching lines @@
     int decode_total_data_len = kDefaultBufferSize - decode_avail_size;
     EXPECT_TRUE(decode_total_data_len == source_len);
     EXPECT_EQ(memcmp(source, decode_buffer, source_len), 0);
   }
 
   // Unsafe function to use filter to decode compressed data.
   // Parameters: Source and source_len are compressed data and its size.
   // Dest is the buffer for decoding results. Upon entry, *dest_len is the size
   // of the dest buffer. Upon exit, *dest_len is the number of chars written
   // into the buffer.
-  int DecodeAllWithFilter(Filter* filter, const char* source, int source_len,
-                          char* dest, int* dest_len) {
+  int DecodeAllWithFilter(Filter* filter,
+                          const char* source,
+                          int source_len,
+                          char* dest,
+                          int* dest_len) {
     memcpy(filter->stream_buffer()->data(), source, source_len);
     filter->FlushStreamBuffer(source_len);
     return filter->ReadData(dest, dest_len);
   }
 
   void InitFilter(Filter::FilterType type) {
     std::vector<Filter::FilterType> filter_types;
     filter_types.push_back(type);
     filter_.reset(Filter::Factory(filter_types, filter_context_));
     ASSERT_TRUE(filter_.get());
     ASSERT_GE(filter_->stream_buffer_size(), kDefaultBufferSize);
   }
 
   void InitFilterWithBufferSize(Filter::FilterType type, int buffer_size) {
     std::vector<Filter::FilterType> filter_types;
     filter_types.push_back(type);
-    filter_.reset(Filter::FactoryForTests(filter_types, filter_context_,
-                                          buffer_size));
+    filter_.reset(
+        Filter::FactoryForTests(filter_types, filter_context_, buffer_size));
     ASSERT_TRUE(filter_.get());
   }
 
   const char* source_buffer() const { return source_buffer_.data(); }
   int source_len() const { return static_cast<int>(source_buffer_.size()); }
 
   scoped_ptr<Filter> filter_;
 
   std::string source_buffer_;
 
   char* deflate_encode_buffer_;
   int deflate_encode_len_;
 
   char* gzip_encode_buffer_;
   int gzip_encode_len_;
 
  private:
   MockFilterContext filter_context_;
 };
 
 // Basic scenario: decoding deflate data with big enough buffer.
 TEST_F(GZipUnitTest, DecodeDeflate) {
   // Decode the compressed data with filter
   InitFilter(Filter::FILTER_TYPE_DEFLATE);
-  memcpy(filter_->stream_buffer()->data(), deflate_encode_buffer_,
+  memcpy(filter_->stream_buffer()->data(),
+         deflate_encode_buffer_,
          deflate_encode_len_);
   filter_->FlushStreamBuffer(deflate_encode_len_);
 
   char deflate_decode_buffer[kDefaultBufferSize];
   int deflate_decode_size = kDefaultBufferSize;
   filter_->ReadData(deflate_decode_buffer, &deflate_decode_size);
 
   // Compare the decoding result with source data
   EXPECT_TRUE(deflate_decode_size == source_len());
   EXPECT_EQ(memcmp(source_buffer(), deflate_decode_buffer, source_len()), 0);
 }
 
 // Basic scenario: decoding gzip data with big enough buffer.
 TEST_F(GZipUnitTest, DecodeGZip) {
   // Decode the compressed data with filter
   InitFilter(Filter::FILTER_TYPE_GZIP);
-  memcpy(filter_->stream_buffer()->data(), gzip_encode_buffer_,
-         gzip_encode_len_);
+  memcpy(
+      filter_->stream_buffer()->data(), gzip_encode_buffer_, gzip_encode_len_);
   filter_->FlushStreamBuffer(gzip_encode_len_);
 
   char gzip_decode_buffer[kDefaultBufferSize];
   int gzip_decode_size = kDefaultBufferSize;
   filter_->ReadData(gzip_decode_buffer, &gzip_decode_size);
 
   // Compare the decoding result with source data
   EXPECT_TRUE(gzip_decode_size == source_len());
   EXPECT_EQ(memcmp(source_buffer(), gzip_decode_buffer, source_len()), 0);
 }
 
 // Tests we can call filter repeatedly to get all the data decoded.
 // To do that, we create a filter with a small buffer that can not hold all
 // the input data.
 TEST_F(GZipUnitTest, DecodeWithSmallBuffer) {
   InitFilterWithBufferSize(Filter::FILTER_TYPE_DEFLATE, kSmallBufferSize);
   EXPECT_EQ(kSmallBufferSize, filter_->stream_buffer_size());
-  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
-                             deflate_encode_buffer_, deflate_encode_len_,
+  DecodeAndCompareWithFilter(filter_.get(),
+                             source_buffer(),
+                             source_len(),
+                             deflate_encode_buffer_,
+                             deflate_encode_len_,
                              kDefaultBufferSize);
 }
 
 // Tests we can still decode with just 1 byte buffer in the filter.
 // The purpose of this tests are two: (1) Verify filter can parse partial GZip
 // header correctly. (2) Sometimes the filter will consume input without
 // generating output. Verify filter can handle it correctly.
 TEST_F(GZipUnitTest, DecodeWithOneByteBuffer) {
   InitFilterWithBufferSize(Filter::FILTER_TYPE_GZIP, 1);
   EXPECT_EQ(1, filter_->stream_buffer_size());
-  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
-                             gzip_encode_buffer_, gzip_encode_len_,
+  DecodeAndCompareWithFilter(filter_.get(),
+                             source_buffer(),
+                             source_len(),
+                             gzip_encode_buffer_,
+                             gzip_encode_len_,
                              kDefaultBufferSize);
 }
 
 // Tests we can decode when caller has small buffer to read out from filter.
 TEST_F(GZipUnitTest, DecodeWithSmallOutputBuffer) {
   InitFilter(Filter::FILTER_TYPE_DEFLATE);
-  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
-                             deflate_encode_buffer_, deflate_encode_len_,
+  DecodeAndCompareWithFilter(filter_.get(),
+                             source_buffer(),
+                             source_len(),
+                             deflate_encode_buffer_,
+                             deflate_encode_len_,
                              kSmallBufferSize);
 }
 
 // Tests we can still decode with just 1 byte buffer in the filter and just 1
 // byte buffer in the caller.
 TEST_F(GZipUnitTest, DecodeWithOneByteInputAndOutputBuffer) {
   InitFilterWithBufferSize(Filter::FILTER_TYPE_GZIP, 1);
   EXPECT_EQ(1, filter_->stream_buffer_size());
-  DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
-                             gzip_encode_buffer_, gzip_encode_len_, 1);
+  DecodeAndCompareWithFilter(filter_.get(),
+                             source_buffer(),
+                             source_len(),
+                             gzip_encode_buffer_,
+                             gzip_encode_len_,
+                             1);
 }
 
 // Decoding deflate stream with corrupted data.
 TEST_F(GZipUnitTest, DecodeCorruptedData) {
   char corrupt_data[kDefaultBufferSize];
   int corrupt_data_len = deflate_encode_len_;
   memcpy(corrupt_data, deflate_encode_buffer_, deflate_encode_len_);
 
   int pos = corrupt_data_len / 2;
   corrupt_data[pos] = !corrupt_data[pos];
 
   // Decode the corrupted data with filter
   InitFilter(Filter::FILTER_TYPE_DEFLATE);
   char corrupt_decode_buffer[kDefaultBufferSize];
   int corrupt_decode_size = kDefaultBufferSize;
 
-  int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len,
-                                 corrupt_decode_buffer, &corrupt_decode_size);
+  int code = DecodeAllWithFilter(filter_.get(),
+                                 corrupt_data,
+                                 corrupt_data_len,
+                                 corrupt_decode_buffer,
+                                 &corrupt_decode_size);
 
   // Expect failures
   EXPECT_TRUE(code == Filter::FILTER_ERROR);
 }
 
 // Decoding deflate stream with missing data.
 TEST_F(GZipUnitTest, DecodeMissingData) {
   char corrupt_data[kDefaultBufferSize];
   int corrupt_data_len = deflate_encode_len_;
   memcpy(corrupt_data, deflate_encode_buffer_, deflate_encode_len_);
 
   int pos = corrupt_data_len / 2;
   int len = corrupt_data_len - pos - 1;
-  memmove(&corrupt_data[pos], &corrupt_data[pos+1], len);
+  memmove(&corrupt_data[pos], &corrupt_data[pos + 1], len);
   --corrupt_data_len;
 
   // Decode the corrupted data with filter
   InitFilter(Filter::FILTER_TYPE_DEFLATE);
   char corrupt_decode_buffer[kDefaultBufferSize];
   int corrupt_decode_size = kDefaultBufferSize;
 
-  int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len,
-                                 corrupt_decode_buffer, &corrupt_decode_size);
+  int code = DecodeAllWithFilter(filter_.get(),
+                                 corrupt_data,
+                                 corrupt_data_len,
+                                 corrupt_decode_buffer,
+                                 &corrupt_decode_size);
 
   // Expect failures
   EXPECT_EQ(Filter::FILTER_ERROR, code);
 }
 
 // Decoding gzip stream with corrupted header.
 TEST_F(GZipUnitTest, DecodeCorruptedHeader) {
   char corrupt_data[kDefaultBufferSize];
   int corrupt_data_len = gzip_encode_len_;
   memcpy(corrupt_data, gzip_encode_buffer_, gzip_encode_len_);
 
   corrupt_data[2] = !corrupt_data[2];
 
   // Decode the corrupted data with filter
   InitFilter(Filter::FILTER_TYPE_GZIP);
   char corrupt_decode_buffer[kDefaultBufferSize];
   int corrupt_decode_size = kDefaultBufferSize;
 
-  int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len,
-                                 corrupt_decode_buffer, &corrupt_decode_size);
+  int code = DecodeAllWithFilter(filter_.get(),
+                                 corrupt_data,
+                                 corrupt_data_len,
+                                 corrupt_decode_buffer,
+                                 &corrupt_decode_size);
 
   // Expect failures
   EXPECT_TRUE(code == Filter::FILTER_ERROR);
 }
 
 }  // namespace net