chromium/ui/events/ozone/evdev/tablet_event_converter_evdev_unittest.cc

// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "ui/events/ozone/evdev/tablet_event_converter_evdev.h"

#include <errno.h>
#include <fcntl.h>
#include <linux/input-event-codes.h>
#include <linux/input.h>
#include <unistd.h>

#include <memory>
#include <utility>
#include <vector>

#include "base/files/file_util.h"
#include "base/files/scoped_file.h"
#include "base/functional/bind.h"
#include "base/memory/ptr_util.h"
#include "base/posix/eintr_wrapper.h"
#include "base/run_loop.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/task_environment.h"
#include "base/time/time.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/re2/src/re2/re2.h"
#include "ui/events/event.h"
#include "ui/events/event_constants.h"
#include "ui/events/keycodes/keyboard_codes_posix.h"
#include "ui/events/ozone/device/device_manager.h"
#include "ui/events/ozone/evdev/event_converter_test_util.h"
#include "ui/events/ozone/evdev/event_device_test_util.h"
#include "ui/events/ozone/evdev/event_factory_evdev.h"
#include "ui/events/ozone/layout/stub/stub_keyboard_layout_engine.h"
#include "ui/events/platform/platform_event_dispatcher.h"
#include "ui/events/platform/platform_event_source.h"
#include "ui/events/test/scoped_event_test_tick_clock.h"
#include "ui/events/types/event_type.h"

#if BUILDFLAG(IS_CHROMEOS_ASH)
#include "ash/constants/ash_features.h"
#endif

namespace {

const char kTestDevicePath[] =;

const ui::DeviceAbsoluteAxis kWacomIntuos5SPenAbsAxes[] =;

const ui::DeviceCapabilities kWacomIntuos5SPen =;

constexpr char kWacomIntuos5SPenLogDescription[] =;

const ui::DeviceAbsoluteAxis EpsonBrightLink1430AbsAxes[] =;

const ui::DeviceCapabilities EpsonBrightLink1430 =;

const ui::DeviceAbsoluteAxis WacomOnePenTabletMediumCTC6110WLAbsAxes[] =;

const ui::DeviceCapabilities WacomOnePenTabletMediumCTC6110WL =;

const ui::DeviceAbsoluteAxis WacomIntuousProMPenPTH660AbsAxes[] =;

const ui::DeviceCapabilities WacomIntuousProMPenPTH660 =;

const ui::DeviceAbsoluteAxis XPPenStarG640AbsAxes[] =;

const ui::DeviceCapabilities XPPenStarG640 =;

const ui::DeviceAbsoluteAxis WacomOneByWacomSPenCTC472AbsAxes[] =;

const ui::DeviceCapabilities WacomOneByWacomSPenCTC472 =;
PointerType;

struct ExpectedEvent {};

std::string LogSubst(std::string description,
                     std::string key,
                     std::string replacement) {}

}  // namespace

namespace ui {

class MockTabletEventConverterEvdev : public TabletEventConverterEvdev {};

class MockTabletCursorEvdev : public CursorDelegateEvdev {};

MockTabletEventConverterEvdev::MockTabletEventConverterEvdev(
    base::ScopedFD fd,
    base::FilePath path,
    CursorDelegateEvdev* cursor,
    const EventDeviceInfo& devinfo,
    DeviceEventDispatcherEvdev* dispatcher)
    :{}

void MockTabletEventConverterEvdev::ConfigureReadMock(struct input_event* queue,
                                                      long read_this_many,
                                                      long queue_index) {}

}  // namespace ui

// Test fixture.
class TabletEventConverterEvdevTest : public testing::Test {};

#define EPSILON

// Uses real data captured from Wacom Intuos 5 Pen
TEST_F(TabletEventConverterEvdevTest, MoveTopLeft) {}

TEST_F(TabletEventConverterEvdevTest, MoveTopRight) {}

TEST_F(TabletEventConverterEvdevTest, MoveBottomLeft) {}

TEST_F(TabletEventConverterEvdevTest, MoveBottomRight) {}

TEST_F(TabletEventConverterEvdevTest,
       ShouldDisableMouseWarpingToOtherDisplays) {}

TEST_F(TabletEventConverterEvdevTest, Tap) {}

TEST_F(TabletEventConverterEvdevTest, StylusButtonPress) {}

