Blimp: add packet-level DEFLATE compression using zlib.

blimp/net/stream_packet_reader_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 <stddef.h>
 #include <string>
 
 #include "base/message_loop/message_loop.h"
 #include "base/sys_byteorder.h"
 #include "blimp/net/common.h"
@@ skipping 11 matching lines @@
 using testing::DoAll;
 using testing::Mock;
 using testing::NotNull;
 using testing::Return;
 using testing::SaveArg;
 using testing::WithArg;
 
 namespace blimp {
 namespace {
 
-const size_t kTestMaxBufferSize = 1 << 16;  // 64KB
-
 class StreamPacketReaderTest : public testing::Test {
  public:
   StreamPacketReaderTest()
       : buffer_(new net::GrowableIOBuffer),
         test_msg_("U WOT M8"),
-        data_reader_(&socket_) {
-    buffer_->SetCapacity(kTestMaxBufferSize);
-  }
+        data_reader_(&socket_) {}
 
   ~StreamPacketReaderTest() override {}
 
   void ReadPacket() { data_reader_.ReadPacket(buffer_, callback_.callback()); }
 
  protected:
   base::MessageLoop message_loop_;
   scoped_refptr<net::GrowableIOBuffer> buffer_;
   std::string test_msg_;
   net::TestCompletionCallback callback_;
   testing::StrictMock<MockStreamSocket> socket_;
   testing::InSequence sequence_;
   StreamPacketReader data_reader_;
 };
 
 // Successful read with 1 async header read and 1 async payload read.
 TEST_F(StreamPacketReaderTest, ReadAsyncHeaderAsyncPayload) {
   net::CompletionCallback socket_cb;
 
   EXPECT_CALL(socket_, Read(NotNull(), kPacketHeaderSizeBytes, _))
       .WillOnce(DoAll(FillBufferFromString<0>(EncodeHeader(test_msg_.size())),
                       SaveArg<2>(&socket_cb), Return(net::ERR_IO_PENDING)));
   EXPECT_CALL(socket_, Read(NotNull(), test_msg_.size(), _))
       .WillOnce(DoAll(FillBufferFromString<0>(test_msg_),
                       SaveArg<2>(&socket_cb), Return(net::ERR_IO_PENDING)));
 
   ReadPacket();
   socket_cb.Run(kPacketHeaderSizeBytes);
   socket_cb.Run(test_msg_.size());
-  EXPECT_EQ(static_cast<int>(test_msg_.size()), callback_.WaitForResult());
-  EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg_));
+  ASSERT_EQ(static_cast<int>(test_msg_.size()), callback_.WaitForResult());
+  EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg_.size(), test_msg_));
 }
 
 // Successful read with 1 async header read and 1 sync payload read.
 TEST_F(StreamPacketReaderTest, ReadAsyncHeaderSyncPayload) {
   net::CompletionCallback socket_cb;
 
   // Asynchronous payload read expectation.
   EXPECT_CALL(socket_, Read(NotNull(), kPacketHeaderSizeBytes, _))
       .WillOnce(DoAll(FillBufferFromString<0>(EncodeHeader(test_msg_.size())),
                       SaveArg<2>(&socket_cb), Return(net::ERR_IO_PENDING)));
 
   // Synchronous payload read expectation. Fills the buffer and returns
   // immediately.
   EXPECT_CALL(socket_, Read(NotNull(), test_msg_.size(), _))
       .WillOnce(
           DoAll(FillBufferFromString<0>(test_msg_), Return(test_msg_.size())));
 
   ReadPacket();
   EXPECT_FALSE(callback_.have_result());
 
   socket_cb.Run(kPacketHeaderSizeBytes);
-  EXPECT_EQ(static_cast<int>(test_msg_.size()), callback_.WaitForResult());
-  EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg_));
+  ASSERT_EQ(static_cast<int>(test_msg_.size()), callback_.WaitForResult());
+  EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg_.size(), test_msg_));
 }
 
 // Successful read with 1 sync header read and 1 async payload read.
 TEST_F(StreamPacketReaderTest, ReadSyncHeaderAsyncPayload) {
   net::CompletionCallback socket_cb;
 
   EXPECT_CALL(socket_, Read(NotNull(), kPacketHeaderSizeBytes, _))
       .WillOnce(DoAll(FillBufferFromString<0>(EncodeHeader(test_msg_.size())),
                       Return(kPacketHeaderSizeBytes)));
   EXPECT_CALL(socket_, Read(NotNull(), test_msg_.size(), _))
       .WillOnce(DoAll(FillBufferFromString<0>(test_msg_),
                       SaveArg<2>(&socket_cb), Return(net::ERR_IO_PENDING)));
 
   ReadPacket();
   socket_cb.Run(test_msg_.size());
-  EXPECT_EQ(static_cast<int>(test_msg_.size()), callback_.WaitForResult());
-  EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg_));
+  ASSERT_EQ(static_cast<int>(test_msg_.size()), callback_.WaitForResult());
+  EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg_.size(), test_msg_));
 }
 
 // Successful read with 1 sync header read and 1 sync payload read.
 TEST_F(StreamPacketReaderTest, ReadSyncHeaderSyncPayload) {
   net::CompletionCallback socket_cb;
 
   EXPECT_CALL(socket_, Read(NotNull(), kPacketHeaderSizeBytes, _))
       .WillOnce(DoAll(FillBufferFromString<0>(EncodeHeader(test_msg_.size())),
                       Return(kPacketHeaderSizeBytes)));
   EXPECT_CALL(socket_, Read(NotNull(), test_msg_.size(), _))
       .WillOnce(
           DoAll(FillBufferFromString<0>(test_msg_), Return(test_msg_.size())));
 
   ReadPacket();
-  EXPECT_EQ(static_cast<int>(test_msg_.size()), callback_.WaitForResult());
-  EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg_));
+  ASSERT_EQ(static_cast<int>(test_msg_.size()), callback_.WaitForResult());
+  EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg_.size(), test_msg_));
 }
 
 // Successful read of 2 messages, header and payload reads all completing
 // synchronously with no partial results.
 TEST_F(StreamPacketReaderTest, ReadMultipleMessagesSync) {
   net::CompletionCallback socket_cb;
   std::string test_msg2 = test_msg_ + "SlightlyLongerString";
 
   // Read the first message's header synchronously.
   EXPECT_CALL(socket_, Read(NotNull(), kPacketHeaderSizeBytes, _))
@@ skipping 13 matching lines @@
                       Return(kPacketHeaderSizeBytes)))
       .RetiresOnSaturation();
 
   // Read the second message's payload synchronously.
   EXPECT_CALL(socket_, Read(NotNull(), test_msg2.size(), _))
       .WillOnce(
           DoAll(FillBufferFromString<0>(test_msg2), Return(test_msg2.size())))
       .RetiresOnSaturation();
 
   ReadPacket();
