net/filter/brotli_filter_unittest.cc - chromium/src.git - Git at Google

 // Copyright 2015 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/filter/brotli_filter.h"

 #include <memory>

 #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"

 namespace {
 const int kDefaultBufferSize = 4096;
 const int kSmallBufferSize = 128;
 }  // namespace

 namespace net {

 // These tests use the path service, which uses autoreleased objects on the
 // Mac, so this needs to be a PlatformTest.
 class BrotliUnitTest : public PlatformTest {
  protected:
   void SetUp() override {
     PlatformTest::SetUp();

     // Get the path of data directory.
     base::FilePath data_dir;
     PathService::Get(base::DIR_SOURCE_ROOT, &data_dir);
     data_dir = data_dir.AppendASCII("net");
     data_dir = data_dir.AppendASCII("data");
     data_dir = data_dir.AppendASCII("filter_unittests");

     // Read data from the original file into buffer.
     base::FilePath file_path;
     file_path = data_dir.AppendASCII("google.txt");
     ASSERT_TRUE(base::ReadFileToString(file_path, &source_buffer_));

     // Read data from the encoded file into buffer.
     base::FilePath encoded_file_path;
     encoded_file_path = data_dir.AppendASCII("google.br");
     ASSERT_TRUE(base::ReadFileToString(encoded_file_path, &encoded_buffer_));
     ASSERT_GE(kDefaultBufferSize, static_cast<int>(encoded_buffer_.size()));
   }

   // Use filter to decode compressed data, and compare the decoded 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_GE(kDefaultBufferSize, source_len);
     ASSERT_GE(kDefaultBufferSize, output_buffer_size);

     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 =
           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 (true) {
         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_NE(Filter::FILTER_ERROR, code);

         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_EQ(source_len, decode_total_data_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 output 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() {
     std::vector<Filter::FilterType> filter_types;
     filter_types.push_back(Filter::FILTER_TYPE_BROTLI);
     filter_ = Filter::Factory(filter_types, filter_context_);
     ASSERT_TRUE(filter_.get());
     ASSERT_LE(kDefaultBufferSize, filter_->stream_buffer_size());
   }

   void InitFilterWithBufferSize(int buffer_size) {
     std::vector<Filter::FilterType> filter_types;
     filter_types.push_back(Filter::FILTER_TYPE_BROTLI);
     filter_ =
         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()); }

   const char* encoded_buffer() const { return encoded_buffer_.data(); }
   int encoded_len() const { return static_cast<int>(encoded_buffer_.size()); }

   std::unique_ptr<Filter> filter_;

  private:
   MockFilterContext filter_context_;
   std::string source_buffer_;
   std::string encoded_buffer_;
 };

 // Basic scenario: decoding brotli data with big enough buffer.
 TEST_F(BrotliUnitTest, DecodeBrotli) {
   InitFilter();
   memcpy(filter_->stream_buffer()->data(), encoded_buffer(), encoded_len());
   filter_->FlushStreamBuffer(encoded_len());

   ASSERT_GE(kDefaultBufferSize, source_len());
   char decode_buffer[kDefaultBufferSize];
   int decode_size = kDefaultBufferSize;
   filter_->ReadData(decode_buffer, &decode_size);

   // Compare the decoding result with source data
   EXPECT_EQ(source_len(), decode_size);
   EXPECT_EQ(memcmp(source_buffer(), 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(BrotliUnitTest, DecodeWithSmallBuffer) {
   InitFilterWithBufferSize(kSmallBufferSize);
   EXPECT_EQ(kSmallBufferSize, filter_->stream_buffer_size());
   DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
                              encoded_buffer(), encoded_len(),
                              kDefaultBufferSize);
 }

 // Tests we can still decode with just 1 byte buffer in the filter.
 // The purpose of this test: sometimes the filter will consume input without
 // generating output. Verify filter can handle it correctly.
 TEST_F(BrotliUnitTest, DecodeWithOneByteBuffer) {
   InitFilterWithBufferSize(1);
   EXPECT_EQ(1, filter_->stream_buffer_size());
   DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
                              encoded_buffer(), encoded_len(),
                              kDefaultBufferSize);
 }

 // Tests we can decode when caller has small buffer to read out from filter.
 TEST_F(BrotliUnitTest, DecodeWithSmallOutputBuffer) {
   InitFilter();
   DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
                              encoded_buffer(), encoded_len(), kSmallBufferSize);
 }

 // Tests we can decode when caller has small buffer and input is also broken
 // into small parts. This may uncover some corner cases that doesn't happen with
 // one-byte buffers.
 TEST_F(BrotliUnitTest, DecodeWithSmallInputAndOutputBuffer) {
   InitFilterWithBufferSize(kSmallBufferSize);
   DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
                              encoded_buffer(), encoded_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(BrotliUnitTest, DecodeWithOneByteInputAndOutputBuffer) {
   InitFilterWithBufferSize(1);
   EXPECT_EQ(1, filter_->stream_buffer_size());
   DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
                              encoded_buffer(), encoded_len(), 1);
 }

 // Decoding deflate stream with corrupted data.
 TEST_F(BrotliUnitTest, DecodeCorruptedData) {
   char corrupt_data[kDefaultBufferSize];
   int corrupt_data_len = encoded_len();
   memcpy(corrupt_data, encoded_buffer(), encoded_len());

   int pos = corrupt_data_len / 2;
   corrupt_data[pos] = !corrupt_data[pos];

   // Decode the corrupted data with filter
   InitFilter();
   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 deflate stream with missing data.
 TEST_F(BrotliUnitTest, DecodeMissingData) {
   char corrupt_data[kDefaultBufferSize];
   int corrupt_data_len = encoded_len();
   memcpy(corrupt_data, encoded_buffer(), encoded_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();
   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 brotli stream with empty output data.
 TEST_F(BrotliUnitTest, DecodeEmptyData) {
   char data[1] = {6};  // WBITS = 16, ISLAST = 1, ISLASTEMPTY = 1
   int data_len = 1;

   InitFilter();
   char decode_buffer[kDefaultBufferSize];
   int decode_size = kDefaultBufferSize;
   int code = DecodeAllWithFilter(filter_.get(), data, data_len, decode_buffer,
                                  &decode_size);

   // Expect success / empty output.
   EXPECT_EQ(Filter::FILTER_DONE, code);
   EXPECT_EQ(0, decode_size);
 }

 }  // namespace net
	// Copyright 2015 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/filter/brotli_filter.h"

	#include <memory>

	#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"

	namespace {
	const int kDefaultBufferSize = 4096;
	const int kSmallBufferSize = 128;
	} // namespace

	namespace net {

	// These tests use the path service, which uses autoreleased objects on the
	// Mac, so this needs to be a PlatformTest.
	class BrotliUnitTest : public PlatformTest {
	protected:
	void SetUp() override {
	PlatformTest::SetUp();

	// Get the path of data directory.
	base::FilePath data_dir;
	PathService::Get(base::DIR_SOURCE_ROOT, &data_dir);
	data_dir = data_dir.AppendASCII("net");
	data_dir = data_dir.AppendASCII("data");
	data_dir = data_dir.AppendASCII("filter_unittests");

	// Read data from the original file into buffer.
	base::FilePath file_path;
	file_path = data_dir.AppendASCII("google.txt");
	ASSERT_TRUE(base::ReadFileToString(file_path, &source_buffer_));

	// Read data from the encoded file into buffer.
	base::FilePath encoded_file_path;
	encoded_file_path = data_dir.AppendASCII("google.br");
	ASSERT_TRUE(base::ReadFileToString(encoded_file_path, &encoded_buffer_));
	ASSERT_GE(kDefaultBufferSize, static_cast<int>(encoded_buffer_.size()));
	}

	// Use filter to decode compressed data, and compare the decoded 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_GE(kDefaultBufferSize, source_len);
	ASSERT_GE(kDefaultBufferSize, output_buffer_size);

	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 =
	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 (true) {
	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_NE(Filter::FILTER_ERROR, code);

	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_EQ(source_len, decode_total_data_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 output 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() {
	std::vector<Filter::FilterType> filter_types;
	filter_types.push_back(Filter::FILTER_TYPE_BROTLI);
	filter_ = Filter::Factory(filter_types, filter_context_);
	ASSERT_TRUE(filter_.get());
	ASSERT_LE(kDefaultBufferSize, filter_->stream_buffer_size());
	}

	void InitFilterWithBufferSize(int buffer_size) {
	std::vector<Filter::FilterType> filter_types;
	filter_types.push_back(Filter::FILTER_TYPE_BROTLI);
	filter_ =
	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()); }

	const char* encoded_buffer() const { return encoded_buffer_.data(); }
	int encoded_len() const { return static_cast<int>(encoded_buffer_.size()); }

	std::unique_ptr<Filter> filter_;

	private:
	MockFilterContext filter_context_;
	std::string source_buffer_;
	std::string encoded_buffer_;
	};

	// Basic scenario: decoding brotli data with big enough buffer.
	TEST_F(BrotliUnitTest, DecodeBrotli) {
	InitFilter();
	memcpy(filter_->stream_buffer()->data(), encoded_buffer(), encoded_len());
	filter_->FlushStreamBuffer(encoded_len());

	ASSERT_GE(kDefaultBufferSize, source_len());
	char decode_buffer[kDefaultBufferSize];
	int decode_size = kDefaultBufferSize;
	filter_->ReadData(decode_buffer, &decode_size);

	// Compare the decoding result with source data
	EXPECT_EQ(source_len(), decode_size);
	EXPECT_EQ(memcmp(source_buffer(), 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(BrotliUnitTest, DecodeWithSmallBuffer) {
	InitFilterWithBufferSize(kSmallBufferSize);
	EXPECT_EQ(kSmallBufferSize, filter_->stream_buffer_size());
	DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
	encoded_buffer(), encoded_len(),
	kDefaultBufferSize);
	}

	// Tests we can still decode with just 1 byte buffer in the filter.
	// The purpose of this test: sometimes the filter will consume input without
	// generating output. Verify filter can handle it correctly.
	TEST_F(BrotliUnitTest, DecodeWithOneByteBuffer) {
	InitFilterWithBufferSize(1);
	EXPECT_EQ(1, filter_->stream_buffer_size());
	DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
	encoded_buffer(), encoded_len(),
	kDefaultBufferSize);
	}

	// Tests we can decode when caller has small buffer to read out from filter.
	TEST_F(BrotliUnitTest, DecodeWithSmallOutputBuffer) {
	InitFilter();
	DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
	encoded_buffer(), encoded_len(), kSmallBufferSize);
	}

	// Tests we can decode when caller has small buffer and input is also broken
	// into small parts. This may uncover some corner cases that doesn't happen with
	// one-byte buffers.
	TEST_F(BrotliUnitTest, DecodeWithSmallInputAndOutputBuffer) {
	InitFilterWithBufferSize(kSmallBufferSize);
	DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
	encoded_buffer(), encoded_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(BrotliUnitTest, DecodeWithOneByteInputAndOutputBuffer) {
	InitFilterWithBufferSize(1);
	EXPECT_EQ(1, filter_->stream_buffer_size());
	DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
	encoded_buffer(), encoded_len(), 1);
	}

	// Decoding deflate stream with corrupted data.
	TEST_F(BrotliUnitTest, DecodeCorruptedData) {
	char corrupt_data[kDefaultBufferSize];
	int corrupt_data_len = encoded_len();
	memcpy(corrupt_data, encoded_buffer(), encoded_len());

	int pos = corrupt_data_len / 2;
	corrupt_data[pos] = !corrupt_data[pos];

	// Decode the corrupted data with filter
	InitFilter();
	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 deflate stream with missing data.
	TEST_F(BrotliUnitTest, DecodeMissingData) {
	char corrupt_data[kDefaultBufferSize];
	int corrupt_data_len = encoded_len();
	memcpy(corrupt_data, encoded_buffer(), encoded_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();
	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 brotli stream with empty output data.
	TEST_F(BrotliUnitTest, DecodeEmptyData) {
	char data[1] = {6}; // WBITS = 16, ISLAST = 1, ISLASTEMPTY = 1
	int data_len = 1;

	InitFilter();
	char decode_buffer[kDefaultBufferSize];
	int decode_size = kDefaultBufferSize;
	int code = DecodeAllWithFilter(filter_.get(), data, data_len, decode_buffer,
	&decode_size);

	// Expect success / empty output.
	EXPECT_EQ(Filter::FILTER_DONE, code);
	EXPECT_EQ(0, decode_size);
	}

	} // namespace net