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