data_sender_unittest.cc revision 03b57e008b61dfcb1fbad3aea950ae0e001748b0 
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
12namespace extensions {
13
14// Runs tests defined in extensions/test/data/data_sender_unittest.js
15class 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    service_provider()->AddService(
26        base::Bind(&DataSenderTest::CreateDataSink, base::Unretained(this)));
27  }
28
29  virtual void TearDown() OVERRIDE {
30    if (receiver_) {
31      receiver_->ShutDown();
32      receiver_ = NULL;
33    }
34    EXPECT_FALSE(buffer_);
35    buffer_.reset();
36    ApiTestBase::TearDown();
37  }
38
39  std::queue<int32_t> error_to_report_;
40  std::queue<std::string> expected_data_;
41
42 private:
43  void CreateDataSink(
44      mojo::InterfaceRequest<device::serial::DataSink> request) {
45    receiver_ = mojo::WeakBindToRequest(
46        new device::DataSinkReceiver(
47            base::Bind(&DataSenderTest::ReadyToReceive, base::Unretained(this)),
48            base::Bind(&DataSenderTest::OnCancel, base::Unretained(this)),
49            base::Bind(base::DoNothing)),
50        &request);
51  }
52
53  void ReadyToReceive(scoped_ptr<device::ReadOnlyBuffer> buffer) {
54    std::string data(buffer->GetData(), buffer->GetSize());
55    if (expected_data_.empty()) {
56      buffer_ = buffer.Pass();
57      return;
58    }
59
60    std::string& expected = expected_data_.front();
61    if (expected.size() > buffer->GetSize()) {
62      EXPECT_EQ(expected.substr(0, buffer->GetSize()), data);
63      expected = expected.substr(buffer->GetSize());
64      buffer->Done(buffer->GetSize());
65      return;
66    }
67    if (expected.size() < buffer->GetSize())
68      data = data.substr(0, expected.size());
69    EXPECT_EQ(expected, data);
70    expected_data_.pop();
71    int32_t error = 0;
72    if (!error_to_report_.empty()) {
73      error = error_to_report_.front();
74      error_to_report_.pop();
75    }
76    if (error)
77      buffer->DoneWithError(data.size(), error);
78    else
79      buffer->Done(data.size());
80  }
81
82  void OnCancel(int32_t error) {
83    ASSERT_TRUE(buffer_);
84    buffer_->DoneWithError(0, error);
85    buffer_.reset();
86  }
87
88  scoped_refptr<device::DataSinkReceiver> receiver_;
89  scoped_ptr<device::ReadOnlyBuffer> buffer_;
90
91  DISALLOW_COPY_AND_ASSIGN(DataSenderTest);
92};
93
94TEST_F(DataSenderTest, Send) {
95  expected_data_.push("aa");
96  RunTest("data_sender_unittest.js", "testSend");
97}
98
99TEST_F(DataSenderTest, LargeSend) {
100  std::string pattern = "1234567890";
101  std::string expected_data;
102  for (int i = 0; i < 110; i++)
103    expected_data += pattern;
104  expected_data_.push(expected_data);
105  RunTest("data_sender_unittest.js", "testLargeSend");
106}
107
108TEST_F(DataSenderTest, SendError) {
109  expected_data_.push("");
110  expected_data_.push("a");
111  error_to_report_.push(1);
112  RunTest("data_sender_unittest.js", "testSendError");
113}
114
115TEST_F(DataSenderTest, SendErrorPartialSuccess) {
116  expected_data_.push(std::string(5, 'b'));
117  expected_data_.push("a");
118  error_to_report_.push(1);
119  RunTest("data_sender_unittest.js", "testSendErrorPartialSuccess");
120}
121
122TEST_F(DataSenderTest, SendErrorBetweenPackets) {
123  expected_data_.push(std::string(2, 'b'));
124  expected_data_.push("a");
125  error_to_report_.push(1);
126  RunTest("data_sender_unittest.js", "testSendErrorBetweenPackets");
127}
128
129TEST_F(DataSenderTest, SendErrorInSecondPacket) {
130  expected_data_.push(std::string(3, 'b'));
131  expected_data_.push("a");
132  error_to_report_.push(1);
133  RunTest("data_sender_unittest.js", "testSendErrorInSecondPacket");
134}
135
136TEST_F(DataSenderTest, SendErrorInLargeSend) {
137  expected_data_.push("123456789012");
138  expected_data_.push("a");
139  error_to_report_.push(1);
140  RunTest("data_sender_unittest.js", "testSendErrorInLargeSend");
141}
142
143TEST_F(DataSenderTest, SendErrorBeforeLargeSend) {
144  expected_data_.push(std::string(2, 'b'));
145  expected_data_.push("a");
146  error_to_report_.push(1);
147  RunTest("data_sender_unittest.js", "testSendErrorBeforeLargeSend");
148}
149
150TEST_F(DataSenderTest, CancelWithoutSend) {
151  RunTest("data_sender_unittest.js", "testCancelWithoutSend");
152}
153
154TEST_F(DataSenderTest, Cancel) {
155  RunTest("data_sender_unittest.js", "testCancel");
156}
157
158TEST_F(DataSenderTest, Close) {
159  RunTest("data_sender_unittest.js", "testClose");
160}
161
162}  // namespace extensions
163