src/extensions/renderer/api/serial/data_sender_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 <queue>
   6
   7 #include "device/serial/data_sink_receiver.h"
   8 #include "device/serial/data_stream.mojom.h"
   9 #include "extensions/renderer/api_test_base.h"
  10 #include "grit/extensions_renderer_resources.h"
  11
  12 namespace extensions {
  13
  14 // Runs tests defined in extensions/test/data/data_sender_unittest.js
  15 class DataSenderTest : public ApiTestBase {
  16  public:
  17   DataSenderTest() {}
  18
  19   void SetUp() override {
  20     ApiTestBase::SetUp();
  21     service_provider()->AddService(
  22         base::Bind(&DataSenderTest::CreateDataSink, base::Unretained(this)));
  23   }
  24
  25   void TearDown() override {
  26     if (receiver_.get()) {
  27       receiver_->ShutDown();
  28       receiver_ = NULL;
  29     }
  30     EXPECT_FALSE(buffer_);
  31     buffer_.reset();
  32     ApiTestBase::TearDown();
  33   }
  34
  35   std::queue<int32_t> error_to_report_;
  36   std::queue<std::string> expected_data_;
  37
  38  private:
  39   void CreateDataSink(
  40       mojo::InterfaceRequest<device::serial::DataSink> request) {
  41     receiver_ = mojo::WeakBindToRequest(
  42         new device::DataSinkReceiver(
  43             base::Bind(&DataSenderTest::ReadyToReceive, base::Unretained(this)),
  44             base::Bind(&DataSenderTest::OnCancel, base::Unretained(this)),
  45             base::Bind(base::DoNothing)),
  46         &request);
  47   }
  48
  49   void ReadyToReceive(scoped_ptr<device::ReadOnlyBuffer> buffer) {
  50     std::string data(buffer->GetData(), buffer->GetSize());
  51     if (expected_data_.empty()) {
  52       buffer_ = buffer.Pass();
  53       return;
  54     }
  55
  56     std::string& expected = expected_data_.front();
  57     if (expected.size() > buffer->GetSize()) {
  58       EXPECT_EQ(expected.substr(0, buffer->GetSize()), data);
  59       expected = expected.substr(buffer->GetSize());
  60       buffer->Done(buffer->GetSize());
  61       return;
  62     }
  63     if (expected.size() < buffer->GetSize())
  64       data = data.substr(0, expected.size());
  65     EXPECT_EQ(expected, data);
  66     expected_data_.pop();
  67     int32_t error = 0;
  68     if (!error_to_report_.empty()) {
  69       error = error_to_report_.front();
  70       error_to_report_.pop();
  71     }
  72     if (error)
  73       buffer->DoneWithError(data.size(), error);
  74     else
  75       buffer->Done(data.size());
  76   }
  77
  78   void OnCancel(int32_t error) {
  79     ASSERT_TRUE(buffer_);
  80     buffer_->DoneWithError(0, error);
  81     buffer_.reset();
  82   }
  83
  84   scoped_refptr<device::DataSinkReceiver> receiver_;
  85   scoped_ptr<device::ReadOnlyBuffer> buffer_;
  86
  87   DISALLOW_COPY_AND_ASSIGN(DataSenderTest);
  88 };
  89
  90 TEST_F(DataSenderTest, Send) {
  91   expected_data_.push("aa");
  92   RunTest("data_sender_unittest.js", "testSend");
  93 }
  94
  95 TEST_F(DataSenderTest, LargeSend) {
  96   std::string pattern = "123";
  97   std::string expected_data;
  98   for (int i = 0; i < 11; i++)
  99     expected_data += pattern;
 100   expected_data_.push(expected_data);
 101   RunTest("data_sender_unittest.js", "testLargeSend");
 102 }
 103
 104 TEST_F(DataSenderTest, SendError) {
 105   expected_data_.push("");
 106   expected_data_.push("a");
 107   error_to_report_.push(1);
 108   RunTest("data_sender_unittest.js", "testSendError");
 109 }
 110
 111 TEST_F(DataSenderTest, SendErrorPartialSuccess) {
 112   expected_data_.push(std::string(5, 'b'));
 113   expected_data_.push("a");
 114   error_to_report_.push(1);
 115   RunTest("data_sender_unittest.js", "testSendErrorPartialSuccess");
 116 }
 117
 118 TEST_F(DataSenderTest, SendErrorBetweenPackets) {
 119   expected_data_.push(std::string(2, 'b'));
 120   expected_data_.push("a");
 121   error_to_report_.push(1);
 122   RunTest("data_sender_unittest.js", "testSendErrorBetweenPackets");
 123 }
 124
 125 TEST_F(DataSenderTest, SendErrorInSecondPacket) {
 126   expected_data_.push(std::string(3, 'b'));
 127   expected_data_.push("a");
 128   error_to_report_.push(1);
 129   RunTest("data_sender_unittest.js", "testSendErrorInSecondPacket");
 130 }
 131
 132 TEST_F(DataSenderTest, SendErrorInLargeSend) {
 133   expected_data_.push("123456789012");
 134   expected_data_.push("a");
 135   error_to_report_.push(1);
 136   RunTest("data_sender_unittest.js", "testSendErrorInLargeSend");
 137 }
 138
 139 TEST_F(DataSenderTest, SendErrorBeforeLargeSend) {
 140   expected_data_.push(std::string(2, 'b'));
 141   expected_data_.push("a");
 142   error_to_report_.push(1);
 143   RunTest("data_sender_unittest.js", "testSendErrorBeforeLargeSend");
 144 }
 145
 146 TEST_F(DataSenderTest, CancelWithoutSend) {
 147   RunTest("data_sender_unittest.js", "testCancelWithoutSend");
 148 }
 149
 150 TEST_F(DataSenderTest, Cancel) {
 151   RunTest("data_sender_unittest.js", "testCancel");
 152 }
 153
 154 TEST_F(DataSenderTest, Close) {
 155   RunTest("data_sender_unittest.js", "testClose");
 156 }
 157
 158 TEST_F(DataSenderTest, SendAfterSerialization) {
 159   expected_data_.push("aa");
 160   RunTest("data_sender_unittest.js", "testSendAfterSerialization");
 161 }
 162
 163 TEST_F(DataSenderTest, SendErrorAfterSerialization) {
 164   expected_data_.push("");
 165   expected_data_.push("a");
 166   error_to_report_.push(1);
 167   RunTest("data_sender_unittest.js", "testSendErrorAfterSerialization");
 168 }
 169
 170 TEST_F(DataSenderTest, CancelAfterSerialization) {
 171   RunTest("data_sender_unittest.js", "testCancelAfterSerialization");
 172 }
 173
 174 TEST_F(DataSenderTest, SerializeCancelsSendsInProgress) {
 175   RunTest("data_sender_unittest.js", "testSerializeCancelsSendsInProgress");
 176 }
 177
 178 TEST_F(DataSenderTest, SerializeWaitsForCancel) {
 179   RunTest("data_sender_unittest.js", "testSerializeWaitsForCancel");
 180 }
 181
 182 TEST_F(DataSenderTest, SerializeAfterClose) {
 183   RunTest("data_sender_unittest.js", "testSerializeAfterClose");
 184 }
 185
 186 }  // namespace extensions