net/base/gzip_filter_unittest.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <fstream>
   6 #include <ostream>
   7
   8 #include "base/file_util.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/path_service.h"
  11 #include "net/base/gzip_filter.h"
  12 #include "net/base/mock_filter_context.h"
  13 #include "net/base/io_buffer.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "testing/platform_test.h"
  16 #include "third_party/zlib/zlib.h"
  17
  18 namespace {
  19
  20 const int kDefaultBufferSize = 4096;
  21 const int kSmallBufferSize = 128;
  22
  23 const char kApplicationOctetStream[] = "application/octet-stream";
  24 const char kApplicationXGzip[] = "application/x-gzip";
  25 const char kApplicationGzip[] = "application/gzip";
  26 const char kApplicationXGunzip[] = "application/x-gunzip";
  27
  28 // The GZIP header (see RFC 1952):
  29 //   +---+---+---+---+---+---+---+---+---+---+
  30 //   |ID1|ID2|CM |FLG|     MTIME     |XFL|OS |
  31 //   +---+---+---+---+---+---+---+---+---+---+
  32 //     ID1     \037
  33 //     ID2     \213
  34 //     CM      \010 (compression method == DEFLATE)
  35 //     FLG     \000 (special flags that we do not support)
  36 //     MTIME   Unix format modification time (0 means not available)
  37 //     XFL     2-4? DEFLATE flags
  38 //     OS      ???? Operating system indicator (255 means unknown)
  39 //
  40 // Header value we generate:
  41 const char kGZipHeader[] = { '\037', '\213', '\010', '\000', '\000',
  42                              '\000', '\000', '\000', '\002', '\377' };
  43
  44 enum EncodeMode {
  45   ENCODE_GZIP,      // Wrap the deflate with a GZip header.
  46   ENCODE_DEFLATE    // Raw deflate.
  47 };
  48
  49 }  // namespace
  50
  51 namespace net {
  52
  53 // These tests use the path service, which uses autoreleased objects on the
  54 // Mac, so this needs to be a PlatformTest.
  55 class GZipUnitTest : public PlatformTest {
  56  protected:
  57   virtual void SetUp() {
  58     PlatformTest::SetUp();
  59
  60     deflate_encode_buffer_ = NULL;
  61     gzip_encode_buffer_ = NULL;
  62
  63     // Get the path of source data file.
  64     base::FilePath file_path;
  65     PathService::Get(base::DIR_SOURCE_ROOT, &file_path);
  66     file_path = file_path.AppendASCII("net");
  67     file_path = file_path.AppendASCII("data");
  68     file_path = file_path.AppendASCII("filter_unittests");
  69     file_path = file_path.AppendASCII("google.txt");
  70
  71     // Read data from the file into buffer.
  72     ASSERT_TRUE(file_util::ReadFileToString(file_path, &source_buffer_));
  73
  74     // Encode the data with deflate
  75     deflate_encode_buffer_ = new char[kDefaultBufferSize];
  76     ASSERT_TRUE(deflate_encode_buffer_ != NULL);
  77
  78     deflate_encode_len_ = kDefaultBufferSize;
  79     int code = CompressAll(ENCODE_DEFLATE , source_buffer(), source_len(),
  80                            deflate_encode_buffer_, &deflate_encode_len_);
  81     ASSERT_TRUE(code == Z_STREAM_END);
  82     ASSERT_GT(deflate_encode_len_, 0);
  83     ASSERT_TRUE(deflate_encode_len_ <= kDefaultBufferSize);
  84
  85     // Encode the data with gzip
  86     gzip_encode_buffer_ = new char[kDefaultBufferSize];
  87     ASSERT_TRUE(gzip_encode_buffer_ != NULL);
  88
  89     gzip_encode_len_ = kDefaultBufferSize;
  90     code = CompressAll(ENCODE_GZIP, source_buffer(), source_len(),
  91                            gzip_encode_buffer_, &gzip_encode_len_);
  92     ASSERT_TRUE(code == Z_STREAM_END);
  93     ASSERT_GT(gzip_encode_len_, 0);
  94     ASSERT_TRUE(gzip_encode_len_ <= kDefaultBufferSize);
  95   }
  96
  97   virtual void TearDown() {
  98     delete[] deflate_encode_buffer_;
  99     deflate_encode_buffer_ = NULL;
 100
 101     delete[] gzip_encode_buffer_;
 102     gzip_encode_buffer_ = NULL;
 103
 104     PlatformTest::TearDown();
 105   }
 106
 107   // Compress the data in source with deflate encoding and write output to the
 108   // buffer provided by dest. The function returns Z_OK if success, and returns
 109   // other zlib error code if fail.
 110   // The parameter mode specifies the encoding mechanism.
 111   // The dest buffer should be large enough to hold all the output data.
 112   int CompressAll(EncodeMode mode, const char* source, int source_size,
 113                   char* dest, int* dest_len) {
 114     z_stream zlib_stream;
 115     memset(&zlib_stream, 0, sizeof(zlib_stream));
 116     int code;
 117
 118     // Initialize zlib
 119     if (mode == ENCODE_GZIP) {
 120       code = deflateInit2(&zlib_stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
 121                           -MAX_WBITS,
 122                           8,  // DEF_MEM_LEVEL
 123                           Z_DEFAULT_STRATEGY);
 124     } else {
 125       code = deflateInit(&zlib_stream, Z_DEFAULT_COMPRESSION);
 126     }
 127
 128     if (code != Z_OK)
 129       return code;
 130
 131     // Fill in zlib control block
 132     zlib_stream.next_in = bit_cast<Bytef*>(source);
 133     zlib_stream.avail_in = source_size;
 134     zlib_stream.next_out = bit_cast<Bytef*>(dest);
 135     zlib_stream.avail_out = *dest_len;
 136
 137     // Write header if needed
 138     if (mode == ENCODE_GZIP) {
 139       if (zlib_stream.avail_out < sizeof(kGZipHeader))
 140         return Z_BUF_ERROR;
 141       memcpy(zlib_stream.next_out, kGZipHeader, sizeof(kGZipHeader));
 142       zlib_stream.next_out += sizeof(kGZipHeader);
 143       zlib_stream.avail_out -= sizeof(kGZipHeader);
 144     }
 145
 146     // Do deflate
 147     code = deflate(&zlib_stream, Z_FINISH);
 148     *dest_len = *dest_len - zlib_stream.avail_out;
 149
 150     deflateEnd(&zlib_stream);
 151     return code;
 152   }
 153
 154   // Use filter to decode compressed data, and compare the decoding result with
 155   // the orginal Data.
 156   // Parameters: Source and source_len are original data and its size.
 157   // Encoded_source and encoded_source_len are compressed data and its size.
 158   // Output_buffer_size specifies the size of buffer to read out data from
 159   // filter.
 160   void DecodeAndCompareWithFilter(Filter* filter,
 161                                   const char* source,
 162                                   int source_len,
 163                                   const char* encoded_source,
 164                                   int encoded_source_len,
 165                                   int output_buffer_size) {
 166     // Make sure we have enough space to hold the decoding output.
 167     ASSERT_TRUE(source_len <= kDefaultBufferSize);
 168     ASSERT_TRUE(output_buffer_size <= kDefaultBufferSize);
 169
 170     char decode_buffer[kDefaultBufferSize];
 171     char* decode_next = decode_buffer;
 172     int decode_avail_size = kDefaultBufferSize;
 173
 174     const char* encode_next = encoded_source;
 175     int encode_avail_size = encoded_source_len;
 176
 177     int code = Filter::FILTER_OK;
 178     while (code != Filter::FILTER_DONE) {
 179       int encode_data_len;
 180       encode_data_len = std::min(encode_avail_size,
 181                                  filter->stream_buffer_size());
 182       memcpy(filter->stream_buffer()->data(), encode_next, encode_data_len);
 183       filter->FlushStreamBuffer(encode_data_len);
 184       encode_next += encode_data_len;
 185       encode_avail_size -= encode_data_len;
 186
 187       while (1) {
 188         int decode_data_len = std::min(decode_avail_size, output_buffer_size);
 189
 190         code = filter->ReadData(decode_next, &decode_data_len);
 191         decode_next += decode_data_len;
 192         decode_avail_size -= decode_data_len;
 193
 194         ASSERT_TRUE(code != Filter::FILTER_ERROR);
 195
 196         if (code == Filter::FILTER_NEED_MORE_DATA ||
 197             code == Filter::FILTER_DONE) {
 198           break;
 199         }
 200       }
 201     }
 202
 203     // Compare the decoding result with source data
 204     int decode_total_data_len = kDefaultBufferSize - decode_avail_size;
 205     EXPECT_TRUE(decode_total_data_len == source_len);
 206     EXPECT_EQ(memcmp(source, decode_buffer, source_len), 0);
 207   }
 208
 209   // Unsafe function to use filter to decode compressed data.
 210   // Parameters: Source and source_len are compressed data and its size.
 211   // Dest is the buffer for decoding results. Upon entry, *dest_len is the size
 212   // of the dest buffer. Upon exit, *dest_len is the number of chars written
 213   // into the buffer.
 214   int DecodeAllWithFilter(Filter* filter, const char* source, int source_len,
 215                           char* dest, int* dest_len) {
 216     memcpy(filter->stream_buffer()->data(), source, source_len);
 217     filter->FlushStreamBuffer(source_len);
 218     return filter->ReadData(dest, dest_len);
 219   }
 220
 221   void InitFilter(Filter::FilterType type) {
 222     std::vector<Filter::FilterType> filter_types;
 223     filter_types.push_back(type);
 224     filter_.reset(Filter::Factory(filter_types, filter_context_));
 225     ASSERT_TRUE(filter_.get());
 226     ASSERT_GE(filter_->stream_buffer_size(), kDefaultBufferSize);
 227   }
 228
 229   void InitFilterWithBufferSize(Filter::FilterType type, int buffer_size) {
 230     std::vector<Filter::FilterType> filter_types;
 231     filter_types.push_back(type);
 232     filter_.reset(Filter::FactoryForTests(filter_types, filter_context_,
 233                                           buffer_size));
 234     ASSERT_TRUE(filter_.get());
 235   }
 236
 237   const char* source_buffer() const { return source_buffer_.data(); }
 238   int source_len() const { return static_cast<int>(source_buffer_.size()); }
 239
 240   scoped_ptr<Filter> filter_;
 241
 242   std::string source_buffer_;
 243
 244   char* deflate_encode_buffer_;
 245   int deflate_encode_len_;
 246
 247   char* gzip_encode_buffer_;
 248   int gzip_encode_len_;
 249
 250  private:
 251   MockFilterContext filter_context_;
 252 };
 253
 254 // Basic scenario: decoding deflate data with big enough buffer.
 255 TEST_F(GZipUnitTest, DecodeDeflate) {
 256   // Decode the compressed data with filter
 257   InitFilter(Filter::FILTER_TYPE_DEFLATE);
 258   memcpy(filter_->stream_buffer()->data(), deflate_encode_buffer_,
 259          deflate_encode_len_);
 260   filter_->FlushStreamBuffer(deflate_encode_len_);
 261
 262   char deflate_decode_buffer[kDefaultBufferSize];
 263   int deflate_decode_size = kDefaultBufferSize;
 264   filter_->ReadData(deflate_decode_buffer, &deflate_decode_size);
 265
 266   // Compare the decoding result with source data
 267   EXPECT_TRUE(deflate_decode_size == source_len());
 268   EXPECT_EQ(memcmp(source_buffer(), deflate_decode_buffer, source_len()), 0);
 269 }
 270
 271 // Basic scenario: decoding gzip data with big enough buffer.
 272 TEST_F(GZipUnitTest, DecodeGZip) {
 273   // Decode the compressed data with filter
 274   InitFilter(Filter::FILTER_TYPE_GZIP);
 275   memcpy(filter_->stream_buffer()->data(), gzip_encode_buffer_,
 276          gzip_encode_len_);
 277   filter_->FlushStreamBuffer(gzip_encode_len_);
 278
 279   char gzip_decode_buffer[kDefaultBufferSize];
 280   int gzip_decode_size = kDefaultBufferSize;
 281   filter_->ReadData(gzip_decode_buffer, &gzip_decode_size);
 282
 283   // Compare the decoding result with source data
 284   EXPECT_TRUE(gzip_decode_size == source_len());
 285   EXPECT_EQ(memcmp(source_buffer(), gzip_decode_buffer, source_len()), 0);
 286 }
 287
 288 // Tests we can call filter repeatedly to get all the data decoded.
 289 // To do that, we create a filter with a small buffer that can not hold all
 290 // the input data.
 291 TEST_F(GZipUnitTest, DecodeWithSmallBuffer) {
 292   InitFilterWithBufferSize(Filter::FILTER_TYPE_DEFLATE, kSmallBufferSize);
 293   EXPECT_EQ(kSmallBufferSize, filter_->stream_buffer_size());
 294   DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
 295                              deflate_encode_buffer_, deflate_encode_len_,
 296                              kDefaultBufferSize);
 297 }
 298
 299 // Tests we can still decode with just 1 byte buffer in the filter.
 300 // The purpose of this tests are two: (1) Verify filter can parse partial GZip
 301 // header correctly. (2) Sometimes the filter will consume input without
 302 // generating output. Verify filter can handle it correctly.
 303 TEST_F(GZipUnitTest, DecodeWithOneByteBuffer) {
 304   InitFilterWithBufferSize(Filter::FILTER_TYPE_GZIP, 1);
 305   EXPECT_EQ(1, filter_->stream_buffer_size());
 306   DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
 307                              gzip_encode_buffer_, gzip_encode_len_,
 308                              kDefaultBufferSize);
 309 }
 310
 311 // Tests we can decode when caller has small buffer to read out from filter.
 312 TEST_F(GZipUnitTest, DecodeWithSmallOutputBuffer) {
 313   InitFilter(Filter::FILTER_TYPE_DEFLATE);
 314   DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
 315                              deflate_encode_buffer_, deflate_encode_len_,
 316                              kSmallBufferSize);
 317 }
 318
 319 // Tests we can still decode with just 1 byte buffer in the filter and just 1
 320 // byte buffer in the caller.
 321 TEST_F(GZipUnitTest, DecodeWithOneByteInputAndOutputBuffer) {
 322   InitFilterWithBufferSize(Filter::FILTER_TYPE_GZIP, 1);
 323   EXPECT_EQ(1, filter_->stream_buffer_size());
 324   DecodeAndCompareWithFilter(filter_.get(), source_buffer(), source_len(),
 325                              gzip_encode_buffer_, gzip_encode_len_, 1);
 326 }
 327
 328 // Decoding deflate stream with corrupted data.
 329 TEST_F(GZipUnitTest, DecodeCorruptedData) {
 330   char corrupt_data[kDefaultBufferSize];
 331   int corrupt_data_len = deflate_encode_len_;
 332   memcpy(corrupt_data, deflate_encode_buffer_, deflate_encode_len_);
 333
 334   int pos = corrupt_data_len / 2;
 335   corrupt_data[pos] = !corrupt_data[pos];
 336
 337   // Decode the corrupted data with filter
 338   InitFilter(Filter::FILTER_TYPE_DEFLATE);
 339   char corrupt_decode_buffer[kDefaultBufferSize];
 340   int corrupt_decode_size = kDefaultBufferSize;
 341
 342   int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len,
 343                                  corrupt_decode_buffer, &corrupt_decode_size);
 344
 345   // Expect failures
 346   EXPECT_TRUE(code == Filter::FILTER_ERROR);
 347 }
 348
 349 // Decoding deflate stream with missing data.
 350 TEST_F(GZipUnitTest, DecodeMissingData) {
 351   char corrupt_data[kDefaultBufferSize];
 352   int corrupt_data_len = deflate_encode_len_;
 353   memcpy(corrupt_data, deflate_encode_buffer_, deflate_encode_len_);
 354
 355   int pos = corrupt_data_len / 2;
 356   int len = corrupt_data_len - pos - 1;
 357   memmove(&corrupt_data[pos], &corrupt_data[pos+1], len);
 358   --corrupt_data_len;
 359
 360   // Decode the corrupted data with filter
 361   InitFilter(Filter::FILTER_TYPE_DEFLATE);
 362   char corrupt_decode_buffer[kDefaultBufferSize];
 363   int corrupt_decode_size = kDefaultBufferSize;
 364
 365   int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len,
 366                                  corrupt_decode_buffer, &corrupt_decode_size);
 367
 368   // Expect failures
 369   EXPECT_EQ(Filter::FILTER_ERROR, code);
 370 }
 371
 372 // Decoding gzip stream with corrupted header.
 373 TEST_F(GZipUnitTest, DecodeCorruptedHeader) {
 374   char corrupt_data[kDefaultBufferSize];
 375   int corrupt_data_len = gzip_encode_len_;
 376   memcpy(corrupt_data, gzip_encode_buffer_, gzip_encode_len_);
 377
 378   corrupt_data[2] = !corrupt_data[2];
 379
 380   // Decode the corrupted data with filter
 381   InitFilter(Filter::FILTER_TYPE_GZIP);
 382   char corrupt_decode_buffer[kDefaultBufferSize];
 383   int corrupt_decode_size = kDefaultBufferSize;
 384
 385   int code = DecodeAllWithFilter(filter_.get(), corrupt_data, corrupt_data_len,
 386                                  corrupt_decode_buffer, &corrupt_decode_size);
 387
 388   // Expect failures
 389   EXPECT_TRUE(code == Filter::FILTER_ERROR);
 390 }
 391
 392 }  // namespace net