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 193
