1// Copyright 2014 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/bind.h"
6#include "base/message_loop/message_loop.h"
7#include "base/run_loop.h"
8#include "base/strings/string_piece.h"
9#include "device/serial/async_waiter.h"
10#include "device/serial/buffer.h"
11#include "device/serial/data_receiver.h"
12#include "device/serial/data_source_sender.h"
13#include "device/serial/data_stream.mojom.h"
14#include "mojo/public/cpp/bindings/interface_ptr.h"
15#include "testing/gtest/include/gtest/gtest.h"
16
17namespace device {
18
19class DataSourceTest : public testing::Test {
20 public:
21  enum Event {
22    EVENT_NONE,
23    EVENT_WRITE_BUFFER_READY,
24    EVENT_RECEIVE_COMPLETE,
25    EVENT_ERROR,
26  };
27
28  DataSourceTest()
29      : error_(0), seen_connection_error_(false), expected_event_(EVENT_NONE) {}
30
31  virtual void SetUp() OVERRIDE {
32    message_loop_.reset(new base::MessageLoop);
33    mojo::InterfacePtr<serial::DataSource> source_sender_handle;
34    source_sender_ = mojo::WeakBindToProxy(
35        new DataSourceSender(
36            base::Bind(&DataSourceTest::CanWriteData, base::Unretained(this)),
37            base::Bind(&DataSourceTest::OnError, base::Unretained(this))),
38        &source_sender_handle);
39    receiver_ = new DataReceiver(source_sender_handle.Pass(), 100, kFatalError);
40  }
41
42  virtual void TearDown() OVERRIDE {
43    write_buffer_.reset();
44    buffer_.reset();
45    message_loop_.reset();
46  }
47
48  void OnError() {
49    seen_connection_error_ = true;
50    EventReceived(EVENT_ERROR);
51  }
52
53  void WaitForEvent(Event event) {
54    expected_event_ = event;
55    base::RunLoop run_loop;
56    stop_run_loop_ = run_loop.QuitClosure();
57    run_loop.Run();
58  }
59
60  void EventReceived(Event event) {
61    if (event == expected_event_ && !stop_run_loop_.is_null())
62      stop_run_loop_.Run();
63  }
64
65  bool Receive() {
66    return receiver_->Receive(
67        base::Bind(&DataSourceTest::OnDataReceived, base::Unretained(this)),
68        base::Bind(&DataSourceTest::OnReceiveError, base::Unretained(this)));
69  }
70
71  void FillWriteBuffer(const base::StringPiece& data, int32_t error) {
72    if (!write_buffer_) {
73      // Run the message loop until CanWriteData is called.
74      WaitForEvent(EVENT_WRITE_BUFFER_READY);
75    }
76    ASSERT_TRUE(write_buffer_);
77    ASSERT_GE(write_buffer_->GetSize(), static_cast<uint32_t>(data.size()));
78    memcpy(write_buffer_->GetData(), data.data(), data.size());
79    if (error)
80      write_buffer_->DoneWithError(static_cast<uint32_t>(data.size()), error);
81    else
82      write_buffer_->Done(static_cast<uint32_t>(data.size()));
83    write_buffer_.reset();
84  }
85
86  void ReceiveAndWait() {
87    ASSERT_TRUE(Receive());
88    // Run the message loop until OnDataReceived or OnReceiveError is called.
89    WaitForEvent(EVENT_RECEIVE_COMPLETE);
90  }
91
92  void OnDataReceived(scoped_ptr<ReadOnlyBuffer> buffer) {
93    ASSERT_TRUE(buffer);
94    error_ = 0;
95    buffer_ = buffer.Pass();
96    buffer_contents_ = std::string(buffer_->GetData(), buffer_->GetSize());
97    EventReceived(EVENT_RECEIVE_COMPLETE);
98  }
99
100  void OnReceiveError(int32_t error) {
101    buffer_contents_.clear();
102    error_ = error;
103    EventReceived(EVENT_RECEIVE_COMPLETE);
104  }
105
106  void CanWriteData(scoped_ptr<WritableBuffer> buffer) {
107    write_buffer_ = buffer.Pass();
108    EventReceived(EVENT_WRITE_BUFFER_READY);
109  }
110
111 protected:
112  static const int32_t kFatalError;
113  scoped_ptr<base::MessageLoop> message_loop_;
114  base::Closure stop_run_loop_;
115
116  scoped_refptr<DataSourceSender> source_sender_;
117  scoped_refptr<DataReceiver> receiver_;
118
119  scoped_ptr<ReadOnlyBuffer> buffer_;
120  std::string buffer_contents_;
121  int32_t error_;
122  scoped_ptr<WritableBuffer> write_buffer_;
123
124  bool seen_connection_error_;
125
126  Event expected_event_;
127
128 private:
129  DISALLOW_COPY_AND_ASSIGN(DataSourceTest);
130};
131
132const int32_t DataSourceTest::kFatalError = -10;
133
134// Test that data is successfully transmitted from the source to the receiver.
135TEST_F(DataSourceTest, Basic) {
136  ASSERT_NO_FATAL_FAILURE(FillWriteBuffer("a", 0));
137
138  ASSERT_NO_FATAL_FAILURE(ReceiveAndWait());
139  EXPECT_EQ(0, error_);
140  ASSERT_TRUE(buffer_);
141  EXPECT_EQ("a", buffer_contents_);
142  buffer_->Done(1);
143
144  ASSERT_NO_FATAL_FAILURE(FillWriteBuffer("b", 0));
145
146  ASSERT_NO_FATAL_FAILURE(ReceiveAndWait());
147  EXPECT_EQ(0, error_);
148  ASSERT_TRUE(buffer_);
149  EXPECT_EQ("b", buffer_contents_);
150}
151
152// Test that the receiver does not discard any data that is not read by the
153// client.
154TEST_F(DataSourceTest, PartialReceive) {
155  ASSERT_NO_FATAL_FAILURE(FillWriteBuffer("ab", 0));
156
157  ASSERT_NO_FATAL_FAILURE(ReceiveAndWait());
158  EXPECT_EQ(0, error_);
159  ASSERT_TRUE(buffer_);
160  EXPECT_EQ("ab", buffer_contents_);
161  buffer_->Done(1);
162
163  ASSERT_NO_FATAL_FAILURE(ReceiveAndWait());
164  EXPECT_EQ(0, error_);
165  ASSERT_TRUE(buffer_);
166  EXPECT_EQ("b", buffer_contents_);
167}
168
169// Test that an error is correctly reported to the Receive() call immediately
170// after the data has been read by the client.
171TEST_F(DataSourceTest, ErrorAndData) {
172  ASSERT_NO_FATAL_FAILURE(FillWriteBuffer("abc", -1));
173
174  ASSERT_NO_FATAL_FAILURE(ReceiveAndWait());
175  ASSERT_TRUE(buffer_);
176  EXPECT_EQ("abc", buffer_contents_);
177  buffer_->Done(1);
178  EXPECT_EQ(0, error_);
179  ASSERT_NO_FATAL_FAILURE(ReceiveAndWait());
180  ASSERT_TRUE(buffer_);
181  EXPECT_EQ("bc", buffer_contents_);
182  buffer_->Done(1);
183  EXPECT_EQ(0, error_);
184  ASSERT_NO_FATAL_FAILURE(ReceiveAndWait());
185  ASSERT_TRUE(buffer_);
186  EXPECT_EQ("c", buffer_contents_);
187  buffer_->Done(1);
188  EXPECT_EQ(0, error_);
189  ASSERT_NO_FATAL_FAILURE(ReceiveAndWait());
190  EXPECT_EQ(-1, error_);
191  ASSERT_FALSE(write_buffer_);
192
193  ASSERT_TRUE(Receive());
194  ASSERT_NO_FATAL_FAILURE(FillWriteBuffer("d", 0));
195
196  WaitForEvent(EVENT_RECEIVE_COMPLETE);
197  ASSERT_TRUE(buffer_);
198  EXPECT_EQ("d", buffer_contents_);
199  buffer_->Done(1);
200  EXPECT_EQ(0, error_);
201
202  ASSERT_NO_FATAL_FAILURE(FillWriteBuffer("e", -2));
203  ASSERT_NO_FATAL_FAILURE(ReceiveAndWait());
204  ASSERT_TRUE(buffer_);
205  EXPECT_EQ("e", buffer_contents_);
206  buffer_->Done(1);
207  EXPECT_EQ(0, error_);
208
209  ASSERT_NO_FATAL_FAILURE(ReceiveAndWait());
210  EXPECT_EQ(-2, error_);
211}
212
213// Test that an error is correctly reported when the source encounters an error
214// without sending any data.
215TEST_F(DataSourceTest, ErrorOnly) {
216  ASSERT_NO_FATAL_FAILURE(FillWriteBuffer("", -1));
217
218  ASSERT_NO_FATAL_FAILURE(ReceiveAndWait());
219  EXPECT_FALSE(buffer_);
220  EXPECT_EQ(-1, error_);
221  ASSERT_FALSE(write_buffer_);
222
223  ASSERT_TRUE(Receive());
224  ASSERT_NO_FATAL_FAILURE(FillWriteBuffer("", -2));
225
226  WaitForEvent(EVENT_RECEIVE_COMPLETE);
227  EXPECT_FALSE(buffer_);
228  EXPECT_EQ(-2, error_);
229  ASSERT_FALSE(write_buffer_);
230}
231
232// Test that the source shutting down is correctly reported to the client.
233TEST_F(DataSourceTest, SourceShutdown) {
234  source_sender_->ShutDown();
235  source_sender_ = NULL;
236  ASSERT_NO_FATAL_FAILURE(ReceiveAndWait());
237  EXPECT_FALSE(buffer_);
238  EXPECT_EQ(kFatalError, error_);
239  ASSERT_FALSE(write_buffer_);
240  ASSERT_FALSE(Receive());
241}
242
243// Test that the receiver shutting down is correctly reported to the source.
244TEST_F(DataSourceTest, ReceiverShutdown) {
245  Receive();
246  receiver_ = NULL;
247  EXPECT_EQ(kFatalError, error_);
248  WaitForEvent(EVENT_ERROR);
249  EXPECT_TRUE(seen_connection_error_);
250}
251
252}  // namespace device
253