Add a partial Mojo serial connection interface and implementation.

device/serial/serial_connection_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 "base/bind.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "device/serial/serial.mojom.h"
+#include "device/serial/serial_service_impl.h"
+#include "device/serial/test_serial_io_handler.h"
+#include "mojo/public/cpp/bindings/error_handler.h"
+#include "mojo/public/cpp/bindings/interface_ptr.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace device {
+namespace {
+
+class FakeSerialDeviceEnumerator : public SerialDeviceEnumerator {
+  virtual mojo::Array<serial::DeviceInfoPtr> GetDevices() OVERRIDE {
+    mojo::Array<serial::DeviceInfoPtr> devices(1);
+    devices[0] = serial::DeviceInfo::New();
+    devices[0]->path = "device";
+    return devices.Pass();
+  }
+};
+
+}  // namespace
+
+class SerialConnectionTest : public testing::Test, public mojo::ErrorHandler {
+ public:
+  SerialConnectionTest() : connected_(false), success_(false) {}
+
+  virtual void SetUp() OVERRIDE {
+    message_loop_.reset(new base::MessageLoop);
+    mojo::InterfacePtr<serial::SerialService> service;
+    mojo::BindToProxy(
+        new SerialServiceImpl(
+            new SerialConnectionFactory(
+                base::Bind(&SerialConnectionTest::CreateIoHandler,
+                           base::Unretained(this)),
+                base::MessageLoopProxy::current()),
+            scoped_ptr<SerialDeviceEnumerator>(new FakeSerialDeviceEnumerator)),
+        &service);
+    service.set_error_handler(this);
+    service->Connect(
+        "device", serial::ConnectionOptions::New(), mojo::Get(&connection_));
+    connection_.set_error_handler(this);
+    connection_->GetInfo(
+        base::Bind(&SerialConnectionTest::StoreInfo, base::Unretained(this)));
+    RunMessageLoop();
+    ASSERT_TRUE(io_handler_);
+  }
+
+  void StoreInfo(serial::ConnectionInfoPtr options) {
+    info_ = options.Pass();
+    StopMessageLoop();
+  }
+
+  void StoreControlSignals(serial::DeviceControlSignalsPtr signals) {
+    signals_ = signals.Pass();
+    StopMessageLoop();
+  }
+
+  void StoreSuccess(bool success) {
+    success_ = success;
+    StopMessageLoop();
+  }
+
+  void RunMessageLoop() {
+    run_loop_.reset(new base::RunLoop);
+    run_loop_->Run();
+  }
+
+  void StopMessageLoop() {
+    ASSERT_TRUE(message_loop_);
+    ASSERT_TRUE(run_loop_);
+    message_loop_->PostTask(FROM_HERE, run_loop_->QuitClosure());
+  }
+
+  scoped_refptr<SerialIoHandler> CreateIoHandler() {
+    io_handler_ = new TestSerialIoHandler;
+    return io_handler_;
+  }
+
+  virtual void OnConnectionError() OVERRIDE {
+    StopMessageLoop();
+    FAIL() << "Connection error";
+  }
+
+  mojo::Array<serial::DeviceInfoPtr> devices_;
+  serial::ConnectionInfoPtr info_;
+  serial::DeviceControlSignalsPtr signals_;
+  bool connected_;
+  bool success_;
+
+  scoped_ptr<base::MessageLoop> message_loop_;
+  scoped_ptr<base::RunLoop> run_loop_;
+  mojo::InterfacePtr<serial::Connection> connection_;
+  scoped_refptr<TestSerialIoHandler> io_handler_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SerialConnectionTest);
+};
+
+TEST_F(SerialConnectionTest, GetInfo) {
+  // |info_| is filled in during SetUp().
+  ASSERT_TRUE(info_);
+  EXPECT_EQ(9600u, info_->bitrate);
+  EXPECT_EQ(serial::DATA_BITS_EIGHT, info_->data_bits);
+  EXPECT_EQ(serial::PARITY_BIT_NO, info_->parity_bit);
+  EXPECT_EQ(serial::STOP_BITS_ONE, info_->stop_bits);
+  EXPECT_FALSE(info_->cts_flow_control);
+}
+
+TEST_F(SerialConnectionTest, SetOptions) {
+  serial::ConnectionOptionsPtr options(serial::ConnectionOptions::New());
+  options->bitrate = 12345;
+  options->data_bits = serial::DATA_BITS_SEVEN;
+  options->has_cts_flow_control = true;
+  options->cts_flow_control = true;
+  connection_->SetOptions(
+      options.Pass(),
+      base::Bind(&SerialConnectionTest::StoreSuccess, base::Unretained(this)));
+  RunMessageLoop();
+  ASSERT_TRUE(success_);
+  serial::ConnectionInfo* info = io_handler_->connection_info();
+  EXPECT_EQ(12345u, info->bitrate);
+  EXPECT_EQ(serial::DATA_BITS_SEVEN, info->data_bits);
+  EXPECT_EQ(serial::PARITY_BIT_NO, info->parity_bit);
+  EXPECT_EQ(serial::STOP_BITS_ONE, info->stop_bits);
+  EXPECT_TRUE(info->cts_flow_control);
+}
+
+TEST_F(SerialConnectionTest, GetControlSignals) {
+  connection_->GetControlSignals(base::Bind(
+      &SerialConnectionTest::StoreControlSignals, base::Unretained(this)));
+  serial::DeviceControlSignals* signals = io_handler_->device_control_signals();
+  signals->dcd = true;
+  signals->dsr = true;
+
+  RunMessageLoop();
+  ASSERT_TRUE(signals_);
+  EXPECT_TRUE(signals_->dcd);
+  EXPECT_FALSE(signals_->cts);
+  EXPECT_FALSE(signals_->ri);
+  EXPECT_TRUE(signals_->dsr);
+}
+
+TEST_F(SerialConnectionTest, SetControlSignals) {
+  serial::HostControlSignalsPtr signals(serial::HostControlSignals::New());
+  signals->has_dtr = true;
+  signals->dtr = true;
+  signals->has_rts = true;
+  signals->rts = true;
+
+  connection_->SetControlSignals(
+      signals.Pass(),
+      base::Bind(&SerialConnectionTest::StoreSuccess, base::Unretained(this)));
+  RunMessageLoop();
+  ASSERT_TRUE(success_);
+  EXPECT_TRUE(io_handler_->dtr());
+  EXPECT_TRUE(io_handler_->rts());
+}
+
+TEST_F(SerialConnectionTest, Flush) {
+  ASSERT_EQ(0, io_handler_->flushes());
+  connection_->Flush(
+      base::Bind(&SerialConnectionTest::StoreSuccess, base::Unretained(this)));
+  RunMessageLoop();
+  ASSERT_TRUE(success_);
+  EXPECT_EQ(1, io_handler_->flushes());
+}
+
+TEST_F(SerialConnectionTest, Disconnect) {
+  connection_.reset();
+  message_loop_.reset();
+  EXPECT_TRUE(io_handler_->HasOneRef());
+}
+
+}  // namespace device