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
22using testing::_;
23using testing::DoAll;
24using testing::Mock;
25using testing::SaveArg;
26
27namespace remoting {
28namespace protocol {
29
30namespace {
31const char kTestMessage1[] = "Message1";
32const char kTestMessage2[] = "Message2";
33
34ACTION(CallDoneTask) {
35  arg0.Run();
36}
37}  // namespace
38
39class MockMessageReceivedCallback {
40 public:
41  MOCK_METHOD1(OnMessage, void(const base::Closure&));
42};
43
44class 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  virtual void SetUp() OVERRIDE {
71    reader_.reset(new MessageReader());
72  }
73
74  virtual void TearDown() OVERRIDE {
75    STLDeleteElements(&messages_);
76  }
77
78  void InitReader() {
79    reader_->Init(&socket_, base::Bind(
80        &MessageReaderTest::OnMessage, 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 OnMessage(scoped_ptr<CompoundBuffer> buffer,
97                 const base::Closure& done_callback) {
98    messages_.push_back(buffer.release());
99    callback_.OnMessage(done_callback);
100  }
101
102  base::MessageLoop message_loop_;
103  scoped_ptr<MessageReader> reader_;
104  FakeStreamSocket socket_;
105  MockMessageReceivedCallback callback_;
106  std::vector<CompoundBuffer*> messages_;
107  bool in_callback_;
108};
109
110// Receive one message and process it with delay
111TEST_F(MessageReaderTest, OneMessage_Delay) {
112  base::Closure done_task;
113
114  AddMessage(kTestMessage1);
115
116  EXPECT_CALL(callback_, OnMessage(_))
117      .Times(1)
118      .WillOnce(SaveArg<0>(&done_task));
119
120  InitReader();
121  base::RunLoop().RunUntilIdle();
122
123  Mock::VerifyAndClearExpectations(&callback_);
124  Mock::VerifyAndClearExpectations(&socket_);
125
126  EXPECT_TRUE(CompareResult(messages_[0], kTestMessage1));
127
128  // Verify that the reader starts reading again only after we've
129  // finished processing the previous message.
130  EXPECT_FALSE(socket_.read_pending());
131
132  done_task.Run();
133
134  EXPECT_TRUE(socket_.read_pending());
135}
136
137// Receive one message and process it instantly.
138TEST_F(MessageReaderTest, OneMessage_Instant) {
139  AddMessage(kTestMessage1);
140
141  EXPECT_CALL(callback_, OnMessage(_))
142      .Times(1)
143      .WillOnce(CallDoneTask());
144
145  InitReader();
146  base::RunLoop().RunUntilIdle();
147
148  EXPECT_TRUE(socket_.read_pending());
149  EXPECT_EQ(1U, messages_.size());
150}
151
152// Receive two messages in one packet.
153TEST_F(MessageReaderTest, TwoMessages_Together) {
154  base::Closure done_task1;
155  base::Closure done_task2;
156
157  AddMessage(kTestMessage1);
158  AddMessage(kTestMessage2);
159
160  EXPECT_CALL(callback_, OnMessage(_))
161      .Times(2)
162      .WillOnce(SaveArg<0>(&done_task1))
163      .WillOnce(SaveArg<0>(&done_task2));
164
165  InitReader();
166  base::RunLoop().RunUntilIdle();
167
168  Mock::VerifyAndClearExpectations(&callback_);
169  Mock::VerifyAndClearExpectations(&socket_);
170
171  EXPECT_TRUE(CompareResult(messages_[0], kTestMessage1));
172  EXPECT_TRUE(CompareResult(messages_[1], kTestMessage2));
173
174  // Verify that the reader starts reading again only after we've
175  // finished processing the previous message.
176  EXPECT_FALSE(socket_.read_pending());
177
178  done_task1.Run();
179  base::RunLoop().RunUntilIdle();
180
181  EXPECT_FALSE(socket_.read_pending());
182
183  done_task2.Run();
184  base::RunLoop().RunUntilIdle();
185
186  EXPECT_TRUE(socket_.read_pending());
187}
188
189// Receive two messages in one packet, and process the first one
190// instantly.
191TEST_F(MessageReaderTest, TwoMessages_Instant) {
192  base::Closure done_task2;
193
194  AddMessage(kTestMessage1);
195  AddMessage(kTestMessage2);
196
197  EXPECT_CALL(callback_, OnMessage(_))
198      .Times(2)
199      .WillOnce(CallDoneTask())
200      .WillOnce(SaveArg<0>(&done_task2));
201
202  InitReader();
203  base::RunLoop().RunUntilIdle();
204
205  Mock::VerifyAndClearExpectations(&callback_);
206  Mock::VerifyAndClearExpectations(&socket_);
207
208  EXPECT_TRUE(CompareResult(messages_[1], kTestMessage2));
209
210  // Verify that the reader starts reading again only after we've
211  // finished processing the second message.
212  EXPECT_FALSE(socket_.read_pending());
213
214  done_task2.Run();
215
216  EXPECT_TRUE(socket_.read_pending());
217}
218
219// Receive two messages in one packet, and process both of them
220// instantly.
221TEST_F(MessageReaderTest, TwoMessages_Instant2) {
222  AddMessage(kTestMessage1);
223  AddMessage(kTestMessage2);
224
225  EXPECT_CALL(callback_, OnMessage(_))
226      .Times(2)
227      .WillOnce(CallDoneTask())
228      .WillOnce(CallDoneTask());
229
230  InitReader();
231  base::RunLoop().RunUntilIdle();
232
233  EXPECT_TRUE(socket_.read_pending());
234}
235
236// Receive two messages in separate packets.
237TEST_F(MessageReaderTest, TwoMessages_Separately) {
238  base::Closure done_task;
239
240  AddMessage(kTestMessage1);
241
242  EXPECT_CALL(callback_, OnMessage(_))
243      .Times(1)
244      .WillOnce(SaveArg<0>(&done_task));
245
246  InitReader();
247  base::RunLoop().RunUntilIdle();
248
249  Mock::VerifyAndClearExpectations(&callback_);
250  Mock::VerifyAndClearExpectations(&socket_);
251
252  EXPECT_TRUE(CompareResult(messages_[0], kTestMessage1));
253
254  // Verify that the reader starts reading again only after we've
255  // finished processing the previous message.
256  EXPECT_FALSE(socket_.read_pending());
257
258  done_task.Run();
259  base::RunLoop().RunUntilIdle();
260
261  EXPECT_TRUE(socket_.read_pending());
262
263  // Write another message and verify that we receive it.
264  EXPECT_CALL(callback_, OnMessage(_))
265      .Times(1)
266      .WillOnce(SaveArg<0>(&done_task));
267  AddMessage(kTestMessage2);
268  base::RunLoop().RunUntilIdle();
269
270  EXPECT_TRUE(CompareResult(messages_[1], kTestMessage2));
271
272  // Verify that the reader starts reading again only after we've
273  // finished processing the previous message.
274  EXPECT_FALSE(socket_.read_pending());
275
276  done_task.Run();
277
278  EXPECT_TRUE(socket_.read_pending());
279}
280
281// Read() returns error.
282TEST_F(MessageReaderTest, ReadError) {
283  socket_.set_next_read_error(net::ERR_FAILED);
284
285  // Add a message. It should never be read after the error above.
286  AddMessage(kTestMessage1);
287
288  EXPECT_CALL(callback_, OnMessage(_))
289      .Times(0);
290
291  InitReader();
292}
293
294// Verify that we the OnMessage callback is not reentered.
295TEST_F(MessageReaderTest, ReadFromCallback) {
296  AddMessage(kTestMessage1);
297
298  EXPECT_CALL(callback_, OnMessage(_))
299      .Times(2)
300      .WillOnce(Invoke(this, &MessageReaderTest::AddSecondMessage))
301      .WillOnce(Invoke(this, &MessageReaderTest::OnSecondMessage));
302
303  InitReader();
304  base::RunLoop().RunUntilIdle();
305
306  EXPECT_TRUE(socket_.read_pending());
307}
308
309// Verify that we stop getting callbacks after deleting MessageReader.
310TEST_F(MessageReaderTest, DeleteFromCallback) {
311  base::Closure done_task1;
312  base::Closure done_task2;
313
314  AddMessage(kTestMessage1);
315  AddMessage(kTestMessage2);
316
317  // OnMessage() should never be called for the second message.
318  EXPECT_CALL(callback_, OnMessage(_))
319      .Times(1)
320      .WillOnce(Invoke(this, &MessageReaderTest::DeleteReader));
321
322  InitReader();
323  base::RunLoop().RunUntilIdle();
324}
325
326}  // namespace protocol
327}  // namespace remoting
328