net/filter/gzip_filter_unittest.cc - Issue 1662763002: [ON HOLD] Implement pull-based design for content decoding

Unified Diff: net/filter/gzip_filter_unittest.cc

Issue 1662763002: [ON HOLD] Implement pull-based design for content decoding (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Address comments Created 4 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: net/filter/gzip_filter_unittest.cc

diff --git a/net/filter/gzip_filter_unittest.cc b/net/filter/gzip_filter_unittest.cc

deleted file mode 100644

index a100b255264190df24ab0cdcfbdd0a69ea48d394..0000000000000000000000000000000000000000

--- a/net/filter/gzip_filter_unittest.cc

+++ /dev/null

@@ -1,389 +0,0 @@

-// Use of this source code is governed by a BSD-style license that can be

-// found in the LICENSE file.

-#include "net/filter/gzip_filter.h"

-#include <fstream>

-#include <memory>

-#include <ostream>

-#include "base/bit_cast.h"

-#include "base/files/file_util.h"

-#include "base/path_service.h"

-#include "net/base/io_buffer.h"

-#include "net/filter/mock_filter_context.h"

-#include "testing/gtest/include/gtest/gtest.h"

-#include "testing/platform_test.h"

-#include "third_party/zlib/zlib.h"

-namespace {

-const int kDefaultBufferSize = 4096;

-const int kSmallBufferSize = 128;

-// The GZIP header (see RFC 1952):

-// +---+---+---+---+---+---+---+---+---+---+

-// |ID1|ID2|CM |FLG| MTIME |XFL|OS |

-// +---+---+---+---+---+---+---+---+---+---+

-// 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' };

-enum EncodeMode {

- 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:

- void SetUp() override {

- PlatformTest::SetUp();

- deflate_encode_buffer_ = NULL;

- gzip_encode_buffer_ = NULL;

- // Get the path of source data file.

- base::FilePath file_path;

- PathService::Get(base::DIR_SOURCE_ROOT, &file_path);

- file_path = file_path.AppendASCII("net");

- file_path = file_path.AppendASCII("data");

- file_path = file_path.AppendASCII("filter_unittests");

- 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_);

- 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_);

- ASSERT_TRUE(code == Z_STREAM_END);

- ASSERT_GT(gzip_encode_len_, 0);

- ASSERT_TRUE(gzip_encode_len_ <= kDefaultBufferSize);

- }

- void TearDown() override {

- 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) {

- 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,

- -MAX_WBITS,

- 8, // DEF_MEM_LEVEL

- Z_DEFAULT_STRATEGY);

- } else {

- code = deflateInit(&zlib_stream, Z_DEFAULT_COMPRESSION);

- }

- if (code != Z_OK)

- return code;

- // Fill in zlib control block

- zlib_stream.next_in = bit_cast<Bytef*>(source);

- zlib_stream.avail_in = source_size;

- zlib_stream.next_out = bit_cast<Bytef*>(dest);

- zlib_stream.avail_out = *dest_len;

- // Write header if needed

- if (mode == ENCODE_GZIP) {

- if (zlib_stream.avail_out < sizeof(kGZipHeader))

- return Z_BUF_ERROR;

- memcpy(zlib_stream.next_out, kGZipHeader, sizeof(kGZipHeader));

- zlib_stream.next_out += sizeof(kGZipHeader);

- zlib_stream.avail_out -= sizeof(kGZipHeader);

- }

- // Do deflate

- code = deflate(&zlib_stream, Z_FINISH);

- *dest_len = *dest_len - zlib_stream.avail_out;

- deflateEnd(&zlib_stream);

- return code;

- }

- // Use filter to decode compressed data, and compare the decoding result with

- // the orginal Data.

- // Parameters: Source and source_len are original data and its size.

- // Encoded_source and encoded_source_len are compressed data and its size.

- // Output_buffer_size specifies the size of buffer to read out data from

- // filter.

- void DecodeAndCompareWithFilter(Filter* filter,

- const char* source,

- int source_len,

- const char* encoded_source,

- int encoded_source_len,

- int output_buffer_size) {

- // Make sure we have enough space to hold the decoding output.

- ASSERT_TRUE(source_len <= kDefaultBufferSize);

- ASSERT_TRUE(output_buffer_size <= kDefaultBufferSize);

- 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());

- 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;

- decode_avail_size -= decode_data_len;

- ASSERT_TRUE(code != Filter::FILTER_ERROR);

- if (code == Filter::FILTER_NEED_MORE_DATA ||

- code == Filter::FILTER_DONE) {

- break;

- }

- // Compare the decoding result with source data

- 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) {

- 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));

- ASSERT_TRUE(filter_.get());

- }

- const char* source_buffer() const { return source_buffer_.data(); }

- int source_len() const { return static_cast<int>(source_buffer_.size()); }

- std::unique_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_,

- 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_);

- 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_,

- 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_,

- 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_,

- 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);

-// 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);

- // 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);

- --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);

- // 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);

- // Expect failures

- EXPECT_TRUE(code == Filter::FILTER_ERROR);

-} // namespace net

« net/filter/filter_stream_source.cc ('K') | « net/filter/gzip_filter.cc ('k') | net/filter/gzip_stream_source.h » ('j') | net/filter/sdch_stream_source_delegate.h » ('J')