Implement more of chrome.serial on the Mojo SerialConnection.

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 {
 
 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;
     result[0]->has_product_id = true;
     result[0]->display_name = "foo";
     result[1] = device::serial::DeviceInfo::New();
     result[1]->path = "another_device";
     // These IDs should be ignored.
     result[1]->vendor_id = 1234;
     result[1]->product_id = 5678;
     result[2] = device::serial::DeviceInfo::New();
     result[2]->display_name = "";
     return result.Pass();
   }
 };
 
+enum OptionalValue {
+  OPTIONAL_VALUE_UNSET,
+  OPTIONAL_VALUE_FALSE,
+  OPTIONAL_VALUE_TRUE,
+};
+
+device::serial::HostControlSignals GenerateControlSignals(OptionalValue dtr,
+                                                          OptionalValue rts) {
+  device::serial::HostControlSignals result;
+  switch (dtr) {
+    case OPTIONAL_VALUE_UNSET:
+      break;
+    case OPTIONAL_VALUE_FALSE:
+      result.dtr = false;
+      result.has_dtr = true;
+      break;
+    case OPTIONAL_VALUE_TRUE:
+      result.dtr = true;
+      result.has_dtr = true;
+      break;
+  }
+  switch (rts) {
+    case OPTIONAL_VALUE_UNSET:
+      break;
+    case OPTIONAL_VALUE_FALSE:
+      result.rts = false;
+      result.has_rts = true;
+      break;
+    case OPTIONAL_VALUE_TRUE:
+      result.rts = true;
+      result.has_rts = true;
+      break;
+  }
+  return result;
+}
+
+device::serial::ConnectionOptions GenerateConnectionOptions(
+    int bitrate,
+    device::serial::DataBits data_bits,
+    device::serial::ParityBit parity_bit,
+    device::serial::StopBits stop_bits,
+    OptionalValue cts_flow_control) {
+  device::serial::ConnectionOptions result;
+  result.bitrate = bitrate;
+  result.data_bits = data_bits;
+  result.parity_bit = parity_bit;
+  result.stop_bits = stop_bits;
+  switch (cts_flow_control) {
+    case OPTIONAL_VALUE_UNSET:
+      break;
+    case OPTIONAL_VALUE_FALSE:
+      result.cts_flow_control = false;
+      result.has_cts_flow_control = true;
+      break;
+    case OPTIONAL_VALUE_TRUE:
+      result.cts_flow_control = true;
+      result.has_cts_flow_control = true;
+      break;
+  }
+  return result;
+}
+
+class TestIoHandlerBase : public device::TestSerialIoHandler {

[raymes, 2014/08/14 02:58:04]

Consider merging these classes together into a single TestIOHandler.

[Sam McNally, 2014/08/14 04:33:51]

Acknowledged.

+ public:
+  TestIoHandlerBase() : calls_(0) {}
+
+  size_t num_calls() const { return calls_; }
+
+ protected:
+  virtual ~TestIoHandlerBase() {}
+  void record_call() const { calls_++; }
+
+ private:
+  mutable size_t calls_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestIoHandlerBase);
+};
+
+class SetControlSignalsTestIoHandler : public TestIoHandlerBase {
+ public:
+  SetControlSignalsTestIoHandler() {}
+
+  virtual bool SetControlSignals(
+      const device::serial::HostControlSignals& signals) OVERRIDE {
+    static const device::serial::HostControlSignals expected_signals[] = {
+        GenerateControlSignals(OPTIONAL_VALUE_UNSET, OPTIONAL_VALUE_UNSET),
+        GenerateControlSignals(OPTIONAL_VALUE_FALSE, OPTIONAL_VALUE_UNSET),
+        GenerateControlSignals(OPTIONAL_VALUE_TRUE, OPTIONAL_VALUE_UNSET),
+        GenerateControlSignals(OPTIONAL_VALUE_UNSET, OPTIONAL_VALUE_FALSE),
+        GenerateControlSignals(OPTIONAL_VALUE_FALSE, OPTIONAL_VALUE_FALSE),
+        GenerateControlSignals(OPTIONAL_VALUE_TRUE, OPTIONAL_VALUE_FALSE),
+        GenerateControlSignals(OPTIONAL_VALUE_UNSET, OPTIONAL_VALUE_TRUE),
+        GenerateControlSignals(OPTIONAL_VALUE_FALSE, OPTIONAL_VALUE_TRUE),
+        GenerateControlSignals(OPTIONAL_VALUE_TRUE, OPTIONAL_VALUE_TRUE),
+    };
+    if (num_calls() >= arraysize(expected_signals))
+      return false;
+
+    EXPECT_EQ(expected_signals[num_calls()].has_dtr, signals.has_dtr);
+    EXPECT_EQ(expected_signals[num_calls()].dtr, signals.dtr);
+    EXPECT_EQ(expected_signals[num_calls()].has_rts, signals.has_rts);
+    EXPECT_EQ(expected_signals[num_calls()].rts, signals.rts);
+    record_call();
+    return true;
+  }
+
+ private:
+  virtual ~SetControlSignalsTestIoHandler() {}
+
+  DISALLOW_COPY_AND_ASSIGN(SetControlSignalsTestIoHandler);
+};
+
+class GetControlSignalsTestIoHandler : public TestIoHandlerBase {
+ public:
+  GetControlSignalsTestIoHandler() {}
+
+  virtual device::serial::DeviceControlSignalsPtr GetControlSignals()
+      const OVERRIDE {
+    device::serial::DeviceControlSignalsPtr signals(
+        device::serial::DeviceControlSignals::New());
+    signals->dcd = num_calls() & 1;
+    signals->cts = num_calls() & 2;
+    signals->ri = num_calls() & 4;
+    signals->dsr = num_calls() & 8;
+    record_call();
+    return signals.Pass();
+  }
+
+ private:
+  virtual ~GetControlSignalsTestIoHandler() {}
+
+  DISALLOW_COPY_AND_ASSIGN(GetControlSignalsTestIoHandler);
+};
+
+class ConfigurePortTestIoHandler : public TestIoHandlerBase {
+ public:
+  ConfigurePortTestIoHandler() {}
+  virtual bool ConfigurePort(
+      const device::serial::ConnectionOptions& options) OVERRIDE {
+    static const device::serial::ConnectionOptions expected_options[] = {
+        GenerateConnectionOptions(9600,
+                                  device::serial::DATA_BITS_EIGHT,
+                                  device::serial::PARITY_BIT_NO,
+                                  device::serial::STOP_BITS_ONE,
+                                  OPTIONAL_VALUE_FALSE),
+        GenerateConnectionOptions(57600,
+                                  device::serial::DATA_BITS_NONE,
+                                  device::serial::PARITY_BIT_NONE,
+                                  device::serial::STOP_BITS_NONE,
+                                  OPTIONAL_VALUE_UNSET),
+        GenerateConnectionOptions(0,
+                                  device::serial::DATA_BITS_SEVEN,
+                                  device::serial::PARITY_BIT_NONE,
+                                  device::serial::STOP_BITS_NONE,
+                                  OPTIONAL_VALUE_UNSET),
+        GenerateConnectionOptions(0,
+                                  device::serial::DATA_BITS_EIGHT,
+                                  device::serial::PARITY_BIT_NONE,
+                                  device::serial::STOP_BITS_NONE,
+                                  OPTIONAL_VALUE_UNSET),
+        GenerateConnectionOptions(0,
+                                  device::serial::DATA_BITS_NONE,
+                                  device::serial::PARITY_BIT_NO,
+                                  device::serial::STOP_BITS_NONE,
+                                  OPTIONAL_VALUE_UNSET),
+        GenerateConnectionOptions(0,
+                                  device::serial::DATA_BITS_NONE,
+                                  device::serial::PARITY_BIT_ODD,
+                                  device::serial::STOP_BITS_NONE,
+                                  OPTIONAL_VALUE_UNSET),
+        GenerateConnectionOptions(0,
+                                  device::serial::DATA_BITS_NONE,
+                                  device::serial::PARITY_BIT_EVEN,
+                                  device::serial::STOP_BITS_NONE,
+                                  OPTIONAL_VALUE_UNSET),
+        GenerateConnectionOptions(0,
+                                  device::serial::DATA_BITS_NONE,
+                                  device::serial::PARITY_BIT_NONE,
+                                  device::serial::STOP_BITS_ONE,
+                                  OPTIONAL_VALUE_UNSET),
+        GenerateConnectionOptions(0,
+                                  device::serial::DATA_BITS_NONE,
+                                  device::serial::PARITY_BIT_NONE,
+                                  device::serial::STOP_BITS_TWO,
+                                  OPTIONAL_VALUE_UNSET),
+        GenerateConnectionOptions(0,
+                                  device::serial::DATA_BITS_NONE,
+                                  device::serial::PARITY_BIT_NONE,
+                                  device::serial::STOP_BITS_NONE,
+                                  OPTIONAL_VALUE_FALSE),
+        GenerateConnectionOptions(0,
+                                  device::serial::DATA_BITS_NONE,
+                                  device::serial::PARITY_BIT_NONE,
+                                  device::serial::STOP_BITS_NONE,
+                                  OPTIONAL_VALUE_TRUE),
+    };
+    if (num_calls() >= arraysize(expected_options))
+      return false;
+
+    EXPECT_EQ(expected_options[num_calls()].bitrate, options.bitrate);
+    EXPECT_EQ(expected_options[num_calls()].data_bits, options.data_bits);
+    EXPECT_EQ(expected_options[num_calls()].parity_bit, options.parity_bit);
+    EXPECT_EQ(expected_options[num_calls()].stop_bits, options.stop_bits);
+    EXPECT_EQ(expected_options[num_calls()].has_cts_flow_control,
+              options.has_cts_flow_control);
+    EXPECT_EQ(expected_options[num_calls()].cts_flow_control,
+              options.cts_flow_control);
+    record_call();
+    return TestSerialIoHandler::ConfigurePort(options);
+  }
+
+ private:
+  virtual ~ConfigurePortTestIoHandler() {}
+
+  DISALLOW_COPY_AND_ASSIGN(ConfigurePortTestIoHandler);
+};
+
+class FlushTestIoHandler : public TestIoHandlerBase {
+ public:
+  FlushTestIoHandler() {}
+
+  virtual bool Flush() const OVERRIDE {
+    record_call();
+    return true;
+  }
+
+ private:
+  virtual ~FlushTestIoHandler() {}
+
+  DISALLOW_COPY_AND_ASSIGN(FlushTestIoHandler);
+};
+
+class FailToConnectTestIoHandler : public TestIoHandlerBase {
+ public:
+  FailToConnectTestIoHandler() {}
+  virtual void Open(const std::string& port,
+                    const OpenCompleteCallback& callback) OVERRIDE {
+    callback.Run(false);
+    return;
+  }
+
+ private:
+  virtual ~FailToConnectTestIoHandler() {}
+
+  DISALLOW_COPY_AND_ASSIGN(FailToConnectTestIoHandler);
+};
+
+class FailToGetInfoTestIoHandler : public TestIoHandlerBase {
+ public:
+  explicit FailToGetInfoTestIoHandler(int times_to_succeed)
+      : times_to_succeed_(times_to_succeed) {}
+  virtual device::serial::ConnectionInfoPtr GetPortInfo() const OVERRIDE {
+    if (times_to_succeed_-- > 0)
+      return device::TestSerialIoHandler::GetPortInfo();
+    return device::serial::ConnectionInfoPtr();
+  }
+
+ private:
+  virtual ~FailToGetInfoTestIoHandler() {}
+
+  mutable int times_to_succeed_;
+
+  DISALLOW_COPY_AND_ASSIGN(FailToGetInfoTestIoHandler);
+};
+
 }  // namespace
 
