remoting/protocol/buffered_socket_writer_unittest.cc

   1 // Copyright (c) 2012 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 "remoting/protocol/buffered_socket_writer.h"
   6
   7 #include <stdlib.h>
   8
   9 #include "base/bind.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "net/base/io_buffer.h"
  12 #include "net/base/net_errors.h"
  13 #include "remoting/protocol/fake_session.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace remoting {
  18 namespace protocol {
  19
  20 namespace {
  21 const int kTestBufferSize = 10 * 1024; // 10k;
  22 const size_t kWriteChunkSize = 1024U;
  23 }  // namespace
  24
  25 class BufferedSocketWriterTest : public testing::Test {
  26  public:
  27   BufferedSocketWriterTest()
  28       : write_error_(0) {
  29   }
  30
  31   void OnDone() {
  32     base::MessageLoop::current()->PostTask(FROM_HERE,
  33                                            base::MessageLoop::QuitClosure());
  34   }
  35
  36   void DestroyWriterAndQuit() {
  37     written_data_ = socket_->written_data();
  38     writer_.reset();
  39     socket_.reset();
  40     base::MessageLoop::current()->PostTask(FROM_HERE,
  41                                            base::MessageLoop::QuitClosure());
  42   }
  43
  44   void Unexpected() {
  45     EXPECT_TRUE(false);
  46   }
  47
  48  protected:
  49   virtual void SetUp() OVERRIDE {
  50     socket_.reset(new FakeSocket());
  51     writer_.reset(new BufferedSocketWriter());
  52     writer_->Init(socket_.get(), base::Bind(
  53         &BufferedSocketWriterTest::OnWriteFailed, base::Unretained(this)));
  54     test_buffer_ = new net::IOBufferWithSize(kTestBufferSize);
  55     test_buffer_2_ = new net::IOBufferWithSize(kTestBufferSize);
  56     for (int i = 0; i< kTestBufferSize; ++i) {
  57       test_buffer_->data()[i] = rand() % 256;
  58       test_buffer_2_->data()[i] = rand() % 256;
  59     }
  60   }
  61
  62   void OnWriteFailed(int error) {
  63     write_error_ = error;
  64   }
  65
  66   void TestWrite() {
  67     writer_->Write(test_buffer_, base::Bind(&BufferedSocketWriterTest::OnDone,
  68                                             base::Unretained(this)));
  69     writer_->Write(test_buffer_2_, base::Bind(&BufferedSocketWriterTest::OnDone,
  70                                               base::Unretained(this)));
  71     message_loop_.Run();
  72     ASSERT_EQ(static_cast<size_t>(test_buffer_->size() +
  73                                   test_buffer_2_->size()),
  74               socket_->written_data().size());
  75     EXPECT_EQ(0, memcmp(test_buffer_->data(), socket_->written_data().data(),
  76                         test_buffer_->size()));
  77     EXPECT_EQ(0, memcmp(test_buffer_2_->data(),
  78                         socket_->written_data().data() + test_buffer_->size(),
  79                         test_buffer_2_->size()));
  80   }
  81
  82   void TestAppendInCallback() {
  83     writer_->Write(test_buffer_, base::Bind(
  84         base::IgnoreResult(&BufferedSocketWriterBase::Write),
  85         base::Unretained(writer_.get()), test_buffer_2_,
  86         base::Bind(&BufferedSocketWriterTest::OnDone,
  87                   base::Unretained(this))));
  88     message_loop_.Run();
  89     ASSERT_EQ(static_cast<size_t>(test_buffer_->size() +
  90                                   test_buffer_2_->size()),
  91               socket_->written_data().size());
  92     EXPECT_EQ(0, memcmp(test_buffer_->data(), socket_->written_data().data(),
  93                         test_buffer_->size()));
  94     EXPECT_EQ(0, memcmp(test_buffer_2_->data(),
  95                         socket_->written_data().data() + test_buffer_->size(),
  96                         test_buffer_2_->size()));
  97   }
  98
  99   base::MessageLoop message_loop_;
 100   scoped_ptr<FakeSocket> socket_;
 101   scoped_ptr<BufferedSocketWriter> writer_;
 102   scoped_refptr<net::IOBufferWithSize> test_buffer_;
 103   scoped_refptr<net::IOBufferWithSize> test_buffer_2_;
 104   std::string written_data_;
 105   int write_error_;
 106 };
 107
 108 // Test synchronous write.
 109 TEST_F(BufferedSocketWriterTest, WriteFull) {
 110   TestWrite();
 111 }
 112
 113 // Test synchronous write in 1k chunks.
 114 TEST_F(BufferedSocketWriterTest, WriteChunks) {
 115   socket_->set_write_limit(kWriteChunkSize);
 116   TestWrite();
 117 }
 118
 119 // Test asynchronous write.
 120 TEST_F(BufferedSocketWriterTest, WriteAsync) {
 121   socket_->set_async_write(true);
 122   socket_->set_write_limit(kWriteChunkSize);
 123   TestWrite();
 124 }
 125
 126 // Make sure we can call Write() from the done callback.
 127 TEST_F(BufferedSocketWriterTest, AppendInCallbackSync) {
 128   TestAppendInCallback();
 129 }
 130
 131 // Make sure we can call Write() from the done callback.
 132 TEST_F(BufferedSocketWriterTest, AppendInCallbackAsync) {
 133   socket_->set_async_write(true);
 134   socket_->set_write_limit(kWriteChunkSize);
 135   TestAppendInCallback();
 136 }
 137
 138 // Test that the writer can be destroyed from callback.
 139 TEST_F(BufferedSocketWriterTest, DestroyFromCallback) {
 140   socket_->set_async_write(true);
 141   writer_->Write(test_buffer_, base::Bind(
 142       &BufferedSocketWriterTest::DestroyWriterAndQuit,
 143       base::Unretained(this)));
 144   writer_->Write(test_buffer_2_, base::Bind(
 145       &BufferedSocketWriterTest::Unexpected,
 146       base::Unretained(this)));
 147   socket_->set_async_write(false);
 148   message_loop_.Run();
 149   ASSERT_GE(written_data_.size(),
 150             static_cast<size_t>(test_buffer_->size()));
 151   EXPECT_EQ(0, memcmp(test_buffer_->data(), written_data_.data(),
 152                       test_buffer_->size()));
 153 }
 154
 155 // Verify that it stops writing after the first error.
 156 TEST_F(BufferedSocketWriterTest, TestWriteErrorSync) {
 157   socket_->set_write_limit(kWriteChunkSize);
 158   writer_->Write(test_buffer_, base::Closure());
 159   socket_->set_async_write(true);
 160   writer_->Write(test_buffer_2_,
 161                  base::Bind(&BufferedSocketWriterTest::Unexpected,
 162                             base::Unretained(this)));
 163   socket_->set_next_write_error(net::ERR_FAILED);
 164   socket_->set_async_write(false);
 165   message_loop_.RunUntilIdle();
 166   EXPECT_EQ(net::ERR_FAILED, write_error_);
 167   EXPECT_EQ(static_cast<size_t>(test_buffer_->size()),
 168             socket_->written_data().size());
 169 }
 170
 171 // Verify that it stops writing after the first error.
 172 TEST_F(BufferedSocketWriterTest, TestWriteErrorAsync) {
 173   socket_->set_write_limit(kWriteChunkSize);
 174   writer_->Write(test_buffer_, base::Closure());
 175   socket_->set_async_write(true);
 176   writer_->Write(test_buffer_2_,
 177                  base::Bind(&BufferedSocketWriterTest::Unexpected,
 178                             base::Unretained(this)));
 179   socket_->set_next_write_error(net::ERR_FAILED);
 180   message_loop_.RunUntilIdle();
 181   EXPECT_EQ(net::ERR_FAILED, write_error_);
 182   EXPECT_EQ(static_cast<size_t>(test_buffer_->size()),
 183             socket_->written_data().size());
 184 }
 185
 186 }  // namespace protocol
 187 }  // namespace remoting
 188