src/virtualization/bin/vmm/device/tests/virtio_input_test.cc

// Copyright 2018 The Fuchsia 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 <fuchsia/input/cpp/fidl.h>
#include <fuchsia/logger/cpp/fidl.h>
#include <fuchsia/tracing/provider/cpp/fidl.h>
#include <fuchsia/ui/input3/cpp/fidl.h>
#include <fuchsia/ui/pointer/cpp/fidl.h>
#include <lib/fidl/cpp/binding.h>
#include <lib/sys/component/cpp/testing/realm_builder.h>
#include <lib/sys/component/cpp/testing/realm_builder_types.h>
#include <lib/zx/result.h>

#include <cmath>

#include <virtio/input.h>

#include "src/virtualization/bin/vmm/device/input.h"
#include "src/virtualization/bin/vmm/device/tests/test_with_device.h"
#include "src/virtualization/bin/vmm/device/tests/virtio_queue_fake.h"

namespace {

constexpr uint16_t kNumQueues = 2;
constexpr uint16_t kQueueSize = 16;

const size_t kPageSize = zx_system_get_page_size();

constexpr auto kComponentUrl = "#meta/virtio_input.cm";

struct VirtioInputTestParam {
  std::string test_name;
  bool configure_status_queue;
};

class VirtioInputTest : public TestWithDevice,
                        public ::testing::WithParamInterface<VirtioInputTestParam> {
 protected:
  VirtioInputTest()
      : event_queue_(phys_mem_, kPageSize * kNumQueues, kQueueSize),
        status_queue_(phys_mem_, event_queue_.end(), kQueueSize) {}

  void SetUpWithInputType(fuchsia::virtualization::hardware::InputType input_type) {
    using component_testing::ChildRef;
    using component_testing::ParentRef;
    using component_testing::Protocol;
    using component_testing::RealmBuilder;
    using component_testing::RealmRoot;
    using component_testing::Route;

    constexpr auto kComponentName = "virtio_input";

    auto realm_builder = RealmBuilder::Create();
    realm_builder.AddChild(kComponentName, kComponentUrl);

    realm_builder
        .AddRoute(Route{.capabilities =
                            {
                                Protocol{fuchsia::logger::LogSink::Name_},
                                Protocol{fuchsia::tracing::provider::Registry::Name_},
                            },
                        .source = ParentRef(),
                        .targets = {ChildRef{kComponentName}}})
        .AddRoute(Route{.capabilities =
                            {
                                Protocol{fuchsia::virtualization::hardware::VirtioInput::Name_},
                            },
                        .source = ChildRef{kComponentName},
                        .targets = {ParentRef()}});

    realm_ = std::make_unique<RealmRoot>(realm_builder.Build(dispatcher()));

    fuchsia::virtualization::hardware::StartInfo start_info;
    zx_status_t status = MakeStartInfo(status_queue_.end(), &start_info);
    ASSERT_EQ(ZX_OK, status);

    input_ = realm_->component().ConnectSync<fuchsia::virtualization::hardware::VirtioInput>();

    status = input_->Start(std::move(start_info), std::move(input_type));
    ASSERT_EQ(ZX_OK, status);

    // Configure device queues.
    VirtioQueueFake* queues[kNumQueues] = {&event_queue_, &status_queue_};
    for (uint16_t i = 0; i < kNumQueues; i++) {
      auto q = queues[i];
      q->Configure(kPageSize * i, kPageSize);
      status = input_->ConfigureQueue(i, q->size(), q->desc(), q->avail(), q->used());
      ASSERT_EQ(ZX_OK, status);

      if (!GetParam().configure_status_queue) {
        break;
      }
    }

    // Finish negotiating features.
    status = input_->Ready(0);
    ASSERT_EQ(ZX_OK, status);
  }

  zx::result<std::vector<virtio_input_event_t*>> AddEventDescriptorsToChain(size_t n) {
    std::vector<virtio_input_event_t*> result(n);
    // Note: virtio-input sends only one virtio_input_event_t per chain.
    for (size_t i = 0; i < n; ++i) {
      virtio_input_event_t* event;
      zx_status_t status = DescriptorChainBuilder(event_queue_)
                               .AppendWritableDescriptor(&event, sizeof(*event))
                               .Build();
      if (status != ZX_OK) {
        return zx::error(status);
      }
      result[i] = event;
    }
    return zx::ok(std::move(result));
  }

  // Note: use of sync can be problematic here if the test environment needs to handle
  // some incoming FIDL requests.
  fuchsia::virtualization::hardware::VirtioInputSyncPtr input_;
  VirtioQueueFake event_queue_;
  VirtioQueueFake status_queue_;
  std::unique_ptr<component_testing::RealmRoot> realm_;
};

class VirtioInputKeyboardTest : public VirtioInputTest {
 protected:
  void SetUp() override {
    SetUpWithInputType(fuchsia::virtualization::hardware::InputType::WithKeyboard(
        keyboard_listener_.NewRequest()));
  }

