Chromium Code Reviews| Index: net/base/gzip_filter_unittest.cc |
| diff --git a/net/base/gzip_filter_unittest.cc b/net/base/gzip_filter_unittest.cc |
| index 247e7da4066386f28ee0b6a83862099f6b133e85..e43c42d43fa9b9d62f642dacb657e79f6e446beb 100644 |
| --- a/net/base/gzip_filter_unittest.cc |
| +++ b/net/base/gzip_filter_unittest.cc |
| @@ -24,7 +24,6 @@ namespace { |
| const int kDefaultBufferSize = 4096; |
| const int kSmallBufferSize = 128; |
| -const int kMaxBufferSize = 1048576; // 1048576 == 2^20 == 1 MB |
| const char kApplicationOctetStream[] = "application/octet-stream"; |
| const char kApplicationXGzip[] = "application/x-gzip"; |
| @@ -52,6 +51,8 @@ enum EncodeMode { |
| ENCODE_DEFLATE // Raw deflate. |
| }; |
| +} // namespace |
| + |
| // These tests use the path service, which uses autoreleased objects on the |
| // Mac, so this needs to be a PlatformTest. |
| class GZipUnitTest : public PlatformTest { |
| @@ -220,9 +221,26 @@ class GZipUnitTest : public PlatformTest { |
| 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()); |
| + } |
| + |
| + 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)); |
| + 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_; |
| @@ -230,23 +248,22 @@ class GZipUnitTest : public PlatformTest { |
| char* gzip_encode_buffer_; |
| int gzip_encode_len_; |
| + |
| + private: |
| + net::MockFilterContext filter_context_; |
| }; |
| // Basic scenario: decoding deflate data with big enough buffer. |
| TEST_F(GZipUnitTest, DecodeDeflate) { |
| // Decode the compressed data with filter |
| - std::vector<Filter::FilterType> filter_types; |
| - filter_types.push_back(Filter::FILTER_TYPE_DEFLATE); |
| - net::MockFilterContext filter_context(kDefaultBufferSize); |
| - scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context)); |
| - ASSERT_TRUE(filter.get()); |
| - memcpy(filter->stream_buffer()->data(), deflate_encode_buffer_, |
| + InitFilter(Filter::FILTER_TYPE_DEFLATE); |
| + memcpy(filter_->stream_buffer()->data(), deflate_encode_buffer_, |
| deflate_encode_len_); |
|
jar (doing other things)
2011/03/01 22:44:03
With this code not being explicit about buffer siz
adamk
2011/03/01 23:13:54
I've added this assert to InitBuffer(). There are
|
| - filter->FlushStreamBuffer(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); |
| + filter_->ReadData(deflate_decode_buffer, &deflate_decode_size); |
| // Compare the decoding result with source data |
| EXPECT_TRUE(deflate_decode_size == source_len()); |
| @@ -256,18 +273,14 @@ TEST_F(GZipUnitTest, DecodeDeflate) { |
| // Basic scenario: decoding gzip data with big enough buffer. |
| TEST_F(GZipUnitTest, DecodeGZip) { |
| // Decode the compressed data with filter |
| - std::vector<Filter::FilterType> filter_types; |
| - filter_types.push_back(Filter::FILTER_TYPE_GZIP); |
| - net::MockFilterContext filter_context(kDefaultBufferSize); |
| - scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context)); |
| - ASSERT_TRUE(filter.get()); |
| - memcpy(filter->stream_buffer()->data(), gzip_encode_buffer_, |
| + InitFilter(Filter::FILTER_TYPE_GZIP); |
| + memcpy(filter_->stream_buffer()->data(), gzip_encode_buffer_, |
| gzip_encode_len_); |
| - filter->FlushStreamBuffer(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); |
| + filter_->ReadData(gzip_decode_buffer, &gzip_decode_size); |
| // Compare the decoding result with source data |
| EXPECT_TRUE(gzip_decode_size == source_len()); |
| @@ -278,12 +291,8 @@ TEST_F(GZipUnitTest, DecodeGZip) { |
| // To do that, we create a filter with a small buffer that can not hold all |
| // the input data. |
| TEST_F(GZipUnitTest, DecodeWithSmallBuffer) { |
| - std::vector<Filter::FilterType> filter_types; |
| - filter_types.push_back(Filter::FILTER_TYPE_DEFLATE); |
| - net::MockFilterContext filter_context(kSmallBufferSize); |
| - scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context)); |
| - ASSERT_TRUE(filter.get()); |
| - DecodeAndCompareWithFilter(filter.get(), source_buffer(), source_len(), |
| + InitFilterWithBufferSize(Filter::FILTER_TYPE_DEFLATE, kSmallBufferSize); |
| + DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(), |
| deflate_encode_buffer_, deflate_encode_len_, |
| kDefaultBufferSize); |
| } |
| @@ -293,24 +302,16 @@ TEST_F(GZipUnitTest, DecodeWithSmallBuffer) { |
| // header correctly. (2) Sometimes the filter will consume input without |
| // generating output. Verify filter can handle it correctly. |
| TEST_F(GZipUnitTest, DecodeWithOneByteBuffer) { |
| - std::vector<Filter::FilterType> filter_types; |
| - filter_types.push_back(Filter::FILTER_TYPE_GZIP); |
| - net::MockFilterContext filter_context(1); |
| - scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context)); |
| - ASSERT_TRUE(filter.get()); |
| - DecodeAndCompareWithFilter(filter.get(), source_buffer(), source_len(), |
| + InitFilterWithBufferSize(Filter::FILTER_TYPE_GZIP, 1); |
| + 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) { |
| - std::vector<Filter::FilterType> filter_types; |
| - filter_types.push_back(Filter::FILTER_TYPE_DEFLATE); |
| - net::MockFilterContext filter_context(kDefaultBufferSize); |
| - scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context)); |
| - ASSERT_TRUE(filter.get()); |
| - DecodeAndCompareWithFilter(filter.get(), source_buffer(), source_len(), |
| + InitFilter(Filter::FILTER_TYPE_DEFLATE); |
| + DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(), |
| deflate_encode_buffer_, deflate_encode_len_, |
| kSmallBufferSize); |
| } |
| @@ -318,12 +319,8 @@ TEST_F(GZipUnitTest, DecodeWithSmallOutputBuffer) { |
| // 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) { |
| - std::vector<Filter::FilterType> filter_types; |
| - filter_types.push_back(Filter::FILTER_TYPE_GZIP); |
| - net::MockFilterContext filter_context(1); |
| - scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context)); |
| - ASSERT_TRUE(filter.get()); |
| - DecodeAndCompareWithFilter(filter.get(), source_buffer(), source_len(), |
| + InitFilterWithBufferSize(Filter::FILTER_TYPE_GZIP, 1); |
| + DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(), |
| gzip_encode_buffer_, gzip_encode_len_, 1); |
| } |
| @@ -337,15 +334,11 @@ TEST_F(GZipUnitTest, DecodeCorruptedData) { |
| corrupt_data[pos] = !corrupt_data[pos]; |
| // Decode the corrupted data with filter |
| - std::vector<Filter::FilterType> filter_types; |
| - filter_types.push_back(Filter::FILTER_TYPE_DEFLATE); |
| - net::MockFilterContext filter_context(kDefaultBufferSize); |
| - scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context)); |
| - ASSERT_TRUE(filter.get()); |
| + 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, |
| + int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len, |
| corrupt_decode_buffer, &corrupt_decode_size); |
| // Expect failures |
| @@ -364,15 +357,11 @@ TEST_F(GZipUnitTest, DecodeMissingData) { |
| --corrupt_data_len; |
| // Decode the corrupted data with filter |
| - std::vector<Filter::FilterType> filter_types; |
| - filter_types.push_back(Filter::FILTER_TYPE_DEFLATE); |
| - net::MockFilterContext filter_context(kDefaultBufferSize); |
| - scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context)); |
| - ASSERT_TRUE(filter.get()); |
| + 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, |
| + int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len, |
| corrupt_decode_buffer, &corrupt_decode_size); |
| // Expect failures |
| @@ -388,19 +377,13 @@ TEST_F(GZipUnitTest, DecodeCorruptedHeader) { |
| corrupt_data[2] = !corrupt_data[2]; |
| // Decode the corrupted data with filter |
| - std::vector<Filter::FilterType> filter_types; |
| - filter_types.push_back(Filter::FILTER_TYPE_GZIP); |
| - net::MockFilterContext filter_context(kDefaultBufferSize); |
| - scoped_ptr<Filter> filter(Filter::Factory(filter_types, filter_context)); |
| - ASSERT_TRUE(filter.get()); |
| + 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, |
| + 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 |