-void CreateSerialService(
-    mojo::InterfaceRequest<device::serial::SerialService> request) {
-  mojo::BindToRequest(
-      new device::SerialServiceImpl(
-          new device::SerialConnectionFactory(
-              device::SerialConnectionFactory::IoHandlerFactory(),
-              base::MessageLoopProxy::current()),
-          scoped_ptr<device::SerialDeviceEnumerator>(
-              new FakeSerialDeviceEnumerator)),
-      &request);
-}
-
 class SerialApiTest : public ApiTestBase {
  public:
+  SerialApiTest() {}
+
   virtual void SetUp() OVERRIDE {
     ApiTestBase::SetUp();
     env()->RegisterModule("serial", IDR_SERIAL_CUSTOM_BINDINGS_JS);
     env()->RegisterModule("serial_service", IDR_SERIAL_SERVICE_JS);
     env()->RegisterModule("device/serial/serial.mojom", IDR_SERIAL_MOJOM_JS);
-    service_provider()->AddService<device::serial::SerialService>(
-        base::Bind(CreateSerialService));
-  }
+    service_provider()->AddService<device::serial::SerialService>(base::Bind(
+        &SerialApiTest::CreateSerialService, base::Unretained(this)));
+  }
+
+  virtual void TearDown() OVERRIDE {
+    if (io_handler_)
+      EXPECT_TRUE(io_handler_->HasOneRef());
+    ApiTestBase::TearDown();
+  }
+
+  scoped_refptr<TestIoHandlerBase> io_handler_;
+
+ private:
+  scoped_refptr<device::SerialIoHandler> GetIoHandler() {
+    if (!io_handler_)
+      io_handler_ = new TestIoHandlerBase;
+    return io_handler_;
+  }
+
+  void CreateSerialService(
+      mojo::InterfaceRequest<device::serial::SerialService> request) {
+    mojo::BindToRequest(new device::SerialServiceImpl(
+                            new device::SerialConnectionFactory(
+                                base::Bind(&SerialApiTest::GetIoHandler,
+                                           base::Unretained(this)),
+                                base::MessageLoopProxy::current()),
+                            scoped_ptr<device::SerialDeviceEnumerator>(
+                                new FakeSerialDeviceEnumerator)),
+                        &request);
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(SerialApiTest);
 };
 
 TEST_F(SerialApiTest, GetDevices) {
   RunTest("serial_unittest.js", "testGetDevices");
 }
 
