| OLD | NEW |
|---|
| (Empty) |
| 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 <stddef.h> | |
| 6 #include <stdint.h> | |
| 7 | |
| 8 #include <memory> | |
| 9 #include <utility> | |
| 10 | |
| 11 #include "base/bind.h" | |
| 12 #include "base/macros.h" | |
| 13 #include "base/message_loop/message_loop.h" | |
| 14 #include "base/run_loop.h" | |
| 15 #include "base/strings/string_piece.h" | |
| 16 #include "device/serial/data_sender.h" | |
| 17 #include "device/serial/data_sink_receiver.h" | |
| 18 #include "device/serial/data_stream.mojom.h" | |
| 19 #include "mojo/public/cpp/bindings/interface_ptr.h" | |
| 20 #include "testing/gtest/include/gtest/gtest.h" | |
| 21 | |
| 22 namespace device { | |
| 23 | |
| 24 class DataSinkTest : public testing::Test { | |
| 25 public: | |
| 26 enum Event { | |
| 27 EVENT_NONE, | |
| 28 EVENT_READ_BUFFER_READY, | |
| 29 EVENT_CANCEL_RECEIVED, | |
| 30 EVENT_SEND_SUCCESS, | |
| 31 EVENT_SEND_ERROR, | |
| 32 EVENT_CANCEL_COMPLETE, | |
| 33 EVENT_ERROR, | |
| 34 }; | |
| 35 | |
| 36 DataSinkTest() | |
| 37 : bytes_sent_(0), | |
| 38 send_error_(0), | |
| 39 has_send_error_(false), | |
| 40 cancel_error_(0), | |
| 41 seen_connection_error_(false), | |
| 42 expected_event_(EVENT_NONE) {} | |
| 43 | |
| 44 void SetUp() override { | |
| 45 message_loop_.reset(new base::MessageLoop); | |
| 46 mojo::InterfacePtr<serial::DataSink> sink_handle; | |
| 47 sink_receiver_ = new DataSinkReceiver( | |
| 48 mojo::GetProxy(&sink_handle), | |
| 49 base::Bind(&DataSinkTest::OnDataToRead, base::Unretained(this)), | |
| 50 base::Bind(&DataSinkTest::OnCancel, base::Unretained(this)), | |
| 51 base::Bind(&DataSinkTest::OnError, base::Unretained(this))); | |
| 52 sender_.reset( | |
| 53 new DataSender(std::move(sink_handle), kBufferSize, kFatalError)); | |
| 54 } | |
| 55 | |
| 56 void TearDown() override { | |
| 57 read_buffer_.reset(); | |
| 58 message_loop_.reset(); | |
| 59 if (sink_receiver_.get()) | |
| 60 EXPECT_TRUE(sink_receiver_->HasOneRef()); | |
| 61 } | |
| 62 | |
| 63 void WaitForEvent(Event event) { | |
| 64 expected_event_ = event; | |
| 65 base::RunLoop run_loop; | |
| 66 stop_run_loop_ = run_loop.QuitClosure(); | |
| 67 run_loop.Run(); | |
| 68 } | |
| 69 | |
| 70 void EventReceived(Event event) { | |
| 71 if (event == expected_event_ && !stop_run_loop_.is_null()) | |
| 72 stop_run_loop_.Run(); | |
| 73 } | |
| 74 | |
| 75 void OnError() { | |
| 76 seen_connection_error_ = true; | |
| 77 EventReceived(EVENT_ERROR); | |
| 78 } | |
| 79 | |
| 80 void ExpectDataAndReadAll(const base::StringPiece& expected_data) { | |
| 81 ExpectData(expected_data, static_cast<uint32_t>(expected_data.size()), 0); | |
| 82 } | |
| 83 | |
| 84 void ExpectData(const base::StringPiece& expected_data, | |
| 85 uint32_t bytes_to_read, | |
| 86 int32_t error) { | |
| 87 DCHECK(bytes_to_read <= static_cast<uint32_t>(expected_data.size())); | |
| 88 std::string data; | |
| 89 while (data.size() < static_cast<size_t>(expected_data.size())) { | |
| 90 if (!read_buffer_) | |
| 91 WaitForEvent(EVENT_READ_BUFFER_READY); | |
| 92 ASSERT_TRUE(read_buffer_); | |
| 93 data.append(read_buffer_->GetData(), read_buffer_->GetSize()); | |
| 94 if (bytes_to_read <= read_buffer_->GetSize()) { | |
| 95 if (error) | |
| 96 read_buffer_->DoneWithError(bytes_to_read, error); | |
| 97 else | |
| 98 read_buffer_->Done(bytes_to_read); | |
| 99 read_buffer_.reset(); | |
| 100 break; | |
| 101 } else { | |
| 102 bytes_to_read -= read_buffer_->GetSize(); | |
| 103 read_buffer_->Done(read_buffer_->GetSize()); | |
| 104 read_buffer_.reset(); | |
| 105 } | |
| 106 } | |
| 107 // If we terminate early, we may not see all of the data. In that case, | |
| 108 // check that the part we saw matches what we expected. | |
| 109 if (static_cast<uint32_t>(data.size()) < | |
| 110 static_cast<uint32_t>(expected_data.size()) && | |
| 111 data.size() >= bytes_to_read) { | |
| 112 EXPECT_EQ(expected_data.substr(0, data.size()), data); | |
| 113 return; | |
| 114 } | |
| 115 EXPECT_EQ(expected_data, data); | |
| 116 } | |
| 117 | |
| 118 void ExpectSendSuccess(uint32_t expected_bytes_sent) { | |
| 119 bytes_sent_ = 0; | |
| 120 WaitForEvent(EVENT_SEND_SUCCESS); | |
| 121 EXPECT_EQ(expected_bytes_sent, bytes_sent_); | |
| 122 EXPECT_FALSE(has_send_error_); | |
| 123 } | |
| 124 | |
| 125 void ExpectSendError(uint32_t expected_bytes_sent, int32_t expected_error) { | |
| 126 bytes_sent_ = 0; | |
| 127 has_send_error_ = 0; | |
| 128 send_error_ = 0; | |
| 129 WaitForEvent(EVENT_SEND_ERROR); | |
| 130 EXPECT_EQ(expected_bytes_sent, bytes_sent_); | |
| 131 EXPECT_TRUE(has_send_error_); | |
| 132 EXPECT_EQ(expected_error, send_error_); | |
| 133 } | |
| 134 | |
| 135 void ExpectCancel(int32_t expected_error) { | |
| 136 cancel_error_ = 0; | |
| 137 WaitForEvent(EVENT_CANCEL_RECEIVED); | |
| 138 EXPECT_EQ(expected_error, cancel_error_); | |
| 139 } | |
| 140 | |
| 141 void ExpectCancelResult() { WaitForEvent(EVENT_CANCEL_COMPLETE); } | |
| 142 | |
| 143 bool Send(const base::StringPiece& data) { | |
| 144 return sender_->Send( | |
| 145 data, | |
| 146 base::Bind(&DataSinkTest::OnDataSent, base::Unretained(this)), | |
| 147 base::Bind(&DataSinkTest::OnSendError, base::Unretained(this))); | |
| 148 } | |
| 149 | |
| 150 void OnDataSent(uint32_t bytes_sent) { | |
| 151 bytes_sent_ = bytes_sent; | |
| 152 has_send_error_ = false; | |
| 153 EventReceived(EVENT_SEND_SUCCESS); | |
| 154 } | |
| 155 | |
| 156 void OnSendError(uint32_t bytes_sent, int32_t error) { | |
| 157 bytes_sent_ = bytes_sent; | |
| 158 send_error_ = error; | |
| 159 has_send_error_ = true; | |
| 160 EventReceived(EVENT_SEND_ERROR); | |
| 161 } | |
| 162 | |
| 163 void OnDataToRead(std::unique_ptr<ReadOnlyBuffer> buffer) { | |
| 164 read_buffer_ = std::move(buffer); | |
| 165 read_buffer_contents_ = | |
| 166 std::string(read_buffer_->GetData(), read_buffer_->GetSize()); | |
| 167 EventReceived(EVENT_READ_BUFFER_READY); | |
| 168 } | |
| 169 | |
| 170 bool Cancel(int32_t error) { | |
| 171 return sender_->Cancel( | |
| 172 error, base::Bind(&DataSinkTest::CancelAck, base::Unretained(this))); | |
| 173 } | |
| 174 | |
| 175 void CancelAck() { EventReceived(EVENT_CANCEL_COMPLETE); } | |
| 176 | |
| 177 void OnCancel(int32_t error) { | |
| 178 cancel_error_ = error; | |
| 179 EventReceived(EVENT_CANCEL_RECEIVED); | |
| 180 } | |
| 181 | |
| 182 protected: | |
| 183 static const int32_t kFatalError; | |
| 184 static const uint32_t kBufferSize; | |
| 185 std::unique_ptr<base::MessageLoop> message_loop_; | |
| 186 base::Closure stop_run_loop_; | |
| 187 | |
| 188 scoped_refptr<DataSinkReceiver> sink_receiver_; | |
| 189 std::unique_ptr<DataSender> sender_; | |
| 190 | |
| 191 uint32_t bytes_sent_; | |
| 192 int32_t send_error_; | |
| 193 bool has_send_error_; | |
| 194 int32_t cancel_error_; | |
| 195 std::unique_ptr<ReadOnlyBuffer> read_buffer_; | |
| 196 std::string read_buffer_contents_; | |
| 197 | |
| 198 bool seen_connection_error_; | |
| 199 | |
| 200 Event expected_event_; | |
| 201 | |
| 202 private: | |
| 203 DISALLOW_COPY_AND_ASSIGN(DataSinkTest); | |
| 204 }; | |
| 205 | |
| 206 const int32_t DataSinkTest::kFatalError = -10; | |
| 207 const uint32_t DataSinkTest::kBufferSize = 100; | |
| 208 | |
| 209 TEST_F(DataSinkTest, Basic) { | |
| 210 ASSERT_TRUE(Send("a")); | |
| 211 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll("a")); | |
| 212 ExpectSendSuccess(1); | |
| 213 } | |
| 214 | |
| 215 TEST_F(DataSinkTest, LargeSend) { | |
| 216 std::string pattern = "1234567890"; | |
| 217 std::string data; | |
| 218 for (uint32_t i = 0; i < kBufferSize; i++) | |
| 219 data.append(pattern); | |
| 220 ASSERT_TRUE(Send(data)); | |
| 221 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll(data)); | |
| 222 ExpectSendSuccess(static_cast<uint32_t>(data.size())); | |
| 223 } | |
| 224 | |
| 225 TEST_F(DataSinkTest, ErrorAndAllData) { | |
| 226 ASSERT_TRUE(Send("a")); | |
| 227 ASSERT_NO_FATAL_FAILURE(ExpectData("a", 1, -1)); | |
| 228 ExpectSendError(1, -1); | |
| 229 } | |
| 230 | |
| 231 TEST_F(DataSinkTest, ErrorAndPartialData) { | |
| 232 ASSERT_TRUE(Send("ab")); | |
| 233 ASSERT_NO_FATAL_FAILURE(ExpectData("ab", 1, -1)); | |
| 234 ExpectSendError(1, -1); | |
| 235 | |
| 236 ASSERT_TRUE(Send("c")); | |
| 237 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll("c")); | |
| 238 ExpectSendSuccess(1); | |
| 239 } | |
| 240 | |
| 241 TEST_F(DataSinkTest, ErrorAndPartialDataAtPacketBoundary) { | |
| 242 ASSERT_TRUE(Send("ab")); | |
| 243 ASSERT_NO_FATAL_FAILURE(ExpectData("ab", 2, -1)); | |
| 244 ExpectSendError(2, -1); | |
| 245 | |
| 246 ASSERT_TRUE(Send("c")); | |
| 247 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll("c")); | |
| 248 ExpectSendSuccess(1); | |
| 249 } | |
| 250 | |
| 251 TEST_F(DataSinkTest, ErrorInSecondPacket) { | |
| 252 ASSERT_TRUE(Send("a")); | |
| 253 ASSERT_TRUE(Send("b")); | |
| 254 ASSERT_NO_FATAL_FAILURE(ExpectData("ab", 2, -1)); | |
| 255 ExpectSendSuccess(1); | |
| 256 ExpectSendError(1, -1); | |
| 257 | |
| 258 ASSERT_TRUE(Send("c")); | |
| 259 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll("c")); | |
| 260 ExpectSendSuccess(1); | |
| 261 } | |
| 262 | |
| 263 TEST_F(DataSinkTest, ErrorBeforeLargeSend) { | |
| 264 ASSERT_TRUE(Send("a")); | |
| 265 std::string pattern = "123456789"; | |
| 266 std::string data; | |
| 267 for (int i = 0; i < 100; i++) | |
| 268 data.append("1234567890"); | |
| 269 ASSERT_TRUE(Send(data)); | |
| 270 ASSERT_NO_FATAL_FAILURE(ExpectData("a" + data, 1, -1)); | |
| 271 ExpectSendError(1, -1); | |
| 272 ExpectSendError(0, -1); | |
| 273 } | |
| 274 | |
| 275 TEST_F(DataSinkTest, ErrorOnly) { | |
| 276 ASSERT_TRUE(Send("a")); | |
| 277 ASSERT_NO_FATAL_FAILURE(ExpectData("a", 0, -1)); | |
| 278 ExpectSendError(0, -1); | |
| 279 | |
| 280 ASSERT_TRUE(Send("b")); | |
| 281 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll("b")); | |
| 282 ExpectSendSuccess(1); | |
| 283 } | |
| 284 | |
| 285 TEST_F(DataSinkTest, Cancel) { | |
| 286 ASSERT_TRUE(Send("a")); | |
| 287 WaitForEvent(EVENT_READ_BUFFER_READY); | |
| 288 ASSERT_TRUE(Cancel(-2)); | |
| 289 // Check that sends fail until the cancel operation completes. | |
| 290 EXPECT_FALSE(Send("b")); | |
| 291 ASSERT_NO_FATAL_FAILURE(ExpectCancel(-2)); | |
| 292 ASSERT_NO_FATAL_FAILURE(ExpectData("a", 0, -1)); | |
| 293 // Check that the error reported by the sink implementation is reported to the | |
| 294 // client - not the cancellation error. | |
| 295 ExpectSendError(0, -1); | |
| 296 ExpectCancelResult(); | |
| 297 | |
| 298 EXPECT_TRUE(Send("c")); | |
| 299 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll("c")); | |
| 300 ExpectSendSuccess(1); | |
| 301 } | |
| 302 | |
| 303 TEST_F(DataSinkTest, CancelSinkSucceeds) { | |
| 304 ASSERT_TRUE(Send("a")); | |
| 305 EXPECT_TRUE(Send("b")); | |
| 306 WaitForEvent(EVENT_READ_BUFFER_READY); | |
| 307 ASSERT_TRUE(Cancel(-2)); | |
| 308 ASSERT_NO_FATAL_FAILURE(ExpectCancel(-2)); | |
| 309 ASSERT_NO_FATAL_FAILURE(ExpectData("ab", 1, 0)); | |
| 310 ExpectSendError(1, -2); | |
| 311 ExpectCancelResult(); | |
| 312 | |
| 313 EXPECT_TRUE(Send("c")); | |
| 314 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll("c")); | |
| 315 ExpectSendSuccess(1); | |
| 316 } | |
| 317 | |
| 318 TEST_F(DataSinkTest, CancelTwice) { | |
| 319 ASSERT_TRUE(Send("a")); | |
| 320 WaitForEvent(EVENT_READ_BUFFER_READY); | |
| 321 ASSERT_TRUE(Cancel(-2)); | |
| 322 ASSERT_NO_FATAL_FAILURE(ExpectCancel(-2)); | |
| 323 ASSERT_NO_FATAL_FAILURE(ExpectData("a", 0, -2)); | |
| 324 ExpectSendError(0, -2); | |
| 325 ExpectCancelResult(); | |
| 326 | |
| 327 EXPECT_TRUE(Send("b")); | |
| 328 WaitForEvent(EVENT_READ_BUFFER_READY); | |
| 329 ASSERT_TRUE(Cancel(-3)); | |
| 330 ASSERT_NO_FATAL_FAILURE(ExpectCancel(-3)); | |
| 331 ASSERT_NO_FATAL_FAILURE(ExpectData("b", 0, -3)); | |
| 332 ExpectSendError(0, -3); | |
| 333 ExpectCancelResult(); | |
| 334 | |
| 335 EXPECT_TRUE(Send("c")); | |
| 336 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll("c")); | |
| 337 ExpectSendSuccess(1); | |
| 338 } | |
| 339 | |
| 340 TEST_F(DataSinkTest, CancelTwiceWithNoSendBetween) { | |
| 341 ASSERT_TRUE(Send("a")); | |
| 342 WaitForEvent(EVENT_READ_BUFFER_READY); | |
| 343 ASSERT_TRUE(Cancel(-2)); | |
| 344 ASSERT_NO_FATAL_FAILURE(ExpectCancel(-2)); | |
| 345 ASSERT_NO_FATAL_FAILURE(ExpectData("a", 0, -2)); | |
| 346 ExpectSendError(0, -2); | |
| 347 ExpectCancelResult(); | |
| 348 ASSERT_TRUE(Cancel(-3)); | |
| 349 ExpectCancelResult(); | |
| 350 | |
| 351 EXPECT_TRUE(Send("b")); | |
| 352 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll("b")); | |
| 353 ExpectSendSuccess(1); | |
| 354 } | |
| 355 | |
| 356 TEST_F(DataSinkTest, CancelDuringError) { | |
| 357 ASSERT_TRUE(Send("a")); | |
| 358 WaitForEvent(EVENT_READ_BUFFER_READY); | |
| 359 ASSERT_TRUE(Cancel(-2)); | |
| 360 ASSERT_NO_FATAL_FAILURE(ExpectData("a", 0, -1)); | |
| 361 ExpectSendError(0, -1); | |
| 362 ExpectCancelResult(); | |
| 363 | |
| 364 EXPECT_TRUE(Send("a")); | |
| 365 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll("a")); | |
| 366 ExpectSendSuccess(1); | |
| 367 } | |
| 368 | |
| 369 TEST_F(DataSinkTest, CancelWithoutSend) { | |
| 370 ASSERT_TRUE(Cancel(-2)); | |
| 371 ExpectCancelResult(); | |
| 372 | |
| 373 EXPECT_TRUE(Send("a")); | |
| 374 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll("a")); | |
| 375 ExpectSendSuccess(1); | |
| 376 EXPECT_EQ(0, cancel_error_); | |
| 377 } | |
| 378 | |
| 379 TEST_F(DataSinkTest, CancelPartialPacket) { | |
| 380 ASSERT_TRUE(Send("ab")); | |
| 381 WaitForEvent(EVENT_READ_BUFFER_READY); | |
| 382 ASSERT_TRUE(Cancel(-2)); | |
| 383 ASSERT_NO_FATAL_FAILURE(ExpectCancel(-2)); | |
| 384 ASSERT_NO_FATAL_FAILURE(ExpectData("ab", 1, -2)); | |
| 385 ExpectSendError(1, -2); | |
| 386 ExpectCancelResult(); | |
| 387 | |
| 388 EXPECT_TRUE(Send("c")); | |
| 389 ASSERT_NO_FATAL_FAILURE(ExpectDataAndReadAll("c")); | |
| 390 ExpectSendSuccess(1); | |
| 391 } | |
| 392 | |
| 393 TEST_F(DataSinkTest, SinkReceiverShutdown) { | |
| 394 ASSERT_TRUE(Send("a")); | |
| 395 ASSERT_TRUE(Send(std::string(kBufferSize * 10, 'b'))); | |
| 396 ASSERT_TRUE(Cancel(-1)); | |
| 397 sink_receiver_->ShutDown(); | |
| 398 sink_receiver_ = NULL; | |
| 399 ExpectSendError(0, kFatalError); | |
| 400 ExpectSendError(0, kFatalError); | |
| 401 ExpectCancelResult(); | |
| 402 ASSERT_FALSE(Send("a")); | |
| 403 ASSERT_FALSE(Cancel(-1)); | |
| 404 } | |
| 405 | |
| 406 TEST_F(DataSinkTest, SenderShutdown) { | |
| 407 ASSERT_TRUE(Send("a")); | |
| 408 ASSERT_TRUE(Send(std::string(kBufferSize * 10, 'b'))); | |
| 409 ASSERT_TRUE(Cancel(-1)); | |
| 410 sender_.reset(); | |
| 411 ExpectSendError(0, kFatalError); | |
| 412 ExpectSendError(0, kFatalError); | |
| 413 ExpectCancelResult(); | |
| 414 if (!seen_connection_error_) | |
| 415 WaitForEvent(EVENT_ERROR); | |
| 416 EXPECT_TRUE(seen_connection_error_); | |
| 417 } | |
| 418 | |
| 419 } // namespace device | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2410743002:
Remove the mojo serial interfaces and related infrastructure. (Closed)