  fuchsia::ui::input3::KeyboardListenerPtr keyboard_listener_;
};

class VirtioInputMouseTest : public VirtioInputTest, public fuchsia::ui::pointer::MouseSource {
 protected:
  void SetUp() override {
    fuchsia::ui::pointer::MouseSourceHandle mouse_client;
    binding_.Bind(mouse_client.NewRequest());
    SetUpWithInputType(
        fuchsia::virtualization::hardware::InputType::WithMouse(std::move(mouse_client)));
  }

  // fuchsia.ui.pointer.MouseSource implementation
  void Watch(WatchCallback callback) override {
    ASSERT_FALSE(watch_responder_.has_value()) << "Device has two Watch calls in flight";
    watch_responder_ = std::move(callback);
  }

  std::optional<fuchsia::ui::pointer::MouseSource::WatchCallback> TakeResponder() {
    return std::exchange(watch_responder_, std::nullopt);
  }

  fidl::Binding<fuchsia::ui::pointer::MouseSource> binding_{this};

 private:
  std::optional<fuchsia::ui::pointer::MouseSource::WatchCallback> watch_responder_;
};

TEST_P(VirtioInputKeyboardTest, Keyboard) {
  // Enqueue descriptors for the events. Do this before we inject the key event because the device
  // may choose to drop input events if there are no descriptors available:
  //
  // 5.8.6.2 Device Requirements: Device Operation
  //
  // A device MAY drop input events if the eventq does not have enough available buffers.
  auto events = AddEventDescriptorsToChain(2);
  ASSERT_TRUE(events.is_ok());

  zx_status_t status = input_->NotifyQueue(0);
  ASSERT_EQ(ZX_OK, status);

  // Inject a key event.
  std::optional<fuchsia::ui::input3::KeyEventStatus> key_status = std::nullopt;
  fuchsia::ui::input3::KeyEvent keyboard;
  keyboard.set_type(fuchsia::ui::input3::KeyEventType::PRESSED);
  keyboard.set_key(fuchsia::input::Key::A);
  keyboard_listener_->OnKeyEvent(std::move(keyboard), [&](auto result) { key_status = result; });

  // Expect the virtio event.
  status = WaitOnInterrupt();
  ASSERT_EQ(ZX_OK, status);

  // Verify we received 2 events; key press + sync.
  auto event_1 = events.value()[0];
  EXPECT_EQ(VIRTIO_INPUT_EV_KEY, event_1->type);
  EXPECT_EQ(30, event_1->code);
  EXPECT_EQ(VIRTIO_INPUT_EV_KEY_PRESSED, event_1->value);
  auto event_2 = events.value()[1];
  EXPECT_EQ(VIRTIO_INPUT_EV_SYN, event_2->type);
}

constexpr uint32_t kMouseDeviceId = 0;

fuchsia::ui::pointer::MouseEvent MakeMouseUpdate() {
  static uint64_t timestamp = 0;

  fuchsia::ui::pointer::MousePointerSample pointer_sample;
  pointer_sample.set_device_id(kMouseDeviceId);
  pointer_sample.set_position_in_viewport({0.0, 0.0});

  fuchsia::ui::pointer::MouseEvent mouse_event;
  mouse_event.set_timestamp(timestamp++);
  mouse_event.set_pointer_sample(std::move(pointer_sample));

  return mouse_event;
}

fuchsia::ui::pointer::MouseEvent MakeMouseEvent() {
  // clang-format off
  fuchsia::ui::pointer::ViewParameters view_parameters {
    .view = {
      .min = {0.0, 0.0},
      .max = {1.0, 1.0},
    },
    .viewport = {
      .min = {0.0, 0.0},
      .max = {1.0, 1.0},
    },
    .viewport_to_view_transform = {
      1.0, 0.0, 0.0,
      0.0, 1.0, 0.0,
      0.0, 0.0, 1.0,
    }
  };
  // clang-format on

  fuchsia::ui::pointer::MouseDeviceInfo mouse_device_info;
  mouse_device_info.set_id(kMouseDeviceId);
  mouse_device_info.set_buttons({1, 2});

  fuchsia::ui::pointer::MouseEvent mouse_event = MakeMouseUpdate();
  mouse_event.set_view_parameters(std::move(view_parameters));
  mouse_event.set_device_info(std::move(mouse_device_info));

  return mouse_event;
}

// TODO(https://fxbug.dev/434067533): Fix flaky test.
TEST_P(VirtioInputMouseTest, DISABLED_PointerMove) {
  std::array<float, 2> position = {0.25, 0.50};
  fuchsia::ui::pointer::MouseEvent mouse_event = MakeMouseEvent();
  *mouse_event.mutable_pointer_sample()->mutable_position_in_viewport() = position;

  // Right after device initialization it should be waiting on the first Watch call.
  binding_.WaitForMessage();
  RunLoopUntilIdle();
  auto responder = TakeResponder();
  ASSERT_TRUE(responder.has_value());

  // Add event descriptors before we send the mouse events lest the device drop them.
  auto result = AddEventDescriptorsToChain(3);
  ASSERT_TRUE(result.is_ok());
  auto events = result.value();
  zx_status_t status = input_->NotifyQueue(0);
  ASSERT_EQ(ZX_OK, status);

  // Inject the mouse event.
  std::vector<fuchsia::ui::pointer::MouseEvent> mouse_events;
  mouse_events.emplace(mouse_events.end(), std::move(mouse_event));
  (*responder)(std::move(mouse_events));

  // Expect the virtio event.
  status = WaitOnInterrupt();
  ASSERT_EQ(ZX_OK, status);

  // Check for an accurate translation of the mouse event
  EXPECT_EQ(VIRTIO_INPUT_EV_ABS, events[0]->type);
  EXPECT_EQ(VIRTIO_INPUT_EV_ABS_X, events[0]->code);
  EXPECT_EQ(static_cast<uint32_t>(std::floor(kInputAbsMaxX * position[0])), events[0]->value);
  EXPECT_EQ(VIRTIO_INPUT_EV_ABS, events[1]->type);
  EXPECT_EQ(VIRTIO_INPUT_EV_ABS_Y, events[1]->code);
  EXPECT_EQ(static_cast<uint32_t>(std::floor(kInputAbsMaxY * position[1])), events[1]->value);
  EXPECT_EQ(VIRTIO_INPUT_EV_SYN, events[2]->type);
}

TEST_P(VirtioInputMouseTest, DISABLED_PointerClick) {
  // Right after device initialization it should be waiting on the first Watch call.
  binding_.WaitForMessage();
  RunLoopUntilIdle();
  auto responder = TakeResponder();
  ASSERT_TRUE(responder.has_value());

  // Add event descriptors before we send the mouse events lest the device drop them.
  auto result = AddEventDescriptorsToChain(8);
  ASSERT_TRUE(result.is_ok());
  auto events = result.value();
  zx_status_t status = input_->NotifyQueue(0);
  ASSERT_EQ(ZX_OK, status);

  // Inject left mouse button pressed
  {
    fuchsia::ui::pointer::MouseEvent mouse_event = MakeMouseEvent();
    *mouse_event.mutable_pointer_sample()->mutable_pressed_buttons() = {1};

    std::vector<fuchsia::ui::pointer::MouseEvent> mouse_events;
    mouse_events.emplace(mouse_events.end(), std::move(mouse_event));
    (*responder)(std::move(mouse_events));

    // Expect the virtio event.
    status = WaitOnInterrupt();
    ASSERT_EQ(ZX_OK, status);
  }

  // get next watch request
  binding_.WaitForMessage();
  RunLoopUntilIdle();
  responder = TakeResponder();
  ASSERT_TRUE(responder.has_value());

  // Inject no mouse buttons pressed
  {
    fuchsia::ui::pointer::MouseEvent mouse_event = MakeMouseUpdate();
    *mouse_event.mutable_pointer_sample()->mutable_pressed_buttons() = {};

    std::vector<fuchsia::ui::pointer::MouseEvent> mouse_events;
    mouse_events.emplace(mouse_events.end(), std::move(mouse_event));
    (*responder)(std::move(mouse_events));

    // Expect the virtio event.
    status = WaitOnInterrupt();
    ASSERT_EQ(ZX_OK, status);
  }

  constexpr uint32_t kButtonMouseCode = 0x110;

  EXPECT_EQ(VIRTIO_INPUT_EV_ABS, events[0]->type);
  EXPECT_EQ(VIRTIO_INPUT_EV_ABS_X, events[0]->code);
  EXPECT_EQ(0u, events[0]->value);

  EXPECT_EQ(VIRTIO_INPUT_EV_ABS, events[1]->type);
  EXPECT_EQ(VIRTIO_INPUT_EV_ABS_Y, events[1]->code);
  EXPECT_EQ(0u, events[1]->value);

  EXPECT_EQ(VIRTIO_INPUT_EV_KEY, events[2]->type);
  EXPECT_EQ(kButtonMouseCode, events[2]->code);
  EXPECT_EQ(VIRTIO_INPUT_EV_KEY_PRESSED, events[2]->value);

  EXPECT_EQ(VIRTIO_INPUT_EV_SYN, events[3]->type);

  EXPECT_EQ(VIRTIO_INPUT_EV_ABS, events[4]->type);
  EXPECT_EQ(VIRTIO_INPUT_EV_ABS_X, events[4]->code);
  EXPECT_EQ(0u, events[4]->value);

  EXPECT_EQ(VIRTIO_INPUT_EV_ABS, events[5]->type);
  EXPECT_EQ(VIRTIO_INPUT_EV_ABS_Y, events[5]->code);
  EXPECT_EQ(0u, events[5]->value);

  EXPECT_EQ(VIRTIO_INPUT_EV_KEY, events[6]->type);
  EXPECT_EQ(kButtonMouseCode, events[6]->code);
  EXPECT_EQ(VIRTIO_INPUT_EV_KEY_RELEASED, events[6]->value);

  EXPECT_EQ(VIRTIO_INPUT_EV_SYN, events[7]->type);
}

INSTANTIATE_TEST_SUITE_P(VirtioInputKeyboardComponentsTest, VirtioInputKeyboardTest,
                         testing::Values(VirtioInputTestParam{"statusq", true},
                                         VirtioInputTestParam{"nostatusq", false}),
                         [](const testing::TestParamInfo<VirtioInputTestParam>& info) {
                           return info.param.test_name;
                         });

INSTANTIATE_TEST_SUITE_P(VirtioInputMouseComponentsTest, VirtioInputMouseTest,
                         testing::Values(VirtioInputTestParam{"statusq", true},
                                         VirtioInputTestParam{"nostatusq", false}),
                         [](const testing::TestParamInfo<VirtioInputTestParam>& info) {
                           return info.param.test_name;
                         });

}  // namespace