+TEST_F(SerialApiTest, ConnectFail) {
+  io_handler_ = new FailToConnectTestIoHandler;
+  RunTest("serial_unittest.js", "testConnectFail");
+}
+
+TEST_F(SerialApiTest, GetInfoFailOnConnect) {
+  io_handler_ = new FailToGetInfoTestIoHandler(0);
+  RunTest("serial_unittest.js", "testGetInfoFailOnConnect");
+}
+
+TEST_F(SerialApiTest, Connect) {
+  RunTest("serial_unittest.js", "testConnect");
+}
+
+TEST_F(SerialApiTest, ConnectDefaultOptions) {
+  RunTest("serial_unittest.js", "testConnectDefaultOptions");
+}
+
+TEST_F(SerialApiTest, ConnectInvalidBitrate) {
+  RunTest("serial_unittest.js", "testConnectInvalidBitrate");
+}
+
+TEST_F(SerialApiTest, GetInfo) {
+  RunTest("serial_unittest.js", "testGetInfo");
+}
+
+TEST_F(SerialApiTest, GetInfoFailToGetPortInfo) {
+  io_handler_ = new FailToGetInfoTestIoHandler(1);
+  RunTest("serial_unittest.js", "testGetInfoFailToGetPortInfo");
+}
+
+TEST_F(SerialApiTest, GetConnections) {
+  RunTest("serial_unittest.js", "testGetConnections");
+}
+
+TEST_F(SerialApiTest, GetControlSignals) {
+  io_handler_ = new GetControlSignalsTestIoHandler;
+  RunTest("serial_unittest.js", "testGetControlSignals");
+  EXPECT_EQ(16u, io_handler_->num_calls());
+}
+
+TEST_F(SerialApiTest, SetControlSignals) {
+  io_handler_ = new SetControlSignalsTestIoHandler;
+  RunTest("serial_unittest.js", "testSetControlSignals");
+  EXPECT_EQ(9u, io_handler_->num_calls());
+}
+
+TEST_F(SerialApiTest, Update) {
+  io_handler_ = new ConfigurePortTestIoHandler;
+  RunTest("serial_unittest.js", "testUpdate");
+  EXPECT_EQ(11u, io_handler_->num_calls());
+}
+
+TEST_F(SerialApiTest, UpdateInvalidBitrate) {
+  io_handler_ = new ConfigurePortTestIoHandler;
+  RunTest("serial_unittest.js", "testUpdateInvalidBitrate");
+  EXPECT_EQ(1u, io_handler_->num_calls());
+}
+
+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, 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");
+}
+
 }  // namespace extensions