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