-  EXPECT_EQ(static_cast<int>(test_msg_.size()), callback_.WaitForResult());
+  ASSERT_EQ(static_cast<int>(test_msg_.size()), callback_.WaitForResult());
 
   ReadPacket();
-  EXPECT_EQ(static_cast<int>(test_msg2.size()), callback_.WaitForResult());
+  ASSERT_EQ(static_cast<int>(test_msg2.size()), callback_.WaitForResult());
 
-  EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg_));
+  EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg2.size(), test_msg2));
   EXPECT_FALSE(callback_.have_result());
 }
 
 // Successful read of 2 messages, header and payload reads all completing
 // asynchronously with no partial results.
 TEST_F(StreamPacketReaderTest, ReadMultipleMessagesAsync) {
   net::TestCompletionCallback read_cb1;
   net::TestCompletionCallback read_cb2;
   net::CompletionCallback socket_cb;
 
@@ skipping 17 matching lines @@
 
   // Read a payload asynchronously.
   EXPECT_CALL(socket_, Read(NotNull(), test_msg_.size(), _))
       .WillOnce(DoAll(FillBufferFromString<0>(test_msg_),
                       SaveArg<2>(&socket_cb), Return(net::ERR_IO_PENDING)))
       .RetiresOnSaturation();
 
   data_reader_.ReadPacket(buffer_, read_cb1.callback());
   socket_cb.Run(kPacketHeaderSizeBytes);
   socket_cb.Run(test_msg_.size());
-  EXPECT_EQ(static_cast<int>(test_msg_.size()), read_cb1.WaitForResult());
+  ASSERT_EQ(static_cast<int>(test_msg_.size()), read_cb1.WaitForResult());
 
   data_reader_.ReadPacket(buffer_, read_cb2.callback());
   socket_cb.Run(kPacketHeaderSizeBytes);
   socket_cb.Run(test_msg_.size());
-  EXPECT_EQ(static_cast<int>(test_msg_.size()), read_cb2.WaitForResult());
-  EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg_));
+  ASSERT_EQ(static_cast<int>(test_msg_.size()), read_cb2.WaitForResult());
+  EXPECT_TRUE(BufferStartsWith(buffer_.get(), test_msg_.size(), test_msg_));
 }
 
 // Verify that partial header reads are supported.
 // Read #0: 1 header byte is read.
 // Read #1: Remainder of header bytes read.
 TEST_F(StreamPacketReaderTest, PartialHeaderReadAsync) {
   net::CompletionCallback cb;
   std::string header = EncodeHeader(test_msg_.size());
 
   // The first byte is received (sliced via substr()).
@@ skipping 130 matching lines @@
                       Return(kPacketHeaderSizeBytes)))
       .RetiresOnSaturation();
 
   ReadPacket();
   EXPECT_EQ(net::ERR_INVALID_RESPONSE, callback_.WaitForResult());
 }
 
 // Verify that an illegally large payloads is reported as an erroneous inputs.
 TEST_F(StreamPacketReaderTest, ReadErrorIllegallyLargePayload) {
   EXPECT_CALL(socket_, Read(NotNull(), kPacketHeaderSizeBytes, _))
-      .WillOnce(
-          DoAll(FillBufferFromString<0>(EncodeHeader(kTestMaxBufferSize + 1)),
-                Return(kPacketHeaderSizeBytes)));
+      .WillOnce(DoAll(
+          FillBufferFromString<0>(EncodeHeader(kMaxPacketPayloadSizeBytes + 1)),
+          Return(kPacketHeaderSizeBytes)));
 
   ReadPacket();
   EXPECT_EQ(net::ERR_INVALID_RESPONSE, callback_.WaitForResult());
 }
 
 }  // namespace
 
 }  // namespace blimp