device/serial/data_sink_unittest.cc

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