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 "device/serial/serial_device_enumerator.h" 6 #include "device/serial/serial_service_impl.h" 7 #include "device/serial/test_serial_io_handler.h" 8 #include "extensions/renderer/api_test_base.h" 9 #include "grit/extensions_renderer_resources.h" 10 11 // A test launcher for tests for the serial API defined in 12 // extensions/test/data/serial_unittest.js. Each C++ test function sets up a 13 // fake DeviceEnumerator or SerialIoHandler expecting or returning particular 14 // values for that test. 15 16 namespace extensions { 17 18 namespace { 19 20 class FakeSerialDeviceEnumerator : public device::SerialDeviceEnumerator { 21 virtual mojo::Array<device::serial::DeviceInfoPtr> GetDevices() OVERRIDE { 22 mojo::Array<device::serial::DeviceInfoPtr> result(3); 23 result[0] = device::serial::DeviceInfo::New(); 24 result[0]->path = "device"; 25 result[0]->vendor_id = 1234; 26 result[0]->has_vendor_id = true; 27 result[0]->product_id = 5678; 28 result[0]->has_product_id = true; 29 result[0]->display_name = "foo"; 30 result[1] = device::serial::DeviceInfo::New(); 31 result[1]->path = "another_device"; 32 // These IDs should be ignored. 33 result[1]->vendor_id = 1234; 34 result[1]->product_id = 5678; 35 result[2] = device::serial::DeviceInfo::New(); 36 result[2]->path = ""; 37 result[2]->display_name = ""; 38 return result.Pass(); 39 } 40 }; 41 42 enum OptionalValue { 43 OPTIONAL_VALUE_UNSET, 44 OPTIONAL_VALUE_FALSE, 45 OPTIONAL_VALUE_TRUE, 46 }; 47 48 device::serial::HostControlSignals GenerateControlSignals(OptionalValue dtr, 49 OptionalValue rts) { 50 device::serial::HostControlSignals result; 51 switch (dtr) { 52 case OPTIONAL_VALUE_UNSET: 53 break; 54 case OPTIONAL_VALUE_FALSE: 55 result.dtr = false; 56 result.has_dtr = true; 57 break; 58 case OPTIONAL_VALUE_TRUE: 59 result.dtr = true; 60 result.has_dtr = true; 61 break; 62 } 63 switch (rts) { 64 case OPTIONAL_VALUE_UNSET: 65 break; 66 case OPTIONAL_VALUE_FALSE: 67 result.rts = false; 68 result.has_rts = true; 69 break; 70 case OPTIONAL_VALUE_TRUE: 71 result.rts = true; 72 result.has_rts = true; 73 break; 74 } 75 return result; 76 } 77 78 device::serial::ConnectionOptions GenerateConnectionOptions( 79 int bitrate, 80 device::serial::DataBits data_bits, 81 device::serial::ParityBit parity_bit, 82 device::serial::StopBits stop_bits, 83 OptionalValue cts_flow_control) { 84 device::serial::ConnectionOptions result; 85 result.bitrate = bitrate; 86 result.data_bits = data_bits; 87 result.parity_bit = parity_bit; 88 result.stop_bits = stop_bits; 89 switch (cts_flow_control) { 90 case OPTIONAL_VALUE_UNSET: 91 break; 92 case OPTIONAL_VALUE_FALSE: 93 result.cts_flow_control = false; 94 result.has_cts_flow_control = true; 95 break; 96 case OPTIONAL_VALUE_TRUE: 97 result.cts_flow_control = true; 98 result.has_cts_flow_control = true; 99 break; 100 } 101 return result; 102 } 103 104 class TestIoHandlerBase : public device::TestSerialIoHandler { 105 public: 106 TestIoHandlerBase() : calls_(0) {} 107 108 size_t num_calls() const { return calls_; } 109 110 protected: 111 virtual ~TestIoHandlerBase() {} 112 void record_call() const { calls_++; } 113 114 private: 115 mutable size_t calls_; 116 117 DISALLOW_COPY_AND_ASSIGN(TestIoHandlerBase); 118 }; 119 120 class SetControlSignalsTestIoHandler : public TestIoHandlerBase { 121 public: 122 SetControlSignalsTestIoHandler() {} 123 124 virtual bool SetControlSignals( 125 const device::serial::HostControlSignals& signals) OVERRIDE { 126 static const device::serial::HostControlSignals expected_signals[] = { 127 GenerateControlSignals(OPTIONAL_VALUE_UNSET, OPTIONAL_VALUE_UNSET), 128 GenerateControlSignals(OPTIONAL_VALUE_FALSE, OPTIONAL_VALUE_UNSET), 129 GenerateControlSignals(OPTIONAL_VALUE_TRUE, OPTIONAL_VALUE_UNSET), 130 GenerateControlSignals(OPTIONAL_VALUE_UNSET, OPTIONAL_VALUE_FALSE), 131 GenerateControlSignals(OPTIONAL_VALUE_FALSE, OPTIONAL_VALUE_FALSE), 132 GenerateControlSignals(OPTIONAL_VALUE_TRUE, OPTIONAL_VALUE_FALSE), 133 GenerateControlSignals(OPTIONAL_VALUE_UNSET, OPTIONAL_VALUE_TRUE), 134 GenerateControlSignals(OPTIONAL_VALUE_FALSE, OPTIONAL_VALUE_TRUE), 135 GenerateControlSignals(OPTIONAL_VALUE_TRUE, OPTIONAL_VALUE_TRUE), 136 }; 137 if (num_calls() >= arraysize(expected_signals)) 138 return false; 139 140 EXPECT_EQ(expected_signals[num_calls()].has_dtr, signals.has_dtr); 141 EXPECT_EQ(expected_signals[num_calls()].dtr, signals.dtr); 142 EXPECT_EQ(expected_signals[num_calls()].has_rts, signals.has_rts); 143 EXPECT_EQ(expected_signals[num_calls()].rts, signals.rts); 144 record_call(); 145 return true; 146 } 147 148 private: 149 virtual ~SetControlSignalsTestIoHandler() {} 150 151 DISALLOW_COPY_AND_ASSIGN(SetControlSignalsTestIoHandler); 152 }; 153 154 class GetControlSignalsTestIoHandler : public TestIoHandlerBase { 155 public: 156 GetControlSignalsTestIoHandler() {} 157 158 virtual device::serial::DeviceControlSignalsPtr GetControlSignals() 159 const OVERRIDE { 160 device::serial::DeviceControlSignalsPtr signals( 161 device::serial::DeviceControlSignals::New()); 162 signals->dcd = num_calls() & 1; 163 signals->cts = num_calls() & 2; 164 signals->ri = num_calls() & 4; 165 signals->dsr = num_calls() & 8; 166 record_call(); 167 return signals.Pass(); 168 } 169 170 private: 171 virtual ~GetControlSignalsTestIoHandler() {} 172 173 DISALLOW_COPY_AND_ASSIGN(GetControlSignalsTestIoHandler); 174 }; 175 176 class ConfigurePortTestIoHandler : public TestIoHandlerBase { 177 public: 178 ConfigurePortTestIoHandler() {} 179 virtual bool ConfigurePort( 180 const device::serial::ConnectionOptions& options) OVERRIDE { 181 static const device::serial::ConnectionOptions expected_options[] = { 182 GenerateConnectionOptions(9600, 183 device::serial::DATA_BITS_EIGHT, 184 device::serial::PARITY_BIT_NO, 185 device::serial::STOP_BITS_ONE, 186 OPTIONAL_VALUE_FALSE), 187 GenerateConnectionOptions(57600, 188 device::serial::DATA_BITS_NONE, 189 device::serial::PARITY_BIT_NONE, 190 device::serial::STOP_BITS_NONE, 191 OPTIONAL_VALUE_UNSET), 192 GenerateConnectionOptions(0, 193 device::serial::DATA_BITS_SEVEN, 194 device::serial::PARITY_BIT_NONE, 195 device::serial::STOP_BITS_NONE, 196 OPTIONAL_VALUE_UNSET), 197 GenerateConnectionOptions(0, 198 device::serial::DATA_BITS_EIGHT, 199 device::serial::PARITY_BIT_NONE, 200 device::serial::STOP_BITS_NONE, 201 OPTIONAL_VALUE_UNSET), 202 GenerateConnectionOptions(0, 203 device::serial::DATA_BITS_NONE, 204 device::serial::PARITY_BIT_NO, 205 device::serial::STOP_BITS_NONE, 206 OPTIONAL_VALUE_UNSET), 207 GenerateConnectionOptions(0, 208 device::serial::DATA_BITS_NONE, 209 device::serial::PARITY_BIT_ODD, 210 device::serial::STOP_BITS_NONE, 211 OPTIONAL_VALUE_UNSET), 212 GenerateConnectionOptions(0, 213 device::serial::DATA_BITS_NONE, 214 device::serial::PARITY_BIT_EVEN, 215 device::serial::STOP_BITS_NONE, 216 OPTIONAL_VALUE_UNSET), 217 GenerateConnectionOptions(0, 218 device::serial::DATA_BITS_NONE, 219 device::serial::PARITY_BIT_NONE, 220 device::serial::STOP_BITS_ONE, 221 OPTIONAL_VALUE_UNSET), 222 GenerateConnectionOptions(0, 223 device::serial::DATA_BITS_NONE, 224 device::serial::PARITY_BIT_NONE, 225 device::serial::STOP_BITS_TWO, 226 OPTIONAL_VALUE_UNSET), 227 GenerateConnectionOptions(0, 228 device::serial::DATA_BITS_NONE, 229 device::serial::PARITY_BIT_NONE, 230 device::serial::STOP_BITS_NONE, 231 OPTIONAL_VALUE_FALSE), 232 GenerateConnectionOptions(0, 233 device::serial::DATA_BITS_NONE, 234 device::serial::PARITY_BIT_NONE, 235 device::serial::STOP_BITS_NONE, 236 OPTIONAL_VALUE_TRUE), 237 }; 238 if (num_calls() >= arraysize(expected_options)) 239 return false; 240 241 EXPECT_EQ(expected_options[num_calls()].bitrate, options.bitrate); 242 EXPECT_EQ(expected_options[num_calls()].data_bits, options.data_bits); 243 EXPECT_EQ(expected_options[num_calls()].parity_bit, options.parity_bit); 244 EXPECT_EQ(expected_options[num_calls()].stop_bits, options.stop_bits); 245 EXPECT_EQ(expected_options[num_calls()].has_cts_flow_control, 246 options.has_cts_flow_control); 247 EXPECT_EQ(expected_options[num_calls()].cts_flow_control, 248 options.cts_flow_control); 249 record_call(); 250 return TestSerialIoHandler::ConfigurePort(options); 251 } 252 253 private: 254 virtual ~ConfigurePortTestIoHandler() {} 255 256 DISALLOW_COPY_AND_ASSIGN(ConfigurePortTestIoHandler); 257 }; 258 259 class FlushTestIoHandler : public TestIoHandlerBase { 260 public: 261 FlushTestIoHandler() {} 262 263 virtual bool Flush() const OVERRIDE { 264 record_call(); 265 return true; 266 } 267 268 private: 269 virtual ~FlushTestIoHandler() {} 270 271 DISALLOW_COPY_AND_ASSIGN(FlushTestIoHandler); 272 }; 273 274 class FailToConnectTestIoHandler : public TestIoHandlerBase { 275 public: 276 FailToConnectTestIoHandler() {} 277 virtual void Open(const std::string& port, 278 const OpenCompleteCallback& callback) OVERRIDE { 279 callback.Run(false); 280 return; 281 } 282 283 private: 284 virtual ~FailToConnectTestIoHandler() {} 285 286 DISALLOW_COPY_AND_ASSIGN(FailToConnectTestIoHandler); 287 }; 288 289 class FailToGetInfoTestIoHandler : public TestIoHandlerBase { 290 public: 291 explicit FailToGetInfoTestIoHandler(int times_to_succeed) 292 : times_to_succeed_(times_to_succeed) {} 293 virtual device::serial::ConnectionInfoPtr GetPortInfo() const OVERRIDE { 294 if (times_to_succeed_-- > 0) 295 return device::TestSerialIoHandler::GetPortInfo(); 296 return device::serial::ConnectionInfoPtr(); 297 } 298 299 private: 300 virtual ~FailToGetInfoTestIoHandler() {} 301 302 mutable int times_to_succeed_; 303 304 DISALLOW_COPY_AND_ASSIGN(FailToGetInfoTestIoHandler); 305 }; 306 307 class SendErrorTestIoHandler : public TestIoHandlerBase { 308 public: 309 explicit SendErrorTestIoHandler(device::serial::SendError error) 310 : error_(error) {} 311 312 virtual void WriteImpl() OVERRIDE { QueueWriteCompleted(0, error_); } 313 314 private: 315 virtual ~SendErrorTestIoHandler() {} 316 317 device::serial::SendError error_; 318 319 DISALLOW_COPY_AND_ASSIGN(SendErrorTestIoHandler); 320 }; 321 322 class FixedDataReceiveTestIoHandler : public TestIoHandlerBase { 323 public: 324 explicit FixedDataReceiveTestIoHandler(const std::string& data) 325 : data_(data) {} 326 327 virtual void ReadImpl() OVERRIDE { 328 if (pending_read_buffer_len() < data_.size()) 329 return; 330 memcpy(pending_read_buffer(), data_.c_str(), data_.size()); 331 QueueReadCompleted(static_cast<uint32_t>(data_.size()), 332 device::serial::RECEIVE_ERROR_NONE); 333 } 334 335 private: 336 virtual ~FixedDataReceiveTestIoHandler() {} 337 338 const std::string data_; 339 340 DISALLOW_COPY_AND_ASSIGN(FixedDataReceiveTestIoHandler); 341 }; 342 343 class ReceiveErrorTestIoHandler : public TestIoHandlerBase { 344 public: 345 explicit ReceiveErrorTestIoHandler(device::serial::ReceiveError error) 346 : error_(error) {} 347 348 virtual void ReadImpl() OVERRIDE { QueueReadCompleted(0, error_); } 349 350 private: 351 virtual ~ReceiveErrorTestIoHandler() {} 352 353 device::serial::ReceiveError error_; 354 355 DISALLOW_COPY_AND_ASSIGN(ReceiveErrorTestIoHandler); 356 }; 357 358 class SendDataWithErrorIoHandler : public TestIoHandlerBase { 359 public: 360 SendDataWithErrorIoHandler() : sent_error_(false) {} 361 virtual void WriteImpl() OVERRIDE { 362 if (sent_error_) { 363 WriteCompleted(pending_write_buffer_len(), 364 device::serial::SEND_ERROR_NONE); 365 return; 366 } 367 sent_error_ = true; 368 // We expect the JS test code to send a 4 byte buffer. 369 ASSERT_LT(2u, pending_write_buffer_len()); 370 WriteCompleted(2, device::serial::SEND_ERROR_SYSTEM_ERROR); 371 } 372 373 private: 374 virtual ~SendDataWithErrorIoHandler() {} 375 376 bool sent_error_; 377 378 DISALLOW_COPY_AND_ASSIGN(SendDataWithErrorIoHandler); 379 }; 380 381 class BlockSendsForeverSendIoHandler : public TestIoHandlerBase { 382 public: 383 BlockSendsForeverSendIoHandler() {} 384 virtual void WriteImpl() OVERRIDE {} 385 386 private: 387 virtual ~BlockSendsForeverSendIoHandler() {} 388 389 DISALLOW_COPY_AND_ASSIGN(BlockSendsForeverSendIoHandler); 390 }; 391 392 } // namespace 393 394 class SerialApiTest : public ApiTestBase { 395 public: 396 SerialApiTest() {} 397 398 virtual void SetUp() OVERRIDE { 399 ApiTestBase::SetUp(); 400 env()->RegisterModule("async_waiter", IDR_ASYNC_WAITER_JS); 401 env()->RegisterModule("data_receiver", IDR_DATA_RECEIVER_JS); 402 env()->RegisterModule("data_sender", IDR_DATA_SENDER_JS); 403 env()->RegisterModule("serial", IDR_SERIAL_CUSTOM_BINDINGS_JS); 404 env()->RegisterModule("serial_service", IDR_SERIAL_SERVICE_JS); 405 env()->RegisterModule("device/serial/data_stream.mojom", 406 IDR_DATA_STREAM_MOJOM_JS); 407 env()->RegisterModule("device/serial/data_stream_serialization.mojom", 408 IDR_DATA_STREAM_SERIALIZATION_MOJOM_JS); 409 env()->RegisterModule("device/serial/serial.mojom", IDR_SERIAL_MOJOM_JS); 410 service_provider()->AddService<device::serial::SerialService>(base::Bind( 411 &SerialApiTest::CreateSerialService, base::Unretained(this))); 412 } 413 414 scoped_refptr<TestIoHandlerBase> io_handler_; 415 416 private: 417 scoped_refptr<device::SerialIoHandler> GetIoHandler() { 418 if (!io_handler_.get()) 419 io_handler_ = new TestIoHandlerBase; 420 return io_handler_; 421 } 422 423 void CreateSerialService( 424 mojo::InterfaceRequest<device::serial::SerialService> request) { 425 mojo::BindToRequest(new device::SerialServiceImpl( 426 new device::SerialConnectionFactory( 427 base::Bind(&SerialApiTest::GetIoHandler, 428 base::Unretained(this)), 429 base::MessageLoopProxy::current()), 430 scoped_ptr<device::SerialDeviceEnumerator>( 431 new FakeSerialDeviceEnumerator)), 432 &request); 433 } 434 435 DISALLOW_COPY_AND_ASSIGN(SerialApiTest); 436 }; 437 438 TEST_F(SerialApiTest, GetDevices) { 439 RunTest("serial_unittest.js", "testGetDevices"); 440 } 441 442 TEST_F(SerialApiTest, ConnectFail) { 443 io_handler_ = new FailToConnectTestIoHandler; 444 RunTest("serial_unittest.js", "testConnectFail"); 445 } 446 447 TEST_F(SerialApiTest, GetInfoFailOnConnect) { 448 io_handler_ = new FailToGetInfoTestIoHandler(0); 449 RunTest("serial_unittest.js", "testGetInfoFailOnConnect"); 450 } 451 452 TEST_F(SerialApiTest, Connect) { 453 RunTest("serial_unittest.js", "testConnect"); 454 } 455 456 TEST_F(SerialApiTest, ConnectDefaultOptions) { 457 RunTest("serial_unittest.js", "testConnectDefaultOptions"); 458 } 459 460 TEST_F(SerialApiTest, ConnectInvalidBitrate) { 461 RunTest("serial_unittest.js", "testConnectInvalidBitrate"); 462 } 463 464 TEST_F(SerialApiTest, GetInfo) { 465 RunTest("serial_unittest.js", "testGetInfo"); 466 } 467 468 TEST_F(SerialApiTest, GetInfoFailToGetPortInfo) { 469 io_handler_ = new FailToGetInfoTestIoHandler(1); 470 RunTest("serial_unittest.js", "testGetInfoFailToGetPortInfo"); 471 } 472 473 TEST_F(SerialApiTest, GetConnections) { 474 RunTest("serial_unittest.js", "testGetConnections"); 475 } 476 477 TEST_F(SerialApiTest, GetControlSignals) { 478 io_handler_ = new GetControlSignalsTestIoHandler; 479 RunTest("serial_unittest.js", "testGetControlSignals"); 480 EXPECT_EQ(16u, io_handler_->num_calls()); 481 } 482 483 TEST_F(SerialApiTest, SetControlSignals) { 484 io_handler_ = new SetControlSignalsTestIoHandler; 485 RunTest("serial_unittest.js", "testSetControlSignals"); 486 EXPECT_EQ(9u, io_handler_->num_calls()); 487 } 488 489 TEST_F(SerialApiTest, Update) { 490 io_handler_ = new ConfigurePortTestIoHandler; 491 RunTest("serial_unittest.js", "testUpdate"); 492 EXPECT_EQ(11u, io_handler_->num_calls()); 493 } 494 495 TEST_F(SerialApiTest, UpdateInvalidBitrate) { 496 io_handler_ = new ConfigurePortTestIoHandler; 497 RunTest("serial_unittest.js", "testUpdateInvalidBitrate"); 498 EXPECT_EQ(1u, io_handler_->num_calls()); 499 } 500 501 TEST_F(SerialApiTest, Flush) { 502 io_handler_ = new FlushTestIoHandler; 503 RunTest("serial_unittest.js", "testFlush"); 504 EXPECT_EQ(1u, io_handler_->num_calls()); 505 } 506 507 TEST_F(SerialApiTest, SetPaused) { 508 RunTest("serial_unittest.js", "testSetPaused"); 509 } 510 511 TEST_F(SerialApiTest, Echo) { 512 RunTest("serial_unittest.js", "testEcho"); 513 } 514 515 TEST_F(SerialApiTest, SendDuringExistingSend) { 516 RunTest("serial_unittest.js", "testSendDuringExistingSend"); 517 } 518 519 TEST_F(SerialApiTest, SendAfterSuccessfulSend) { 520 RunTest("serial_unittest.js", "testSendAfterSuccessfulSend"); 521 } 522 523 TEST_F(SerialApiTest, SendPartialSuccessWithError) { 524 io_handler_ = new SendDataWithErrorIoHandler(); 525 RunTest("serial_unittest.js", "testSendPartialSuccessWithError"); 526 } 527 528 TEST_F(SerialApiTest, SendTimeout) { 529 io_handler_ = new BlockSendsForeverSendIoHandler(); 530 RunTest("serial_unittest.js", "testSendTimeout"); 531 } 532 533 TEST_F(SerialApiTest, DisableSendTimeout) { 534 io_handler_ = new BlockSendsForeverSendIoHandler(); 535 RunTest("serial_unittest.js", "testDisableSendTimeout"); 536 } 537 538 TEST_F(SerialApiTest, PausedReceive) { 539 io_handler_ = new FixedDataReceiveTestIoHandler("data"); 540 RunTest("serial_unittest.js", "testPausedReceive"); 541 } 542 543 TEST_F(SerialApiTest, PausedReceiveError) { 544 io_handler_ = 545 new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DEVICE_LOST); 546 RunTest("serial_unittest.js", "testPausedReceiveError"); 547 } 548 549 TEST_F(SerialApiTest, ReceiveTimeout) { 550 RunTest("serial_unittest.js", "testReceiveTimeout"); 551 } 552 553 TEST_F(SerialApiTest, DisableReceiveTimeout) { 554 RunTest("serial_unittest.js", "testDisableReceiveTimeout"); 555 } 556 557 TEST_F(SerialApiTest, ReceiveErrorDisconnected) { 558 io_handler_ = 559 new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DISCONNECTED); 560 RunTest("serial_unittest.js", "testReceiveErrorDisconnected"); 561 } 562 563 TEST_F(SerialApiTest, ReceiveErrorDeviceLost) { 564 io_handler_ = 565 new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DEVICE_LOST); 566 RunTest("serial_unittest.js", "testReceiveErrorDeviceLost"); 567 } 568 569 TEST_F(SerialApiTest, ReceiveErrorSystemError) { 570 io_handler_ = 571 new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_SYSTEM_ERROR); 572 RunTest("serial_unittest.js", "testReceiveErrorSystemError"); 573 } 574 575 TEST_F(SerialApiTest, SendErrorDisconnected) { 576 io_handler_ = 577 new SendErrorTestIoHandler(device::serial::SEND_ERROR_DISCONNECTED); 578 RunTest("serial_unittest.js", "testSendErrorDisconnected"); 579 } 580 581 TEST_F(SerialApiTest, SendErrorSystemError) { 582 io_handler_ = 583 new SendErrorTestIoHandler(device::serial::SEND_ERROR_SYSTEM_ERROR); 584 RunTest("serial_unittest.js", "testSendErrorSystemError"); 585 } 586 587 TEST_F(SerialApiTest, DisconnectUnknownConnectionId) { 588 RunTest("serial_unittest.js", "testDisconnectUnknownConnectionId"); 589 } 590 591 TEST_F(SerialApiTest, GetInfoUnknownConnectionId) { 592 RunTest("serial_unittest.js", "testGetInfoUnknownConnectionId"); 593 } 594 595 TEST_F(SerialApiTest, UpdateUnknownConnectionId) { 596 RunTest("serial_unittest.js", "testUpdateUnknownConnectionId"); 597 } 598 599 TEST_F(SerialApiTest, SetControlSignalsUnknownConnectionId) { 600 RunTest("serial_unittest.js", "testSetControlSignalsUnknownConnectionId"); 601 } 602 603 TEST_F(SerialApiTest, GetControlSignalsUnknownConnectionId) { 604 RunTest("serial_unittest.js", "testGetControlSignalsUnknownConnectionId"); 605 } 606 607 TEST_F(SerialApiTest, FlushUnknownConnectionId) { 608 RunTest("serial_unittest.js", "testFlushUnknownConnectionId"); 609 } 610 611 TEST_F(SerialApiTest, SetPausedUnknownConnectionId) { 612 RunTest("serial_unittest.js", "testSetPausedUnknownConnectionId"); 613 } 614 615 TEST_F(SerialApiTest, SendUnknownConnectionId) { 616 RunTest("serial_unittest.js", "testSendUnknownConnectionId"); 617 } 618 619 } // namespace extensions 620
