| Index: net/filter/gzip_filter_unittest.cc
|
| diff --git a/net/filter/gzip_filter_unittest.cc b/net/filter/gzip_filter_unittest.cc
|
| index 97d7b7d281475ca54eeced204cbc5be64411b909..22594fd34d7f06c1f432527bd4327c48eb18c2d2 100644
|
| --- a/net/filter/gzip_filter_unittest.cc
|
| +++ b/net/filter/gzip_filter_unittest.cc
|
| @@ -33,12 +33,12 @@ const int kSmallBufferSize = 128;
|
| // 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
|
| @@ -71,8 +71,11 @@ class GZipUnitTest : public PlatformTest {
|
| 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);
|
| @@ -82,8 +85,11 @@ class GZipUnitTest : public PlatformTest {
|
| 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);
|
| @@ -104,15 +110,20 @@ class GZipUnitTest : public PlatformTest {
|
| // 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);
|
| @@ -172,8 +183,8 @@ class GZipUnitTest : public PlatformTest {
|
| 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;
|
| @@ -206,8 +217,11 @@ class GZipUnitTest : public PlatformTest {
|
| // 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);
|
| @@ -224,8 +238,8 @@ class GZipUnitTest : public PlatformTest {
|
| 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());
|
| }
|
|
|
| @@ -250,7 +264,8 @@ class GZipUnitTest : public PlatformTest {
|
| 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_);
|
|
|
| @@ -267,8 +282,8 @@ TEST_F(GZipUnitTest, DecodeDeflate) {
|
| 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];
|
| @@ -286,8 +301,11 @@ TEST_F(GZipUnitTest, DecodeGZip) {
|
| 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);
|
| }
|
|
|
| @@ -298,16 +316,22 @@ TEST_F(GZipUnitTest, DecodeWithSmallBuffer) {
|
| 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);
|
| }
|
|
|
| @@ -316,8 +340,12 @@ TEST_F(GZipUnitTest, DecodeWithSmallOutputBuffer) {
|
| 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.
|
| @@ -334,8 +362,11 @@ TEST_F(GZipUnitTest, DecodeCorruptedData) {
|
| 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);
|
| @@ -349,7 +380,7 @@ TEST_F(GZipUnitTest, DecodeMissingData) {
|
|
|
| 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
|
| @@ -357,8 +388,11 @@ TEST_F(GZipUnitTest, DecodeMissingData) {
|
| 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);
|
| @@ -377,8 +411,11 @@ TEST_F(GZipUnitTest, DecodeCorruptedHeader) {
|
| 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);
|
|
|