Implement the client side of Serial I/O on data pipe.

extensions/renderer/api/serial/serial_api_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "device/serial/serial_device_enumerator.h"
 #include "device/serial/serial_service_impl.h"
 #include "device/serial/test_serial_io_handler.h"
 #include "extensions/renderer/api_test_base.h"
 #include "grit/extensions_renderer_resources.h"
 
 namespace extensions {
 

[raymes, 2014/09/02 04:59:32]

Make a note somewhere in this file of what these tests test and how these tests
work (their interaction with the JS).

[Sam McNally, 2014/09/02 07:41:12]

Done.

 namespace {
 
 class FakeSerialDeviceEnumerator : public device::SerialDeviceEnumerator {
   virtual mojo::Array<device::serial::DeviceInfoPtr> GetDevices() OVERRIDE {
     mojo::Array<device::serial::DeviceInfoPtr> result(3);
     result[0] = device::serial::DeviceInfo::New();
     result[0]->path = "device";
     result[0]->vendor_id = 1234;
     result[0]->has_vendor_id = true;
     result[0]->product_id = 5678;
@@ skipping 268 matching lines @@
   }
 
  private:
   virtual ~FailToGetInfoTestIoHandler() {}
 
   mutable int times_to_succeed_;
 
   DISALLOW_COPY_AND_ASSIGN(FailToGetInfoTestIoHandler);
 };
 
+class SendErrorTestIoHandler : public TestIoHandlerBase {
+ public:
+  explicit SendErrorTestIoHandler(device::serial::SendError error)
+      : error_(error) {}
+
+  virtual void WriteImpl() OVERRIDE { QueueWriteCompleted(0, error_); }
+
+ private:
+  virtual ~SendErrorTestIoHandler() {}
+
+  device::serial::SendError error_;
+
+  DISALLOW_COPY_AND_ASSIGN(SendErrorTestIoHandler);
+};
+
+class FixedDataReceiveTestIoHandler : public TestIoHandlerBase {
+ public:
+  explicit FixedDataReceiveTestIoHandler(const std::string& data)
+      : data_(data) {}
+
+  virtual void ReadImpl() OVERRIDE {
+    if (pending_read_buffer_len() < data_.size())
+      return;
+    memcpy(pending_read_buffer(), data_.c_str(), data_.size());
+    QueueReadCompleted(static_cast<uint32_t>(data_.size()),
+                       device::serial::RECEIVE_ERROR_NONE);
+  }
+
+ private:
+  virtual ~FixedDataReceiveTestIoHandler() {}
+
+  const std::string data_;
+
+  DISALLOW_COPY_AND_ASSIGN(FixedDataReceiveTestIoHandler);
+};
+
+class ReceiveErrorTestIoHandler : public TestIoHandlerBase {
+ public:
+  explicit ReceiveErrorTestIoHandler(device::serial::ReceiveError error)
+      : error_(error) {}
+
+  virtual void ReadImpl() OVERRIDE { QueueReadCompleted(0, error_); }
+
+ private:
+  virtual ~ReceiveErrorTestIoHandler() {}
+
+  device::serial::ReceiveError error_;
+
+  DISALLOW_COPY_AND_ASSIGN(ReceiveErrorTestIoHandler);
+};
+
+class SendDataWithErrorIoHandler : public TestIoHandlerBase {
+ public:
+  SendDataWithErrorIoHandler() : sent_error_(false) {}
+  virtual void WriteImpl() OVERRIDE {
+    if (sent_error_) {
+      WriteCompleted(pending_write_buffer_len(),
+                     device::serial::SEND_ERROR_NONE);
+      return;
+    }
+    sent_error_ = true;
+    // We expect the JS test code to send a 4 byte buffer.
+    ASSERT_LT(2u, pending_write_buffer_len());
+    WriteCompleted(2, device::serial::SEND_ERROR_SYSTEM_ERROR);
+  }
+
+ private:
+  virtual ~SendDataWithErrorIoHandler() {}
+
+  bool sent_error_;
+
+  DISALLOW_COPY_AND_ASSIGN(SendDataWithErrorIoHandler);
+};
+
+class BlockSendsForeverSendIoHandler : public TestIoHandlerBase {
+ public:
+  BlockSendsForeverSendIoHandler() {}
+  virtual void WriteImpl() OVERRIDE {}
+
+ private:
+  virtual ~BlockSendsForeverSendIoHandler() {}
+
+  DISALLOW_COPY_AND_ASSIGN(BlockSendsForeverSendIoHandler);
+};
+
 }  // namespace
 
 class SerialApiTest : public ApiTestBase {
  public:
   SerialApiTest() {}
 
   virtual void SetUp() OVERRIDE {
     ApiTestBase::SetUp();
+    env()->RegisterModule("async_waiter", IDR_ASYNC_WAITER_JS);
+    env()->RegisterModule("data_receiver", IDR_DATA_RECEIVER_JS);
+    env()->RegisterModule("data_sender", IDR_DATA_SENDER_JS);
     env()->RegisterModule("serial", IDR_SERIAL_CUSTOM_BINDINGS_JS);
     env()->RegisterModule("serial_service", IDR_SERIAL_SERVICE_JS);
     env()->RegisterModule("device/serial/data_stream.mojom",
                           IDR_DATA_STREAM_MOJOM_JS);
     env()->RegisterModule("device/serial/serial.mojom", IDR_SERIAL_MOJOM_JS);
     service_provider()->AddService<device::serial::SerialService>(base::Bind(
         &SerialApiTest::CreateSerialService, base::Unretained(this)));
   }
 
   virtual void TearDown() OVERRIDE {
@@ skipping 92 matching lines @@
 TEST_F(SerialApiTest, Flush) {
   io_handler_ = new FlushTestIoHandler;
   RunTest("serial_unittest.js", "testFlush");
   EXPECT_EQ(1u, io_handler_->num_calls());
 }
 
 TEST_F(SerialApiTest, SetPaused) {
   RunTest("serial_unittest.js", "testSetPaused");
 }
 
+TEST_F(SerialApiTest, Echo) {
+  RunTest("serial_unittest.js", "testEcho");
+}
+
+TEST_F(SerialApiTest, SendDuringExistingSend) {
+  RunTest("serial_unittest.js", "testSendDuringExistingSend");
+}
+
+TEST_F(SerialApiTest, SendAfterSuccessfulSend) {
+  RunTest("serial_unittest.js", "testSendAfterSuccessfulSend");
+}
+
+TEST_F(SerialApiTest, SendPartialSuccessWithError) {
+  io_handler_ = new SendDataWithErrorIoHandler();
+  RunTest("serial_unittest.js", "testSendPartialSuccessWithError");
+}
+
+TEST_F(SerialApiTest, SendTimeout) {
+  io_handler_ = new BlockSendsForeverSendIoHandler();
+  RunTest("serial_unittest.js", "testSendTimeout");
+}
+
+TEST_F(SerialApiTest, DisableSendTimeout) {
+  io_handler_ = new BlockSendsForeverSendIoHandler();
+  RunTest("serial_unittest.js", "testDisableSendTimeout");
+}
+
+TEST_F(SerialApiTest, PausedReceive) {
+  io_handler_ = new FixedDataReceiveTestIoHandler("data");
+  RunTest("serial_unittest.js", "testPausedReceive");
+}
+
+TEST_F(SerialApiTest, PausedReceiveError) {
+  io_handler_ =
+      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DEVICE_LOST);
+  RunTest("serial_unittest.js", "testPausedReceiveError");
+}
+
+TEST_F(SerialApiTest, ReceiveTimeout) {
+  RunTest("serial_unittest.js", "testReceiveTimeout");
+}
+
+TEST_F(SerialApiTest, DisableReceiveTimeout) {
+  RunTest("serial_unittest.js", "testDisableReceiveTimeout");
+}
+
+TEST_F(SerialApiTest, ReceiveErrorDisconnected) {
+  io_handler_ =
+      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DISCONNECTED);
+  RunTest("serial_unittest.js", "testReceiveErrorDisconnected");
+}
+
+TEST_F(SerialApiTest, ReceiveErrorTimeout) {
+  io_handler_ =
+      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_TIMEOUT);
+  RunTest("serial_unittest.js", "testReceiveErrorTimeout");
+}
+
+TEST_F(SerialApiTest, ReceiveErrorDeviceLost) {
+  io_handler_ =
+      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_DEVICE_LOST);
+  RunTest("serial_unittest.js", "testReceiveErrorDeviceLost");
+}
+
+TEST_F(SerialApiTest, ReceiveErrorSystemError) {
+  io_handler_ =
+      new ReceiveErrorTestIoHandler(device::serial::RECEIVE_ERROR_SYSTEM_ERROR);
+  RunTest("serial_unittest.js", "testReceiveErrorSystemError");
+}
+
+TEST_F(SerialApiTest, SendErrorDisconnected) {
+  io_handler_ =
+      new SendErrorTestIoHandler(device::serial::SEND_ERROR_DISCONNECTED);
+  RunTest("serial_unittest.js", "testSendErrorDisconnected");
+}
+
+TEST_F(SerialApiTest, SendErrorTimeout) {
+  io_handler_ = new SendErrorTestIoHandler(device::serial::SEND_ERROR_TIMEOUT);
+  RunTest("serial_unittest.js", "testSendErrorTimeout");
+}
+
+TEST_F(SerialApiTest, SendErrorSystemError) {
+  io_handler_ =
+      new SendErrorTestIoHandler(device::serial::SEND_ERROR_SYSTEM_ERROR);
+  RunTest("serial_unittest.js", "testSendErrorSystemError");
+}
+
 TEST_F(SerialApiTest, DisconnectUnknownConnectionId) {
   RunTest("serial_unittest.js", "testDisconnectUnknownConnectionId");
 }
 
 TEST_F(SerialApiTest, GetInfoUnknownConnectionId) {
   RunTest("serial_unittest.js", "testGetInfoUnknownConnectionId");
 }
 
 TEST_F(SerialApiTest, UpdateUnknownConnectionId) {
   RunTest("serial_unittest.js", "testUpdateUnknownConnectionId");
 }
 
 TEST_F(SerialApiTest, SetControlSignalsUnknownConnectionId) {
   RunTest("serial_unittest.js", "testSetControlSignalsUnknownConnectionId");
 }
 
 TEST_F(SerialApiTest, GetControlSignalsUnknownConnectionId) {
   RunTest("serial_unittest.js", "testGetControlSignalsUnknownConnectionId");
 }
 
 TEST_F(SerialApiTest, FlushUnknownConnectionId) {
   RunTest("serial_unittest.js", "testFlushUnknownConnectionId");
 }
 
 TEST_F(SerialApiTest, SetPausedUnknownConnectionId) {
   RunTest("serial_unittest.js", "testSetPausedUnknownConnectionId");
 }
 
+TEST_F(SerialApiTest, SendUnknownConnectionId) {
+  RunTest("serial_unittest.js", "testSendUnknownConnectionId");
+}
+
 }  // namespace extensions