src/base/async_socket_io_handler_unittest.cc

   1 // Copyright 2013 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 "base/async_socket_io_handler.h"
   6
   7 #include "base/bind.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace {
  11 const char kAsyncSocketIoTestString[] = "Hello, AsyncSocketIoHandler";
  12 const size_t kAsyncSocketIoTestStringLength =
  13     arraysize(kAsyncSocketIoTestString);
  14
  15 class TestSocketReader {
  16  public:
  17   // Set |number_of_reads_before_quit| to >0 when you expect a specific number
  18   // of Read operations to complete.  Once that number is reached, the current
  19   // message loop will be Quit().  Set |number_of_reads_before_quit| to -1 if
  20   // callbacks should not be counted.
  21   TestSocketReader(base::CancelableSyncSocket* socket,
  22                    int number_of_reads_before_quit,
  23                    bool issue_reads_from_callback,
  24                    bool expect_eof)
  25       : socket_(socket), buffer_(),
  26         number_of_reads_before_quit_(number_of_reads_before_quit),
  27         callbacks_received_(0),
  28         issue_reads_from_callback_(issue_reads_from_callback),
  29         expect_eof_(expect_eof) {
  30     io_handler.Initialize(socket_->handle(),
  31                           base::Bind(&TestSocketReader::OnRead,
  32                                      base::Unretained(this)));
  33   }
  34   ~TestSocketReader() {}
  35
  36   bool IssueRead() {
  37     return io_handler.Read(&buffer_[0], sizeof(buffer_));
  38   }
  39
  40   const char* buffer() const { return &buffer_[0]; }
  41
  42   int callbacks_received() const { return callbacks_received_; }
  43
  44  private:
  45   void OnRead(int bytes_read) {
  46     if (!expect_eof_) {
  47       EXPECT_GT(bytes_read, 0);
  48     } else {
  49       EXPECT_GE(bytes_read, 0);
  50     }
  51     ++callbacks_received_;
  52     if (number_of_reads_before_quit_ == callbacks_received_) {
  53       base::MessageLoop::current()->Quit();
  54     } else if (issue_reads_from_callback_) {
  55       IssueRead();
  56     }
  57   }
  58
  59   base::AsyncSocketIoHandler io_handler;
  60   base::CancelableSyncSocket* socket_;  // Ownership lies outside the class.
  61   char buffer_[kAsyncSocketIoTestStringLength];
  62   int number_of_reads_before_quit_;
  63   int callbacks_received_;
  64   bool issue_reads_from_callback_;
  65   bool expect_eof_;
  66 };
  67
  68 // Workaround to be able to use a base::Closure for sending data.
  69 // Send() returns int but a closure must return void.
  70 void SendData(base::CancelableSyncSocket* socket,
  71               const void* buffer,
  72               size_t length) {
  73   socket->Send(buffer, length);
  74 }
  75
  76 }  // end namespace.
  77
  78 // Tests doing a pending read from a socket and use an IO handler to get
  79 // notified of data.
  80 TEST(AsyncSocketIoHandlerTest, AsynchronousReadWithMessageLoop) {
  81   base::MessageLoopForIO loop;
  82
  83   base::CancelableSyncSocket pair[2];
  84   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));
  85
  86   TestSocketReader reader(&pair[0], 1, false, false);
  87   EXPECT_TRUE(reader.IssueRead());
  88
  89   pair[1].Send(kAsyncSocketIoTestString, kAsyncSocketIoTestStringLength);
  90   base::MessageLoop::current()->Run();
  91   EXPECT_EQ(strcmp(reader.buffer(), kAsyncSocketIoTestString), 0);
  92   EXPECT_EQ(1, reader.callbacks_received());
  93 }
  94
  95 // Tests doing a read from a socket when we know that there is data in the
  96 // socket.  Here we want to make sure that any async 'can read' notifications
  97 // won't trip us off and that the synchronous case works as well.
  98 TEST(AsyncSocketIoHandlerTest, SynchronousReadWithMessageLoop) {
  99   base::MessageLoopForIO loop;
 100
 101   base::CancelableSyncSocket pair[2];
 102   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));
 103
 104   TestSocketReader reader(&pair[0], -1, false, false);
 105
 106   pair[1].Send(kAsyncSocketIoTestString, kAsyncSocketIoTestStringLength);
 107   base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
 108       base::MessageLoop::QuitClosure(),
 109       base::TimeDelta::FromMilliseconds(100));
 110   base::MessageLoop::current()->Run();
 111
 112   EXPECT_TRUE(reader.IssueRead());
 113   EXPECT_EQ(strcmp(reader.buffer(), kAsyncSocketIoTestString), 0);
 114   // We've now verified that the read happened synchronously, but it's not
 115   // guaranteed that the callback has been issued since the callback will be
 116   // called asynchronously even though the read may have been done.
 117   // So we call RunUntilIdle() to allow any event notifications or APC's on
 118   // Windows, to execute before checking the count of how many callbacks we've
 119   // received.
 120   base::MessageLoop::current()->RunUntilIdle();
 121   EXPECT_EQ(1, reader.callbacks_received());
 122 }
 123
 124 // Calls Read() from within a callback to test that simple read "loops" work.
 125 TEST(AsyncSocketIoHandlerTest, ReadFromCallback) {
 126   base::MessageLoopForIO loop;
 127
 128   base::CancelableSyncSocket pair[2];
 129   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));
 130
 131   const int kReadOperationCount = 10;
 132   TestSocketReader reader(&pair[0], kReadOperationCount, true, false);
 133   EXPECT_TRUE(reader.IssueRead());
 134
 135   // Issue sends on an interval to satisfy the Read() requirements.
 136   int64 milliseconds = 0;
 137   for (int i = 0; i < kReadOperationCount; ++i) {
 138     base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
 139         base::Bind(&SendData, &pair[1], kAsyncSocketIoTestString,
 140             kAsyncSocketIoTestStringLength),
 141         base::TimeDelta::FromMilliseconds(milliseconds));
 142     milliseconds += 10;
 143   }
 144
 145   base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
 146       base::MessageLoop::QuitClosure(),
 147       base::TimeDelta::FromMilliseconds(100 + milliseconds));
 148
 149   base::MessageLoop::current()->Run();
 150   EXPECT_EQ(kReadOperationCount, reader.callbacks_received());
 151 }
 152
 153 // Calls Read() then close other end, check that a correct callback is received.
 154 TEST(AsyncSocketIoHandlerTest, ReadThenClose) {
 155   base::MessageLoopForIO loop;
 156
 157   base::CancelableSyncSocket pair[2];
 158   ASSERT_TRUE(base::CancelableSyncSocket::CreatePair(&pair[0], &pair[1]));
 159
 160   const int kReadOperationCount = 1;
 161   TestSocketReader reader(&pair[0], kReadOperationCount, false, true);
 162   EXPECT_TRUE(reader.IssueRead());
 163
 164   pair[1].Close();
 165
 166   base::MessageLoop::current()->Run();
 167   EXPECT_EQ(kReadOperationCount, reader.callbacks_received());
 168 }