remoting/protocol/message_reader_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 <string>
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/callback.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/run_loop.h"
  12 #include "base/stl_util.h"
  13 #include "base/synchronization/waitable_event.h"
  14 #include "net/base/net_errors.h"
  15 #include "net/socket/socket.h"
  16 #include "remoting/protocol/fake_stream_socket.h"
  17 #include "remoting/protocol/message_reader.h"
  18 #include "testing/gmock/include/gmock/gmock.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20 #include "third_party/webrtc/base/byteorder.h"
  21
  22 using testing::_;
  23 using testing::DoAll;
  24 using testing::Mock;
  25 using testing::SaveArg;
  26
  27 namespace remoting {
  28 namespace protocol {
  29
  30 namespace {
  31 const char kTestMessage1[] = "Message1";
  32 const char kTestMessage2[] = "Message2";
  33
  34 ACTION(CallDoneTask) {
  35   arg0.Run();
  36 }
  37 }  // namespace
  38
  39 class MockMessageReceivedCallback {
  40  public:
  41   MOCK_METHOD1(OnMessage, void(const base::Closure&));
  42 };
  43
  44 class MessageReaderTest : public testing::Test {
  45  public:
  46   MessageReaderTest()
  47       : in_callback_(false) {
  48   }
  49
  50   // Following two methods are used by the ReadFromCallback test.
  51   void AddSecondMessage(const base::Closure& task) {
  52     AddMessage(kTestMessage2);
  53     in_callback_ = true;
  54     task.Run();
  55     in_callback_ = false;
  56   }
  57
  58   void OnSecondMessage(const base::Closure& task) {
  59     EXPECT_FALSE(in_callback_);
  60     task.Run();
  61   }
  62
  63   // Used by the DeleteFromCallback() test.
  64   void DeleteReader(const base::Closure& task) {
  65     reader_.reset();
  66     task.Run();
  67   }
  68
  69  protected:
  70   void SetUp() override {
  71     reader_.reset(new MessageReader());
  72   }
  73
  74   void TearDown() override { STLDeleteElements(&messages_); }
  75
  76   void InitReader() {
  77     reader_->SetMessageReceivedCallback(
  78         base::Bind(&MessageReaderTest::OnMessage, base::Unretained(this)));
  79     reader_->StartReading(&socket_, base::Bind(&MessageReaderTest::OnReadError,
  80                                                base::Unretained(this)));
  81   }
  82
  83   void AddMessage(const std::string& message) {
  84     std::string data = std::string(4, ' ') + message;
  85     rtc::SetBE32(const_cast<char*>(data.data()), message.size());
  86
  87     socket_.AppendInputData(data);
  88   }
  89
  90   bool CompareResult(CompoundBuffer* buffer, const std::string& expected) {
  91     std::string result(buffer->total_bytes(), ' ');
  92     buffer->CopyTo(const_cast<char*>(result.data()), result.size());
  93     return result == expected;
  94   }
  95
  96   void OnReadError(int error) {
  97     read_error_ = error;
  98     reader_.reset();
  99   }
 100
 101   void OnMessage(scoped_ptr<CompoundBuffer> buffer,
 102                  const base::Closure& done_callback) {
 103     messages_.push_back(buffer.release());
 104     callback_.OnMessage(done_callback);
 105   }
 106
 107   base::MessageLoop message_loop_;
 108   scoped_ptr<MessageReader> reader_;
 109   FakeStreamSocket socket_;
 110   MockMessageReceivedCallback callback_;
 111   int read_error_ = 0;
 112   std::vector<CompoundBuffer*> messages_;
 113   bool in_callback_;
 114 };
 115
 116 // Receive one message and process it with delay
 117 TEST_F(MessageReaderTest, OneMessage_Delay) {
 118   base::Closure done_task;
 119
 120   AddMessage(kTestMessage1);
 121
 122   EXPECT_CALL(callback_, OnMessage(_))
 123       .Times(1)
 124       .WillOnce(SaveArg<0>(&done_task));
 125
 126   InitReader();
 127   base::RunLoop().RunUntilIdle();
 128
 129   Mock::VerifyAndClearExpectations(&callback_);
 130   Mock::VerifyAndClearExpectations(&socket_);
 131
 132   EXPECT_TRUE(CompareResult(messages_[0], kTestMessage1));
 133
 134   // Verify that the reader starts reading again only after we've
 135   // finished processing the previous message.
 136   EXPECT_FALSE(socket_.read_pending());
 137
 138   done_task.Run();
 139
 140   EXPECT_TRUE(socket_.read_pending());
 141 }
 142
 143 // Receive one message and process it instantly.
 144 TEST_F(MessageReaderTest, OneMessage_Instant) {
 145   AddMessage(kTestMessage1);
 146
 147   EXPECT_CALL(callback_, OnMessage(_))
 148       .Times(1)
 149       .WillOnce(CallDoneTask());
 150
 151   InitReader();
 152   base::RunLoop().RunUntilIdle();
 153
 154   EXPECT_TRUE(socket_.read_pending());
 155   EXPECT_EQ(1U, messages_.size());
 156 }
 157
 158 // Receive two messages in one packet.
 159 TEST_F(MessageReaderTest, TwoMessages_Together) {
 160   base::Closure done_task1;
 161   base::Closure done_task2;
 162
 163   AddMessage(kTestMessage1);
 164   AddMessage(kTestMessage2);
 165
 166   EXPECT_CALL(callback_, OnMessage(_))
 167       .Times(2)
 168       .WillOnce(SaveArg<0>(&done_task1))
 169       .WillOnce(SaveArg<0>(&done_task2));
 170
 171   InitReader();
 172   base::RunLoop().RunUntilIdle();
 173
 174   Mock::VerifyAndClearExpectations(&callback_);
 175   Mock::VerifyAndClearExpectations(&socket_);
 176
 177   EXPECT_TRUE(CompareResult(messages_[0], kTestMessage1));
 178   EXPECT_TRUE(CompareResult(messages_[1], kTestMessage2));
 179
 180   // Verify that the reader starts reading again only after we've
 181   // finished processing the previous message.
 182   EXPECT_FALSE(socket_.read_pending());
 183
 184   done_task1.Run();
 185   base::RunLoop().RunUntilIdle();
 186
 187   EXPECT_FALSE(socket_.read_pending());
 188
 189   done_task2.Run();
 190   base::RunLoop().RunUntilIdle();
 191
 192   EXPECT_TRUE(socket_.read_pending());
 193 }
 194
 195 // Receive two messages in one packet, and process the first one
 196 // instantly.
 197 TEST_F(MessageReaderTest, TwoMessages_Instant) {
 198   base::Closure done_task2;
 199
 200   AddMessage(kTestMessage1);
 201   AddMessage(kTestMessage2);
 202
 203   EXPECT_CALL(callback_, OnMessage(_))
 204       .Times(2)
 205       .WillOnce(CallDoneTask())
 206       .WillOnce(SaveArg<0>(&done_task2));
 207
 208   InitReader();
 209   base::RunLoop().RunUntilIdle();
 210
 211   Mock::VerifyAndClearExpectations(&callback_);
 212   Mock::VerifyAndClearExpectations(&socket_);
 213
 214   EXPECT_TRUE(CompareResult(messages_[1], kTestMessage2));
 215
 216   // Verify that the reader starts reading again only after we've
 217   // finished processing the second message.
 218   EXPECT_FALSE(socket_.read_pending());
 219
 220   done_task2.Run();
 221
 222   EXPECT_TRUE(socket_.read_pending());
 223 }
 224
 225 // Receive two messages in one packet, and process both of them
 226 // instantly.
 227 TEST_F(MessageReaderTest, TwoMessages_Instant2) {
 228   AddMessage(kTestMessage1);
 229   AddMessage(kTestMessage2);
 230
 231   EXPECT_CALL(callback_, OnMessage(_))
 232       .Times(2)
 233       .WillOnce(CallDoneTask())
 234       .WillOnce(CallDoneTask());
 235
 236   InitReader();
 237   base::RunLoop().RunUntilIdle();
 238
 239   EXPECT_TRUE(socket_.read_pending());
 240 }
 241
 242 // Receive two messages in separate packets.
 243 TEST_F(MessageReaderTest, TwoMessages_Separately) {
 244   base::Closure done_task;
 245
 246   AddMessage(kTestMessage1);
 247
 248   EXPECT_CALL(callback_, OnMessage(_))
 249       .Times(1)
 250       .WillOnce(SaveArg<0>(&done_task));
 251
 252   InitReader();
 253   base::RunLoop().RunUntilIdle();
 254
 255   Mock::VerifyAndClearExpectations(&callback_);
 256   Mock::VerifyAndClearExpectations(&socket_);
 257
 258   EXPECT_TRUE(CompareResult(messages_[0], kTestMessage1));
 259
 260   // Verify that the reader starts reading again only after we've
 261   // finished processing the previous message.
 262   EXPECT_FALSE(socket_.read_pending());
 263
 264   done_task.Run();
 265   base::RunLoop().RunUntilIdle();
 266
 267   EXPECT_TRUE(socket_.read_pending());
 268
 269   // Write another message and verify that we receive it.
 270   EXPECT_CALL(callback_, OnMessage(_))
 271       .Times(1)
 272       .WillOnce(SaveArg<0>(&done_task));
 273   AddMessage(kTestMessage2);
 274   base::RunLoop().RunUntilIdle();
 275
 276   EXPECT_TRUE(CompareResult(messages_[1], kTestMessage2));
 277
 278   // Verify that the reader starts reading again only after we've
 279   // finished processing the previous message.
 280   EXPECT_FALSE(socket_.read_pending());
 281
 282   done_task.Run();
 283
 284   EXPECT_TRUE(socket_.read_pending());
 285 }
 286
 287 // Read() returns error.
 288 TEST_F(MessageReaderTest, ReadError) {
 289   socket_.AppendReadError(net::ERR_FAILED);
 290
 291   EXPECT_CALL(callback_, OnMessage(_)).Times(0);
 292
 293   InitReader();
 294
 295   EXPECT_EQ(net::ERR_FAILED, read_error_);
 296   EXPECT_FALSE(reader_);
 297 }
 298
 299 // Verify that we the OnMessage callback is not reentered.
 300 TEST_F(MessageReaderTest, ReadFromCallback) {
 301   AddMessage(kTestMessage1);
 302
 303   EXPECT_CALL(callback_, OnMessage(_))
 304       .Times(2)
 305       .WillOnce(Invoke(this, &MessageReaderTest::AddSecondMessage))
 306       .WillOnce(Invoke(this, &MessageReaderTest::OnSecondMessage));
 307
 308   InitReader();
 309   base::RunLoop().RunUntilIdle();
 310
 311   EXPECT_TRUE(socket_.read_pending());
 312 }
 313
 314 // Verify that we stop getting callbacks after deleting MessageReader.
 315 TEST_F(MessageReaderTest, DeleteFromCallback) {
 316   base::Closure done_task1;
 317   base::Closure done_task2;
 318
 319   AddMessage(kTestMessage1);
 320   AddMessage(kTestMessage2);
 321
 322   // OnMessage() should never be called for the second message.
 323   EXPECT_CALL(callback_, OnMessage(_))
 324       .Times(1)
 325       .WillOnce(Invoke(this, &MessageReaderTest::DeleteReader));
 326
 327   InitReader();
 328   base::RunLoop().RunUntilIdle();
 329 }
 330
 331 }  // namespace protocol
 332 }  // namespace remoting