#if BUILDFLAG(IS_CHROMEOS_ASH)
TEST_F(TabletEventConverterEvdevTest, TabletButtonPress) {
  base::test::ScopedFeatureList feature_list;
  feature_list.InitWithFeatures({ash::features::kInputDeviceSettingsSplit,
                                 ash::features::kPeripheralCustomization},
                                {});

  std::unique_ptr<ui::MockTabletEventConverterEvdev> dev =
      CreateDevice(kWacomIntuos5SPen);

  struct input_event mock_kernel_queue[] = {
      {{0, 0}, EV_KEY, BTN_0, 1},
      {{0, 0}, EV_KEY, BTN_0, 0},
  };

  dev->ProcessEvents(mock_kernel_queue, std::size(mock_kernel_queue));
  EXPECT_EQ(2u, size());

  ui::KeyEvent* event = dispatched_key_event(0);
  EXPECT_EQ(ui::EventType::kKeyPressed, event->type());
  EXPECT_EQ(ui::VKEY_BUTTON_0, event->key_code());
  event = dispatched_key_event(1);
  EXPECT_EQ(ui::EventType::kKeyReleased, event->type());
  EXPECT_EQ(ui::VKEY_BUTTON_0, event->key_code());
}
#endif

// Should only get an event if BTN_TOOL received
TEST_F(TabletEventConverterEvdevTest, CheckStylusFiltering) {}

// for digitizer pen with only one side button
TEST_F(TabletEventConverterEvdevTest, DigitizerPenOneSideButtonPress) {}

TEST_F(TabletEventConverterEvdevTest, NoButtonPressedKernel5And6) {}

TEST_F(TabletEventConverterEvdevTest, SideEraserAlwaysPressedKernel5) {}

TEST_F(TabletEventConverterEvdevTest, SideEraserAlwaysPressedKernel6) {}

TEST_F(TabletEventConverterEvdevTest, SideEraserReleasedWhileTouchingKernel5) {}

TEST_F(TabletEventConverterEvdevTest, SideEraserReleasedWhileTouchingKernel6) {}

TEST_F(TabletEventConverterEvdevTest,
       SideEraserPressedWhileTouchingKernel5And6) {}

TEST_F(TabletEventConverterEvdevTest, TailEraserKernel5And6) {}

TEST_F(TabletEventConverterEvdevTest, Button1AlwaysPressedKernel5) {}

TEST_F(TabletEventConverterEvdevTest, Button1AlwaysPressedKernel6) {}

TEST_F(TabletEventConverterEvdevTest, Button1ReleasedWhileTouchingKernel5) {}

TEST_F(TabletEventConverterEvdevTest, Button1ReleasedWhileTouchingKernel6) {}

TEST_F(TabletEventConverterEvdevTest, Button1PressedWhileTouchingKernel5) {}

TEST_F(TabletEventConverterEvdevTest, Button1PressedWhileTouchingKernel6) {}

TEST_F(TabletEventConverterEvdevTest, Button2AlwaysPressedKernel5And6) {}

TEST_F(TabletEventConverterEvdevTest, Button2ReleasedWhileTouchingKernel5And6) {}

TEST_F(TabletEventConverterEvdevTest, Button2PressedWhileTouchingKernel5And6) {}

TEST_F(TabletEventConverterEvdevTest,
       Button1AlwaysPressedWithTailEraserKernel5And6) {}

TEST_F(TabletEventConverterEvdevTest,
       Button1ReleasedWhileTouchingWithTailEraserKernel5And6) {}

TEST_F(TabletEventConverterEvdevTest,
       Button1PressedWhileTouchingWithTailEraserKernel5And6) {}

TEST_F(TabletEventConverterEvdevTest,
       Button2AlwaysPressedWithTailEraserKernel5And6) {}

TEST_F(TabletEventConverterEvdevTest,
       Button2ReleasedWhileTouchingWithTailEraserKernel5And6) {}

TEST_F(TabletEventConverterEvdevTest,
       Button2PressedWhileTouchingWithTailEraserKernel5And6) {}

TEST_F(TabletEventConverterEvdevTest, Basic) {}

// Twiddle each field that can reasonably be changed independently.
TEST_F(TabletEventConverterEvdevTest, LogPressureAbs) {}

TEST_F(TabletEventConverterEvdevTest, LogXYAbs) {}

TEST_F(TabletEventConverterEvdevTest, LogXYTilt) {}