| OLD | NEW |
|---|
| (Empty) |
| 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 <stddef.h> | |
| 6 #include <stdint.h> | |
| 7 | |
| 8 #include <utility> | |
| 9 | |
| 10 #include "base/macros.h" | |
| 11 #include "base/memory/ptr_util.h" | |
| 12 #include "base/threading/thread_task_runner_handle.h" | |
| 13 #include "device/serial/serial_device_enumerator.h" | |
| 14 #include "device/serial/serial_service_impl.h" | |
| 15 #include "device/serial/test_serial_io_handler.h" | |
| 16 #include "extensions/browser/mojo/stash_backend.h" | |
| 17 #include "extensions/common/mojo/keep_alive.mojom.h" | |
| 18 #include "extensions/renderer/api_test_base.h" | |
| 19 #include "grit/extensions_renderer_resources.h" | |
| 20 #include "mojo/public/cpp/bindings/strong_binding.h" | |
| 21 | |
| 22 // A test launcher for tests for the serial API defined in | |
| 23 // extensions/test/data/serial_unittest.js. Each C++ test function sets up a | |
| 24 // fake DeviceEnumerator or SerialIoHandler expecting or returning particular | |
| 25 // values for that test. | |
| 26 | |
| 27 namespace extensions { | |
| 28 | |
| 29 namespace { | |
| 30 | |
| 31 class FakeSerialDeviceEnumerator : public device::SerialDeviceEnumerator { | |
| 32 mojo::Array<device::serial::DeviceInfoPtr> GetDevices() override { | |
| 33 mojo::Array<device::serial::DeviceInfoPtr> result(3); | |
| 34 result[0] = device::serial::DeviceInfo::New(); | |
| 35 result[0]->path = "device"; | |
| 36 result[0]->vendor_id = 1234; | |
| 37 result[0]->has_vendor_id = true; | |
| 38 result[0]->product_id = 5678; | |
| 39 result[0]->has_product_id = true; | |
| 40 result[0]->display_name = "foo"; | |
| 41 result[1] = device::serial::DeviceInfo::New(); | |
| 42 result[1]->path = "another_device"; | |
| 43 // These IDs should be ignored. | |
| 44 result[1]->vendor_id = 1234; | |
| 45 result[1]->product_id = 5678; | |
| 46 result[2] = device::serial::DeviceInfo::New(); | |
| 47 result[2]->path = ""; | |
| 48 result[2]->display_name = ""; | |
| 49 return result; | |
| 50 } | |
| 51 }; | |
| 52 | |
| 53 enum OptionalValue { | |
| 54 OPTIONAL_VALUE_UNSET, | |
| 55 OPTIONAL_VALUE_FALSE, | |
| 56 OPTIONAL_VALUE_TRUE, | |
| 57 }; | |
| 58 | |
| 59 device::serial::HostControlSignals GenerateControlSignals(OptionalValue dtr, | |
| 60 OptionalValue rts) { | |
| 61 device::serial::HostControlSignals result; | |
| 62 switch (dtr) { | |
| 63 case OPTIONAL_VALUE_UNSET: | |
| 64 break; | |
| 65 case OPTIONAL_VALUE_FALSE: | |
| 66 result.dtr = false; | |
| 67 result.has_dtr = true; | |
| 68 break; | |
| 69 case OPTIONAL_VALUE_TRUE: | |
| 70 result.dtr = true; | |
| 71 result.has_dtr = true; | |
| 72 break; | |
| 73 } | |
| 74 switch (rts) { | |
| 75 case OPTIONAL_VALUE_UNSET: | |
| 76 break; | |
| 77 case OPTIONAL_VALUE_FALSE: | |
| 78 result.rts = false; | |
| 79 result.has_rts = true; | |
| 80 break; | |
| 81 case OPTIONAL_VALUE_TRUE: | |
| 82 result.rts = true; | |
| 83 result.has_rts = true; | |
| 84 break; | |
| 85 } | |
| 86 return result; | |
| 87 } | |
| 88 | |
| 89 device::serial::ConnectionOptions GenerateConnectionOptions( | |
| 90 int bitrate, | |
| 91 device::serial::DataBits data_bits, | |
| 92 device::serial::ParityBit parity_bit, | |
| 93 device::serial::StopBits stop_bits, | |
| 94 OptionalValue cts_flow_control) { | |
| 95 device::serial::ConnectionOptions result; | |
| 96 result.bitrate = bitrate; | |
| 97 result.data_bits = data_bits; | |
| 98 result.parity_bit = parity_bit; | |
| 99 result.stop_bits = stop_bits; | |
| 100 switch (cts_flow_control) { | |
| 101 case OPTIONAL_VALUE_UNSET: | |
| 102 break; | |
| 103 case OPTIONAL_VALUE_FALSE: | |
| 104 result.cts_flow_control = false; | |
| 105 result.has_cts_flow_control = true; | |
| 106 break; | |
| 107 case OPTIONAL_VALUE_TRUE: | |
| 108 result.cts_flow_control = true; | |
| 109 result.has_cts_flow_control = true; | |
| 110 break; | |
| 111 } | |
| 112 return result; | |
| 113 } | |
| 114 | |
| 115 class TestIoHandlerBase : public device::TestSerialIoHandler { | |
| 116 public: | |
| 117 TestIoHandlerBase() : calls_(0) {} | |
| 118 | |
| 119 size_t num_calls() const { return calls_; } | |
| 120 | |
| 121 protected: | |
| 122 ~TestIoHandlerBase() override {} | |
| 123 void record_call() const { calls_++; } | |
| 124 | |
| 125 private: | |
| 126 mutable size_t calls_; | |
| 127 | |
| 128 DISALLOW_COPY_AND_ASSIGN(TestIoHandlerBase); | |
| 129 }; | |
| 130 | |
| 131 class SetControlSignalsTestIoHandler : public TestIoHandlerBase { | |
| 132 public: | |
| 133 SetControlSignalsTestIoHandler() {} | |
| 134 | |
| 135 bool SetControlSignals( | |
| 136 const device::serial::HostControlSignals& signals) override { | |
| 137 static const device::serial::HostControlSignals expected_signals[] = { | |
| 138 GenerateControlSignals(OPTIONAL_VALUE_UNSET, OPTIONAL_VALUE_UNSET), | |
| 139 GenerateControlSignals(OPTIONAL_VALUE_FALSE, OPTIONAL_VALUE_UNSET), | |
| 140 GenerateControlSignals(OPTIONAL_VALUE_TRUE, OPTIONAL_VALUE_UNSET), | |
| 141 GenerateControlSignals(OPTIONAL_VALUE_UNSET, OPTIONAL_VALUE_FALSE), | |
| 142 GenerateControlSignals(OPTIONAL_VALUE_FALSE, OPTIONAL_VALUE_FALSE), | |
| 143 GenerateControlSignals(OPTIONAL_VALUE_TRUE, OPTIONAL_VALUE_FALSE), | |
| 144 GenerateControlSignals(OPTIONAL_VALUE_UNSET, OPTIONAL_VALUE_TRUE), | |
| 145 GenerateControlSignals(OPTIONAL_VALUE_FALSE, OPTIONAL_VALUE_TRUE), | |
| 146 GenerateControlSignals(OPTIONAL_VALUE_TRUE, OPTIONAL_VALUE_TRUE), | |
| 147 }; | |
| 148 if (num_calls() >= arraysize(expected_signals)) | |
| 149 return false; | |
| 150 | |
| 151 EXPECT_EQ(expected_signals[num_calls()].has_dtr, signals.has_dtr); | |
| 152 EXPECT_EQ(expected_signals[num_calls()].dtr, signals.dtr); | |
| 153 EXPECT_EQ(expected_signals[num_calls()].has_rts, signals.has_rts); | |
| 154 EXPECT_EQ(expected_signals[num_calls()].rts, signals.rts); | |
| 155 record_call(); | |
| 156 return true; | |
| 157 } | |
| 158 | |
| 159 private: | |
| 160 ~SetControlSignalsTestIoHandler() override {} | |
| 161 | |
| 162 DISALLOW_COPY_AND_ASSIGN(SetControlSignalsTestIoHandler); | |
| 163 }; | |
| 164 | |
| 165 class GetControlSignalsTestIoHandler : public TestIoHandlerBase { | |
| 166 public: | |
| 167 GetControlSignalsTestIoHandler() {} | |
| 168 | |
| 169 device::serial::DeviceControlSignalsPtr GetControlSignals() const override { | |
| 170 device::serial::DeviceControlSignalsPtr signals( | |
| 171 device::serial::DeviceControlSignals::New()); | |
| 172 signals->dcd = num_calls() & 1; | |
| 173 signals->cts = num_calls() & 2; | |
| 174 signals->ri = num_calls() & 4; | |
| 175 signals->dsr = num_calls() & 8; | |
| 176 record_call(); | |
| 177 return signals; | |
| 178 } | |
| 179 | |
| 180 private: | |
| 181 ~GetControlSignalsTestIoHandler() override {} | |
| 182 | |
| 183 DISALLOW_COPY_AND_ASSIGN(GetControlSignalsTestIoHandler); | |
| 184 }; | |
| 185 | |
| 186 class ConfigurePortTestIoHandler : public TestIoHandlerBase { | |
| 187 public: | |
| 188 ConfigurePortTestIoHandler() {} | |
| 189 bool ConfigurePortImpl() override { | |
| 190 static const device::serial::ConnectionOptions expected_options[] = { | |
| 191 // Each JavaScript call to chrome.serial.update only modifies a single | |
| 192 // property of the connection however this function can only check the | |
| 193 // final value of all options. The modified option is marked with "set". | |
| 194 GenerateConnectionOptions(9600, device::serial::DataBits::EIGHT, | |
| 195 device::serial::ParityBit::NO, | |
| 196 device::serial::StopBits::ONE, | |
| 197 OPTIONAL_VALUE_FALSE), | |
| 198 GenerateConnectionOptions( | |
| 199 57600, // set | |
| 200 device::serial::DataBits::EIGHT, device::serial::ParityBit::NO, | |
| 201 device::serial::StopBits::ONE, OPTIONAL_VALUE_FALSE), | |
| 202 GenerateConnectionOptions(57600, | |
| 203 device::serial::DataBits::SEVEN, // set | |
| 204 device::serial::ParityBit::NO, | |
| 205 device::serial::StopBits::ONE, | |
| 206 OPTIONAL_VALUE_FALSE), | |
| 207 GenerateConnectionOptions(57600, | |
| 208 device::serial::DataBits::EIGHT, // set | |
| 209 device::serial::ParityBit::NO, | |
| 210 device::serial::StopBits::ONE, | |
| 211 OPTIONAL_VALUE_FALSE), | |
| 212 GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT, | |
| 213 device::serial::ParityBit::NO, // set | |
| 214 device::serial::StopBits::ONE, | |
| 215 OPTIONAL_VALUE_FALSE), | |
| 216 GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT, | |
| 217 device::serial::ParityBit::ODD, // set | |
| 218 device::serial::StopBits::ONE, | |
| 219 OPTIONAL_VALUE_FALSE), | |
| 220 GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT, | |
| 221 device::serial::ParityBit::EVEN, // set | |
| 222 device::serial::StopBits::ONE, | |
| 223 OPTIONAL_VALUE_FALSE), | |
| 224 GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT, | |
| 225 device::serial::ParityBit::EVEN, | |
| 226 device::serial::StopBits::ONE, // set | |
| 227 OPTIONAL_VALUE_FALSE), | |
| 228 GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT, | |
| 229 device::serial::ParityBit::EVEN, | |
| 230 device::serial::StopBits::TWO, // set | |
| 231 OPTIONAL_VALUE_FALSE), | |
| 232 GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT, | |
| 233 device::serial::ParityBit::EVEN, | |
| 234 device::serial::StopBits::TWO, | |
| 235 OPTIONAL_VALUE_FALSE), // set | |
| 236 GenerateConnectionOptions(57600, device::serial::DataBits::EIGHT, | |
| 237 device::serial::ParityBit::EVEN, | |
| 238 device::serial::StopBits::TWO, | |
| 239 OPTIONAL_VALUE_TRUE), // set | |
| 240 }; | |
| 241 | |
| 242 if (!TestIoHandlerBase::ConfigurePortImpl()) { | |
| 243 return false; | |
| 244 } | |
| 245 | |
| 246 if (num_calls() >= arraysize(expected_options)) { | |
| 247 return false; | |
| 248 } | |
| 249 | |
| 250 EXPECT_EQ(expected_options[num_calls()].bitrate, options().bitrate); | |
| 251 EXPECT_EQ(expected_options[num_calls()].data_bits, options().data_bits); | |
| 252 EXPECT_EQ(expected_options[num_calls()].parity_bit, options().parity_bit); | |
| 253 EXPECT_EQ(expected_options[num_calls()].stop_bits, options().stop_bits); | |
| 254 EXPECT_EQ(expected_options[num_calls()].has_cts_flow_control, | |
| 255 options().has_cts_flow_control); | |
| 256 EXPECT_EQ(expected_options[num_calls()].cts_flow_control, | |
| 257 options().cts_flow_control); | |
| 258 record_call(); | |
| 259 return true; | |
| 260 } | |
| 261 | |
| 262 private: | |
| 263 ~ConfigurePortTestIoHandler() override {} | |
| 264 | |
| 265 DISALLOW_COPY_AND_ASSIGN(ConfigurePortTestIoHandler); | |
| 266 }; | |
| 267 | |
| 268 class FlushTestIoHandler : public TestIoHandlerBase { | |
| 269 public: | |
| 270 FlushTestIoHandler() {} | |
| 271 | |
| 272 bool Flush() const override { | |
| 273 record_call(); | |
| 274 return true; | |
| 275 } | |
| 276 | |
| 277 private: | |
| 278 ~FlushTestIoHandler() override {} | |
| 279 | |
| 280 DISALLOW_COPY_AND_ASSIGN(FlushTestIoHandler); | |
| 281 }; | |
| 282 | |
| 283 class FailToConnectTestIoHandler : public TestIoHandlerBase { | |
| 284 public: | |
| 285 FailToConnectTestIoHandler() {} | |
| 286 void Open(const std::string& port, | |
| 287 const device::serial::ConnectionOptions& options, | |
| 288 const OpenCompleteCallback& callback) override { | |
| 289 callback.Run(false); | |
| 290 return; | |
| 291 } | |
| 292 | |
| 293 private: | |
| 294 ~FailToConnectTestIoHandler() override {} | |
| 295 | |
| 296 DISALLOW_COPY_AND_ASSIGN(FailToConnectTestIoHandler); | |
| 297 }; | |
| 298 | |
| 299 class FailToGetInfoTestIoHandler : public TestIoHandlerBase { | |
| 300 public: | |
| 301 explicit FailToGetInfoTestIoHandler(int times_to_succeed) | |
| 302 : times_to_succeed_(times_to_succeed) {} | |
| 303 device::serial::ConnectionInfoPtr GetPortInfo() const override { | |
| 304 if (times_to_succeed_-- > 0) | |
| 305 return device::TestSerialIoHandler::GetPortInfo(); | |
| 306 return device::serial::ConnectionInfoPtr(); | |
| 307 } | |
| 308 | |
| 309 private: | |
| 310 ~FailToGetInfoTestIoHandler() override {} | |
| 311 | |
| 312 mutable int times_to_succeed_; | |
| 313 | |
| 314 DISALLOW_COPY_AND_ASSIGN(FailToGetInfoTestIoHandler); | |
| 315 }; | |
| 316 | |
| 317 class SendErrorTestIoHandler : public TestIoHandlerBase { | |
| 318 public: | |
| 319 explicit SendErrorTestIoHandler(device::serial::SendError error) | |
| 320 : error_(error) {} | |
| 321 | |
| 322 void WriteImpl() override { QueueWriteCompleted(0, error_); } | |
| 323 | |
| 324 private: | |
| 325 ~SendErrorTestIoHandler() override {} | |
| 326 | |
| 327 device::serial::SendError error_; | |
| 328 | |
| 329 DISALLOW_COPY_AND_ASSIGN(SendErrorTestIoHandler); | |
| 330 }; | |
| 331 | |
| 332 class FixedDataReceiveTestIoHandler : public TestIoHandlerBase { | |
| 333 public: | |
| 334 explicit FixedDataReceiveTestIoHandler(const std::string& data) | |
| 335 : data_(data) {} | |
| 336 | |
| 337 void ReadImpl() override { | |
| 338 if (pending_read_buffer_len() < data_.size()) | |
| 339 return; | |
| 340 memcpy(pending_read_buffer(), data_.c_str(), data_.size()); | |
| 341 QueueReadCompleted(static_cast<uint32_t>(data_.size()), | |
| 342 device::serial::ReceiveError::NONE); | |
| 343 } | |
| 344 | |
| 345 private: | |
| 346 ~FixedDataReceiveTestIoHandler() override {} | |
| 347 | |
| 348 const std::string data_; | |
| 349 | |
| 350 DISALLOW_COPY_AND_ASSIGN(FixedDataReceiveTestIoHandler); | |
| 351 }; | |
| 352 | |
| 353 class ReceiveErrorTestIoHandler : public TestIoHandlerBase { | |
| 354 public: | |
| 355 explicit ReceiveErrorTestIoHandler(device::serial::ReceiveError error) | |
| 356 : error_(error) {} | |
| 357 | |
| 358 void ReadImpl() override { QueueReadCompleted(0, error_); } | |
| 359 | |
| 360 private: | |
| 361 ~ReceiveErrorTestIoHandler() override {} | |
| 362 | |
| 363 device::serial::ReceiveError error_; | |
| 364 | |
| 365 DISALLOW_COPY_AND_ASSIGN(ReceiveErrorTestIoHandler); | |
| 366 }; | |
| 367 | |
| 368 class SendDataWithErrorIoHandler : public TestIoHandlerBase { | |
| 369 public: | |
| 370 SendDataWithErrorIoHandler() : sent_error_(false) {} | |
| 371 void WriteImpl() override { | |
| 372 if (sent_error_) { | |
| 373 WriteCompleted(pending_write_buffer_len(), | |
| 374 device::serial::SendError::NONE); | |
| 375 return; | |
| 376 } | |
| 377 sent_error_ = true; | |
| 378 // We expect the JS test code to send a 4 byte buffer. | |
| 379 ASSERT_LT(2u, pending_write_buffer_len()); | |
| 380 WriteCompleted(2, device::serial::SendError::SYSTEM_ERROR); | |
| 381 } | |
| 382 | |
| 383 private: | |
| 384 ~SendDataWithErrorIoHandler() override {} | |
| 385 | |
| 386 bool sent_error_; | |
| 387 | |
| 388 DISALLOW_COPY_AND_ASSIGN(SendDataWithErrorIoHandler); | |
| 389 }; | |
| 390 | |
| 391 class BlockSendsForeverSendIoHandler : public TestIoHandlerBase { | |
| 392 public: | |
| 393 BlockSendsForeverSendIoHandler() {} | |
| 394 void WriteImpl() override {} | |
| 395 | |
| 396 private: | |
| 397 ~BlockSendsForeverSendIoHandler() override {} | |
| 398 | |
| 399 DISALLOW_COPY_AND_ASSIGN(BlockSendsForeverSendIoHandler); | |
| 400 }; | |
| 401 | |
| 402 } // namespace | |
| 403 | |
| 404 class SerialApiTest : public ApiTestBase { | |
| 405 public: | |
| 406 SerialApiTest() {} | |
| 407 | |
| 408 void SetUp() override { | |
| 409 ApiTestBase::SetUp(); | |
| 410 stash_backend_.reset(new StashBackend(base::Closure())); | |
| 411 PrepareEnvironment(api_test_env(), stash_backend_.get()); | |
| 412 } | |
| 413 | |
| 414 void PrepareEnvironment(ApiTestEnvironment* environment, | |
| 415 StashBackend* stash_backend) { | |
| 416 environment->env()->RegisterModule("serial", IDR_SERIAL_CUSTOM_BINDINGS_JS); | |
| 417 environment->interface_provider()-> | |
| 418 AddInterface<device::serial::SerialService>( | |
| 419 base::Bind(&SerialApiTest::CreateSerialService, | |
| 420 base::Unretained(this))); | |
| 421 environment->interface_provider()->AddInterface(base::Bind( | |
| 422 &StashBackend::BindToRequest, base::Unretained(stash_backend))); | |
| 423 environment->interface_provider()->IgnoreInterfaceRequests<KeepAlive>(); | |
| 424 } | |
| 425 | |
| 426 scoped_refptr<TestIoHandlerBase> io_handler_; | |
| 427 | |
| 428 std::unique_ptr<StashBackend> stash_backend_; | |
| 429 | |
| 430 private: | |
| 431 scoped_refptr<device::SerialIoHandler> GetIoHandler() { | |
| 432 if (!io_handler_.get()) | |
| 433 io_handler_ = new TestIoHandlerBase; | |
| 434 return io_handler_; | |
| 435 } | |
| 436 | |
| 437 void CreateSerialService( | |
| 438 mojo::InterfaceRequest<device::serial::SerialService> request) { | |
| 439 mojo::MakeStrongBinding(base::MakeUnique<device::SerialServiceImpl>( | |
| 440 new device::SerialConnectionFactory( | |
| 441 base::Bind(&SerialApiTest::GetIoHandler, | |
| 442 base::Unretained(this)), | |
| 443 base::ThreadTaskRunnerHandle::Get()), | |
| 444 base::MakeUnique<FakeSerialDeviceEnumerator>()), | |
| 445 std::move(request)); | |
| 446 } | |
| 447 | |
| 448 DISALLOW_COPY_AND_ASSIGN(SerialApiTest); | |
| 449 }; | |
| 450 | |
| 451 TEST_F(SerialApiTest, GetDevices) { | |
| 452 RunTest("serial_unittest.js", "testGetDevices"); | |
| 453 } | |
| 454 | |
| 455 TEST_F(SerialApiTest, ConnectFail) { | |
| 456 io_handler_ = new FailToConnectTestIoHandler; | |
| 457 RunTest("serial_unittest.js", "testConnectFail"); | |
| 458 } | |
| 459 | |
| 460 TEST_F(SerialApiTest, GetInfoFailOnConnect) { | |
| 461 io_handler_ = new FailToGetInfoTestIoHandler(0); | |
| 462 RunTest("serial_unittest.js", "testGetInfoFailOnConnect"); | |
| 463 } | |
| 464 | |
| 465 TEST_F(SerialApiTest, Connect) { | |
| 466 RunTest("serial_unittest.js", "testConnect"); | |
| 467 } | |
| 468 | |
| 469 TEST_F(SerialApiTest, ConnectDefaultOptions) { | |
| 470 RunTest("serial_unittest.js", "testConnectDefaultOptions"); | |
| 471 } | |
| 472 | |
| 473 TEST_F(SerialApiTest, ConnectInvalidBitrate) { | |
| 474 RunTest("serial_unittest.js", "testConnectInvalidBitrate"); | |
| 475 } | |
| 476 | |
| 477 TEST_F(SerialApiTest, GetInfo) { | |
| 478 RunTest("serial_unittest.js", "testGetInfo"); | |
| 479 } | |
| 480 | |
| 481 TEST_F(SerialApiTest, GetInfoAfterSerialization) { | |
| 482 RunTest("serial_unittest.js", "testGetInfoAfterSerialization"); | |
| 483 } | |
| 484 | |
| 485 TEST_F(SerialApiTest, GetInfoFailToGetPortInfo) { | |
| 486 io_handler_ = new FailToGetInfoTestIoHandler(1); | |
| 487 RunTest("serial_unittest.js", "testGetInfoFailToGetPortInfo"); | |
| 488 } | |
| 489 | |
| 490 TEST_F(SerialApiTest, GetConnections) { | |
| 491 RunTest("serial_unittest.js", "testGetConnections"); | |
| 492 } | |
| 493 | |
| 494 // https://crbug.com/599898 | |
| 495 #if defined(LEAK_SANITIZER) | |
| 496 #define MAYBE_GetControlSignals DISABLED_GetControlSignals | |
| 497 #else | |
| 498 #define MAYBE_GetControlSignals GetControlSignals | |
| 499 #endif | |
| 500 TEST_F(SerialApiTest, MAYBE_GetControlSignals) { | |
| 501 io_handler_ = new GetControlSignalsTestIoHandler; | |
| 502 RunTest("serial_unittest.js", "testGetControlSignals"); | |
| 503 EXPECT_EQ(16u, io_handler_->num_calls()); | |
| 504 } | |
| 505 | |
| 506 TEST_F(SerialApiTest, SetControlSignals) { | |
| 507 io_handler_ = new SetControlSignalsTestIoHandler; | |
| 508 RunTest("serial_unittest.js", "testSetControlSignals"); | |
| 509 EXPECT_EQ(9u, io_handler_->num_calls()); | |
| 510 } | |
| 511 | |
| 512 // https://crbug.com/599898 | |
| 513 #if defined(LEAK_SANITIZER) | |
| 514 #define MAYBE_Update DISABLED_Update | |
| 515 #else | |
| 516 #define MAYBE_Update Update | |
| 517 #endif | |
| 518 TEST_F(SerialApiTest, MAYBE_Update) { | |
| 519 io_handler_ = new ConfigurePortTestIoHandler; | |
| 520 RunTest("serial_unittest.js", "testUpdate"); | |
| 521 EXPECT_EQ(11u, io_handler_->num_calls()); | |
| 522 } | |
| 523 | |
| 524 // https://crbug.com/599898 | |
| 525 #if defined(LEAK_SANITIZER) | |
| 526 #define MAYBE_UpdateAcrossSerialization DISABLED_UpdateAcrossSerialization | |
| 527 #else | |
| 528 #define MAYBE_UpdateAcrossSerialization UpdateAcrossSerialization | |
| 529 #endif | |
| 530 TEST_F(SerialApiTest, MAYBE_UpdateAcrossSerialization) { | |
| 531 io_handler_ = new ConfigurePortTestIoHandler; | |
| 532 RunTest("serial_unittest.js", "testUpdateAcrossSerialization"); | |
| 533 EXPECT_EQ(11u, io_handler_->num_calls()); | |
| 534 } | |
| 535 | |
| 536 TEST_F(SerialApiTest, UpdateInvalidBitrate) { | |
| 537 io_handler_ = new ConfigurePortTestIoHandler; | |
| 538 RunTest("serial_unittest.js", "testUpdateInvalidBitrate"); | |
| 539 EXPECT_EQ(1u, io_handler_->num_calls()); | |
| 540 } | |
| 541 | |
| 542 TEST_F(SerialApiTest, Flush) { | |
| 543 io_handler_ = new FlushTestIoHandler; | |
| 544 RunTest("serial_unittest.js", "testFlush"); | |
| 545 EXPECT_EQ(1u, io_handler_->num_calls()); | |
| 546 } | |
| 547 | |
| 548 TEST_F(SerialApiTest, SetPaused) { | |
| 549 RunTest("serial_unittest.js", "testSetPaused"); | |
| 550 } | |
| 551 | |
| 552 TEST_F(SerialApiTest, Echo) { | |
| 553 RunTest("serial_unittest.js", "testEcho"); | |
| 554 } | |
| 555 | |
| 556 TEST_F(SerialApiTest, EchoAfterSerialization) { | |
| 557 RunTest("serial_unittest.js", "testEchoAfterSerialization"); | |
| 558 } | |
| 559 | |
| 560 TEST_F(SerialApiTest, SendDuringExistingSend) { | |
| 561 RunTest("serial_unittest.js", "testSendDuringExistingSend"); | |
| 562 } | |
| 563 | |
| 564 TEST_F(SerialApiTest, SendAfterSuccessfulSend) { | |
| 565 RunTest("serial_unittest.js", "testSendAfterSuccessfulSend"); | |
| 566 } | |
| 567 | |
| 568 TEST_F(SerialApiTest, SendPartialSuccessWithError) { | |
| 569 io_handler_ = new SendDataWithErrorIoHandler(); | |
| 570 RunTest("serial_unittest.js", "testSendPartialSuccessWithError"); | |
| 571 } | |
| 572 | |
| 573 TEST_F(SerialApiTest, SendTimeout) { | |
| 574 io_handler_ = new BlockSendsForeverSendIoHandler(); | |
| 575 RunTest("serial_unittest.js", "testSendTimeout"); | |
| 576 } | |
| 577 | |
| 578 TEST_F(SerialApiTest, SendTimeoutAfterSerialization) { | |
| 579 io_handler_ = new BlockSendsForeverSendIoHandler(); | |
| 580 RunTest("serial_unittest.js", "testSendTimeoutAfterSerialization"); | |
| 581 } | |
| 582 | |
| 583 TEST_F(SerialApiTest, DisableSendTimeout) { | |
| 584 io_handler_ = new BlockSendsForeverSendIoHandler(); | |
| 585 RunTest("serial_unittest.js", "testDisableSendTimeout"); | |
| 586 } | |
| 587 | |
| 588 TEST_F(SerialApiTest, PausedReceive) { | |
| 589 io_handler_ = new FixedDataReceiveTestIoHandler("data"); | |
| 590 RunTest("serial_unittest.js", "testPausedReceive"); | |
| 591 } | |
| 592 | |
| 593 TEST_F(SerialApiTest, PausedReceiveError) { | |
| 594 io_handler_ = | |
| 595 new ReceiveErrorTestIoHandler(device::serial::ReceiveError::DEVICE_LOST); | |
| 596 RunTest("serial_unittest.js", "testPausedReceiveError"); | |
| 597 } | |
| 598 | |
| 599 TEST_F(SerialApiTest, ReceiveTimeout) { | |
| 600 RunTest("serial_unittest.js", "testReceiveTimeout"); | |
| 601 } | |
| 602 | |
| 603 TEST_F(SerialApiTest, ReceiveTimeoutAfterSerialization) { | |
| 604 RunTest("serial_unittest.js", "testReceiveTimeoutAfterSerialization"); | |
| 605 } | |
| 606 | |
| 607 TEST_F(SerialApiTest, DisableReceiveTimeout) { | |
| 608 RunTest("serial_unittest.js", "testDisableReceiveTimeout"); | |
| 609 } | |
| 610 | |
| 611 TEST_F(SerialApiTest, ReceiveErrorDisconnected) { | |
| 612 io_handler_ = | |
| 613 new ReceiveErrorTestIoHandler(device::serial::ReceiveError::DISCONNECTED); | |
| 614 RunTest("serial_unittest.js", "testReceiveErrorDisconnected"); | |
| 615 } | |
| 616 | |
| 617 TEST_F(SerialApiTest, ReceiveErrorDeviceLost) { | |
| 618 io_handler_ = | |
| 619 new ReceiveErrorTestIoHandler(device::serial::ReceiveError::DEVICE_LOST); | |
| 620 RunTest("serial_unittest.js", "testReceiveErrorDeviceLost"); | |
| 621 } | |
| 622 | |
| 623 TEST_F(SerialApiTest, ReceiveErrorBreak) { | |
| 624 io_handler_ = | |
| 625 new ReceiveErrorTestIoHandler(device::serial::ReceiveError::BREAK); | |
| 626 RunTest("serial_unittest.js", "testReceiveErrorBreak"); | |
| 627 } | |
| 628 | |
| 629 TEST_F(SerialApiTest, ReceiveErrorFrameError) { | |
| 630 io_handler_ = | |
| 631 new ReceiveErrorTestIoHandler(device::serial::ReceiveError::FRAME_ERROR); | |
| 632 RunTest("serial_unittest.js", "testReceiveErrorFrameError"); | |
| 633 } | |
| 634 | |
| 635 TEST_F(SerialApiTest, ReceiveErrorOverrun) { | |
| 636 io_handler_ = | |
| 637 new ReceiveErrorTestIoHandler(device::serial::ReceiveError::OVERRUN); | |
| 638 RunTest("serial_unittest.js", "testReceiveErrorOverrun"); | |
| 639 } | |
| 640 | |
| 641 TEST_F(SerialApiTest, ReceiveErrorBufferOverflow) { | |
| 642 io_handler_ = new ReceiveErrorTestIoHandler( | |
| 643 device::serial::ReceiveError::BUFFER_OVERFLOW); | |
| 644 RunTest("serial_unittest.js", "testReceiveErrorBufferOverflow"); | |
| 645 } | |
| 646 | |
| 647 TEST_F(SerialApiTest, ReceiveErrorParityError) { | |
| 648 io_handler_ = | |
| 649 new ReceiveErrorTestIoHandler(device::serial::ReceiveError::PARITY_ERROR); | |
| 650 RunTest("serial_unittest.js", "testReceiveErrorParityError"); | |
| 651 } | |
| 652 | |
| 653 TEST_F(SerialApiTest, ReceiveErrorSystemError) { | |
| 654 io_handler_ = | |
| 655 new ReceiveErrorTestIoHandler(device::serial::ReceiveError::SYSTEM_ERROR); | |
| 656 RunTest("serial_unittest.js", "testReceiveErrorSystemError"); | |
| 657 } | |
| 658 | |
| 659 TEST_F(SerialApiTest, SendErrorDisconnected) { | |
| 660 io_handler_ = | |
| 661 new SendErrorTestIoHandler(device::serial::SendError::DISCONNECTED); | |
| 662 RunTest("serial_unittest.js", "testSendErrorDisconnected"); | |
| 663 } | |
| 664 | |
| 665 TEST_F(SerialApiTest, SendErrorSystemError) { | |
| 666 io_handler_ = | |
| 667 new SendErrorTestIoHandler(device::serial::SendError::SYSTEM_ERROR); | |
| 668 RunTest("serial_unittest.js", "testSendErrorSystemError"); | |
| 669 } | |
| 670 | |
| 671 TEST_F(SerialApiTest, DisconnectUnknownConnectionId) { | |
| 672 RunTest("serial_unittest.js", "testDisconnectUnknownConnectionId"); | |
| 673 } | |
| 674 | |
| 675 TEST_F(SerialApiTest, GetInfoUnknownConnectionId) { | |
| 676 RunTest("serial_unittest.js", "testGetInfoUnknownConnectionId"); | |
| 677 } | |
| 678 | |
| 679 TEST_F(SerialApiTest, UpdateUnknownConnectionId) { | |
| 680 RunTest("serial_unittest.js", "testUpdateUnknownConnectionId"); | |
| 681 } | |
| 682 | |
| 683 TEST_F(SerialApiTest, SetControlSignalsUnknownConnectionId) { | |
| 684 RunTest("serial_unittest.js", "testSetControlSignalsUnknownConnectionId"); | |
| 685 } | |
| 686 | |
| 687 TEST_F(SerialApiTest, GetControlSignalsUnknownConnectionId) { | |
| 688 RunTest("serial_unittest.js", "testGetControlSignalsUnknownConnectionId"); | |
| 689 } | |
| 690 | |
| 691 TEST_F(SerialApiTest, FlushUnknownConnectionId) { | |
| 692 RunTest("serial_unittest.js", "testFlushUnknownConnectionId"); | |
| 693 } | |
| 694 | |
| 695 TEST_F(SerialApiTest, SetPausedUnknownConnectionId) { | |
| 696 RunTest("serial_unittest.js", "testSetPausedUnknownConnectionId"); | |
| 697 } | |
| 698 | |
| 699 TEST_F(SerialApiTest, SendUnknownConnectionId) { | |
| 700 RunTest("serial_unittest.js", "testSendUnknownConnectionId"); | |
| 701 } | |
| 702 | |
| 703 // Note: these tests are disabled, since there is no good story for persisting | |
| 704 // the stashed handles when an extension process is shut down. See | |
| 705 // https://crbug.com/538774 | |
| 706 TEST_F(SerialApiTest, DISABLED_StashAndRestoreDuringEcho) { | |
| 707 ASSERT_NO_FATAL_FAILURE(RunTest("serial_unittest.js", "testSendAndStash")); | |
| 708 std::unique_ptr<ModuleSystemTestEnvironment> new_env(CreateEnvironment()); | |
| 709 ApiTestEnvironment new_api_test_env(new_env.get()); | |
| 710 PrepareEnvironment(&new_api_test_env, stash_backend_.get()); | |
| 711 new_api_test_env.RunTest("serial_unittest.js", "testRestoreAndReceive"); | |
| 712 } | |
| 713 | |
| 714 TEST_F(SerialApiTest, DISABLED_StashAndRestoreDuringEchoError) { | |
| 715 io_handler_ = | |
| 716 new ReceiveErrorTestIoHandler(device::serial::ReceiveError::DEVICE_LOST); | |
| 717 ASSERT_NO_FATAL_FAILURE( | |
| 718 RunTest("serial_unittest.js", "testRestoreAndReceiveErrorSetUp")); | |
| 719 std::unique_ptr<ModuleSystemTestEnvironment> new_env(CreateEnvironment()); | |
| 720 ApiTestEnvironment new_api_test_env(new_env.get()); | |
| 721 PrepareEnvironment(&new_api_test_env, stash_backend_.get()); | |
| 722 new_api_test_env.RunTest("serial_unittest.js", "testRestoreAndReceiveError"); | |
| 723 } | |
| 724 | |
| 725 // https://crbug.com/599898 | |
| 726 #if defined(LEAK_SANITIZER) | |
| 727 #define MAYBE_StashAndRestoreNoConnections DISABLED_StashAndRestoreNoConnections | |
| 728 #else | |
| 729 #define MAYBE_StashAndRestoreNoConnections StashAndRestoreNoConnections | |
| 730 #endif | |
| 731 TEST_F(SerialApiTest, MAYBE_StashAndRestoreNoConnections) { | |
| 732 ASSERT_NO_FATAL_FAILURE( | |
| 733 RunTest("serial_unittest.js", "testStashNoConnections")); | |
| 734 io_handler_ = nullptr; | |
| 735 std::unique_ptr<ModuleSystemTestEnvironment> new_env(CreateEnvironment()); | |
| 736 ApiTestEnvironment new_api_test_env(new_env.get()); | |
| 737 PrepareEnvironment(&new_api_test_env, stash_backend_.get()); | |
| 738 new_api_test_env.RunTest("serial_unittest.js", "testRestoreNoConnections"); | |
| 739 } | |
| 740 | |
| 741 } // namespace extensions | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2410743002:
Remove the mojo serial interfaces and related infrastructure. (Closed)
