Add unittests for BufferedSocketWriter and fix some bugs in that code.

remoting/protocol/buffered_socket_writer_unittest.cc

+// Copyright (c) 2012 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 "remoting/protocol/buffered_socket_writer.h"
+
+#include "base/bind.h"
+#include "base/message_loop.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "remoting/protocol/fake_session.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace remoting {
+namespace protocol {
+
+namespace {
+const int kTestBufferSize = 10 * 1024; // 10k;
+const size_t kWriteChunkSize = 1024U;
+}  // namespace
+
+class BufferedSocketWriterTest : public testing::Test {
+ public:
+  BufferedSocketWriterTest()
+      : write_error_(0) {
+

[simonmorris, 2012/07/31 20:19:50]

Remove blank line.

[Sergey Ulanov, 2012/07/31 21:37:53]

Done.

+  }
+
+  void OnDone() {
+    MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+  }
+
+  void DestroyWriterAndQuit() {
+    written_data_ = socket_->written_data();
+    writer_.reset();
+    socket_.reset();
+    MessageLoop::current()->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+  }
+
+  void Unexpected() {
+    EXPECT_TRUE(false);
+  }
+
+ protected:
+  void SetUp() OVERRIDE {
+    socket_.reset(new FakeSocket());
+    writer_.reset(new BufferedSocketWriter());
+    writer_->Init(socket_.get(), base::Bind(
+        &BufferedSocketWriterTest::OnWriteFailed, base::Unretained(this)));
+    test_buffer_ = new net::IOBufferWithSize(kTestBufferSize);
+    test_buffer_2_ = new net::IOBufferWithSize(kTestBufferSize);
+  }
+
+  void OnWriteFailed(int error) {
+    write_error_ = error;
+  }
+
+  void TestWrite() {
+    writer_->Write(test_buffer_, base::Bind(&BufferedSocketWriterTest::OnDone,
+                                            base::Unretained(this)));
+    writer_->Write(test_buffer_2_, base::Bind(&BufferedSocketWriterTest::OnDone,
+                                              base::Unretained(this)));
+    message_loop_.Run();
+    ASSERT_EQ(static_cast<size_t>(test_buffer_->size() +
+                                  test_buffer_2_->size()),
+              socket_->written_data().size());
+    EXPECT_EQ(0, memcmp(test_buffer_->data(), socket_->written_data().data(),
+                        test_buffer_->size()));
+    EXPECT_EQ(0, memcmp(test_buffer_2_->data(),
+                        socket_->written_data().data() + test_buffer_->size(),
+                        test_buffer_2_->size()));
+  }
+
+  void TestAppendInCallback() {
+    writer_->Write(test_buffer_, base::Bind(
+        base::IgnoreResult(&BufferedSocketWriterBase::Write),
+        base::Unretained(writer_.get()), test_buffer_2_,
+        base::Bind(&BufferedSocketWriterTest::OnDone,
+                  base::Unretained(this))));
+    message_loop_.Run();
+    ASSERT_EQ(static_cast<size_t>(test_buffer_->size() +
+                                  test_buffer_2_->size()),
+              socket_->written_data().size());
+    EXPECT_EQ(0, memcmp(test_buffer_->data(), socket_->written_data().data(),
+                        test_buffer_->size()));
+    EXPECT_EQ(0, memcmp(test_buffer_2_->data(),
+                        socket_->written_data().data() + test_buffer_->size(),
+                        test_buffer_2_->size()));
+  }
+
+  MessageLoop message_loop_;
+  scoped_ptr<FakeSocket> socket_;
+  scoped_ptr<BufferedSocketWriter> writer_;
+  scoped_refptr<net::IOBufferWithSize> test_buffer_;
+  scoped_refptr<net::IOBufferWithSize> test_buffer_2_;
+  std::string written_data_;
+  int write_error_;
+};
+
+// Test synchronous write.
+TEST_F(BufferedSocketWriterTest, WriteFull) {
+  TestWrite();
+}
+
+// Test synchronous write in 1k chunks.
+TEST_F(BufferedSocketWriterTest, WriteChunks) {
+  socket_->set_write_limit(kWriteChunkSize);
+  TestWrite();
+}
+
+// Test asynchronous write.
+TEST_F(BufferedSocketWriterTest, WriteAsync) {
+  socket_->set_async_write(true);
+  socket_->set_write_limit(kWriteChunkSize);
+  TestWrite();
+}
+
+// Make sure we can call Write() from the done callback.
+TEST_F(BufferedSocketWriterTest, AppendInCallbackSync) {
+  TestAppendInCallback();
+}
+
+// Make sure we can call Write() from the done callback.
+TEST_F(BufferedSocketWriterTest, AppendInCallbackAsync) {
+  socket_->set_async_write(true);
+  socket_->set_write_limit(kWriteChunkSize);
+  TestAppendInCallback();
+}
+
+// Test that the writer can be destroyed from callback.
+TEST_F(BufferedSocketWriterTest, DestroyFromCallback) {
+  socket_->set_async_write(true);
+  writer_->Write(test_buffer_, base::Bind(
+      &BufferedSocketWriterTest::DestroyWriterAndQuit,
+      base::Unretained(this)));
+  writer_->Write(test_buffer_2_, base::Bind(
+      &BufferedSocketWriterTest::Unexpected,
+      base::Unretained(this)));
+  socket_->set_async_write(false);
+  message_loop_.Run();
+  ASSERT_GE(written_data_.size(),
+            static_cast<size_t>(test_buffer_->size()));
+  EXPECT_EQ(0, memcmp(test_buffer_->data(), written_data_.data(),
+                      test_buffer_->size()));
+}
+
+// Verify that it stops writing after the first error.
+TEST_F(BufferedSocketWriterTest, TestWriteError) {
+  socket_->set_write_limit(kWriteChunkSize);
+  socket_->set_async_write(true);
+  writer_->Write(test_buffer_,
+                 base::Bind(&BufferedSocketWriterTest::Unexpected,
+                            base::Unretained(this)));
+  writer_->Write(test_buffer_2_,
+                 base::Bind(&BufferedSocketWriterTest::Unexpected,
+                            base::Unretained(this)));
+  socket_->set_next_write_error(net::ERR_FAILED);
+  message_loop_.RunAllPending();
+  EXPECT_EQ(net::ERR_FAILED, write_error_);
+  EXPECT_EQ(kWriteChunkSize, socket_->written_data().size());
+}
+
+}  // namespace protocol
+}  // namespace remoting
+