Home | History | Annotate | Download | only in serial 
      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