net/socket/buffered_write_stream_socket_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 "net/socket/buffered_write_stream_socket.h"
   6
   7 #include "base/memory/ref_counted.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "net/base/net_errors.h"
  11 #include "net/base/net_log.h"
  12 #include "net/socket/socket_test_util.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace net {
  16
  17 namespace {
  18
  19 class BufferedWriteStreamSocketTest : public testing::Test {
  20  public:
  21   void Finish() {
  22     base::MessageLoop::current()->RunUntilIdle();
  23     EXPECT_TRUE(data_->at_read_eof());
  24     EXPECT_TRUE(data_->at_write_eof());
  25   }
  26
  27   void Initialize(MockWrite* writes, size_t writes_count) {
  28     data_.reset(new DeterministicSocketData(NULL, 0, writes, writes_count));
  29     data_->set_connect_data(MockConnect(SYNCHRONOUS, 0));
  30     if (writes_count) {
  31       data_->StopAfter(writes_count);
  32     }
  33     DeterministicMockTCPClientSocket* wrapped_socket =
  34         new DeterministicMockTCPClientSocket(net_log_.net_log(), data_.get());
  35     data_->set_delegate(wrapped_socket->AsWeakPtr());
  36     socket_.reset(new BufferedWriteStreamSocket(wrapped_socket));
  37     socket_->Connect(callback_.callback());
  38   }
  39
  40   void TestWrite(const char* text) {
  41     scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(text));
  42     EXPECT_EQ(buf->size(),
  43               socket_->Write(buf.get(), buf->size(), callback_.callback()));
  44   }
  45
  46   scoped_ptr<BufferedWriteStreamSocket> socket_;
  47   scoped_ptr<DeterministicSocketData> data_;
  48   BoundNetLog net_log_;
  49   TestCompletionCallback callback_;
  50 };
  51
  52 TEST_F(BufferedWriteStreamSocketTest, SingleWrite) {
  53   MockWrite writes[] = {
  54     MockWrite(SYNCHRONOUS, 0, "abc"),
  55   };
  56   Initialize(writes, arraysize(writes));
  57   TestWrite("abc");
  58   Finish();
  59 }
  60
  61 TEST_F(BufferedWriteStreamSocketTest, AsyncWrite) {
  62   MockWrite writes[] = {
  63     MockWrite(ASYNC, 0, "abc"),
  64   };
  65   Initialize(writes, arraysize(writes));
  66   TestWrite("abc");
  67   data_->Run();
  68   Finish();
  69 }
  70
  71 TEST_F(BufferedWriteStreamSocketTest, TwoWritesIntoOne) {
  72   MockWrite writes[] = {
  73     MockWrite(SYNCHRONOUS, 0, "abcdef"),
  74   };
  75   Initialize(writes, arraysize(writes));
  76   TestWrite("abc");
  77   TestWrite("def");
  78   Finish();
  79 }
  80
  81 TEST_F(BufferedWriteStreamSocketTest, WriteWhileBlocked) {
  82   MockWrite writes[] = {
  83     MockWrite(ASYNC, 0, "abc"),
  84     MockWrite(ASYNC, 1, "def"),
  85     MockWrite(ASYNC, 2, "ghi"),
  86   };
  87   Initialize(writes, arraysize(writes));
  88   TestWrite("abc");
  89   base::MessageLoop::current()->RunUntilIdle();
  90   TestWrite("def");
  91   data_->RunFor(1);
  92   TestWrite("ghi");
  93   data_->RunFor(1);
  94   Finish();
  95 }
  96
  97 TEST_F(BufferedWriteStreamSocketTest, ContinuesPartialWrite) {
  98   MockWrite writes[] = {
  99     MockWrite(ASYNC, 0, "abc"),
 100     MockWrite(ASYNC, 1, "def"),
 101   };
 102   Initialize(writes, arraysize(writes));
 103   TestWrite("abcdef");
 104   data_->Run();
 105   Finish();
 106 }
 107
 108 TEST_F(BufferedWriteStreamSocketTest, TwoSeparateWrites) {
 109   MockWrite writes[] = {
 110     MockWrite(ASYNC, 0, "abc"),
 111     MockWrite(ASYNC, 1, "def"),
 112   };
 113   Initialize(writes, arraysize(writes));
 114   TestWrite("abc");
 115   data_->RunFor(1);
 116   TestWrite("def");
 117   data_->RunFor(1);
 118   Finish();
 119 }
 120
 121 }  // anonymous namespace
 122
 123 }  // namespace net