Fix division by zero. Test filter with empty output.

net/filter/brotli_filter_unittest.cc

 // 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 "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "net/base/io_buffer.h"
 #include "net/filter/brotli_filter.h"
 #include "net/filter/mock_filter_context.h"
@@ skipping 139 matching lines @@
   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);
+  filter_.reset(nullptr);

[cbentzel, 2016/01/21 10:42:59]

Why is this needed? Shouldn't the scoped_ptr be going out of scope when the test
destroys?

[eustas, 2016/01/21 10:49:14]

It is for making destruction an explicit part of test. Of course this could be
easily removed, but in the case of problems stack trace will look a little bit
weird.

 }
 
 // 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);
+  filter_.reset(nullptr);
 }
 
 // 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);
+  filter_.reset(nullptr);
 }
 
 // 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);
+  filter_.reset(nullptr);
 }
 
 // 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);
+  filter_.reset(nullptr);
 }
 
-// Decoding deflate stream with corrupted data.
+// Decoding brotli 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
+  // 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 failures.
   EXPECT_EQ(Filter::FILTER_ERROR, code);
+  filter_.reset(nullptr);
 }
 
-// Decoding deflate stream with missing data.
+// Decoding brotli 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
+  // 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 failures.
   EXPECT_EQ(Filter::FILTER_ERROR, code);
+  filter_.reset(nullptr);
+}
+
+// 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);
+  filter_.reset(nullptr);
 }
 
 }  // namespace net