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

#include "ui/views/interaction/interaction_test_util_views.h"

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

#include "base/test/bind.h"
#include "build/build_config.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/accessibility/ax_action_data.h"
#include "ui/accessibility/ax_enums.mojom-shared.h"
#include "ui/base/accelerators/accelerator.h"
#include "ui/base/interaction/element_identifier.h"
#include "ui/base/interaction/element_tracker.h"
#include "ui/base/interaction/expect_call_in_scope.h"
#include "ui/base/interaction/interaction_test_util.h"
#include "ui/base/metadata/metadata_header_macros.h"
#include "ui/base/metadata/metadata_impl_macros.h"
#include "ui/base/models/combobox_model.h"
#include "ui/base/models/simple_combobox_model.h"
#include "ui/base/mojom/menu_source_type.mojom.h"
#include "ui/gfx/range/range.h"
#include "ui/menus/simple_menu_model.h"
#include "ui/views/accessibility/view_accessibility.h"
#include "ui/views/bubble/bubble_dialog_delegate_view.h"
#include "ui/views/controls/button/button.h"
#include "ui/views/controls/button/label_button.h"
#include "ui/views/controls/combobox/combobox.h"
#include "ui/views/controls/editable_combobox/editable_combobox.h"
#include "ui/views/controls/menu/menu_item_view.h"
#include "ui/views/controls/menu/menu_runner.h"
#include "ui/views/controls/tabbed_pane/tabbed_pane.h"
#include "ui/views/controls/textfield/textfield.h"
#include "ui/views/interaction/element_tracker_views.h"
#include "ui/views/layout/flex_layout.h"
#include "ui/views/layout/flex_layout_types.h"
#include "ui/views/test/views_test_base.h"
#include "ui/views/test/widget_test.h"
#include "ui/views/view.h"
#include "ui/views/view_class_properties.h"
#include "ui/views/view_utils.h"
#include "ui/views/widget/widget.h"

#if BUILDFLAG(IS_MAC)
#include "ui/base/interaction/interaction_test_util_mac.h"
#endif

namespace views::test {

namespace {
DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kMenuItemIdentifier);
const char16_t kMenuItem1[] = u"Menu item";
const char16_t kMenuItem2[] = u"Menu item 2";
const char16_t kTab1Title[] = u"Tab1";
const char16_t kTab2Title[] = u"Tab2";
const char16_t kTab3Title[] = u"Tab3";
const char16_t kComboBoxItem1[] = u"Item1";
const char16_t kComboBoxItem2[] = u"Item2";
const char16_t kComboBoxItem3[] = u"Item3";
constexpr int kMenuID1 = 1;
constexpr int kMenuID2 = 2;

class DefaultActionTestView : public View {
  METADATA_HEADER(DefaultActionTestView, View)

 public:
  DefaultActionTestView() = default;
  ~DefaultActionTestView() override = default;

  bool HandleAccessibleAction(const ui::AXActionData& action_data) override {
    EXPECT_EQ(ax::mojom::Action::kDoDefault, action_data.action);
    EXPECT_FALSE(activated_);
    activated_ = true;
    return true;
  }

  bool activated() const { return activated_; }

 private:
  bool activated_ = false;
};

BEGIN_METADATA(DefaultActionTestView)
END_METADATA

class AcceleratorView : public View {
  METADATA_HEADER(AcceleratorView, View)

 public:
  explicit AcceleratorView(ui::Accelerator accelerator)
      : accelerator_(accelerator) {
    AddAccelerator(accelerator);
  }

  bool AcceleratorPressed(const ui::Accelerator& accelerator) override {
    EXPECT_EQ(accelerator_, accelerator);
    EXPECT_FALSE(pressed_);
    pressed_ = true;
    return true;
  }

  bool CanHandleAccelerators() const override { return true; }

  bool pressed() const { return pressed_; }

 private:
  const ui::Accelerator accelerator_;
  bool pressed_ = false;
};

BEGIN_METADATA(AcceleratorView)
END_METADATA

}  // namespace

class InteractionTestUtilViewsTest
    : public ViewsTestBase,
      public testing::WithParamInterface<
          ui::test::InteractionTestUtil::InputType> {
 public:
  InteractionTestUtilViewsTest() = default;
  ~InteractionTestUtilViewsTest() override = default;

  std::unique_ptr<Widget> CreateWidget() {
    auto widget = std::make_unique<Widget>();
    Widget::InitParams params =
        CreateParams(Widget::InitParams::CLIENT_OWNS_WIDGET,
                     Widget::InitParams::TYPE_WINDOW_FRAMELESS);
    params.bounds = gfx::Rect(0, 0, 300, 300);
    widget->Init(std::move(params));
    auto* contents = widget->SetContentsView(std::make_unique<View>());
    auto* layout = contents->SetLayoutManager(std::make_unique<FlexLayout>());
    layout->SetOrientation(LayoutOrientation::kHorizontal);
    layout->SetDefault(kFlexBehaviorKey,
                       FlexSpecification(MinimumFlexSizeRule::kPreferred,
                                         MaximumFlexSizeRule::kUnbounded));
    WidgetVisibleWaiter visible_waiter(widget.get());
    widget->Show();
    visible_waiter.Wait();
    return widget;
  }

  static View* ElementToView(ui::TrackedElement* element) {
    return element ? element->AsA<TrackedElementViews>()->view() : nullptr;
  }

  void CreateMenuModel() {
    menu_model_ = std::make_unique<ui::SimpleMenuModel>(nullptr);
    menu_model_->AddItem(kMenuID1, kMenuItem1);
    menu_model_->AddItem(kMenuID2, kMenuItem2);
    menu_model_->SetElementIdentifierAt(1, kMenuItemIdentifier);
  }

  void ShowMenu() {
    CreateMenuModel();

    menu_runner_ =
        std::make_unique<MenuRunner>(menu_model_.get(), MenuRunner::NO_FLAGS);
    menu_runner_->RunMenuAt(
        widget_.get(), nullptr, gfx::Rect(gfx::Point(), gfx::Size(200, 200)),
        MenuAnchorPosition::kTopLeft, ui::mojom::MenuSourceType::kMouse);

    menu_item_ = AsViewClass<MenuItemView>(ElementToView(
        ui::ElementTracker::GetElementTracker()->GetFirstMatchingElement(
            kMenuItemIdentifier,
            ElementTrackerViews::GetContextForView(contents_))));
    Widget* const menu_widget = menu_item_->GetWidget();
    test::WidgetVisibleWaiter visible_waiter(menu_widget);
    visible_waiter.Wait();
    EXPECT_TRUE(menu_item_->GetVisible());
    EXPECT_TRUE(menu_item_->GetWidget()->IsVisible());
  }

  void CloseMenu() {
    menu_item_ = nullptr;
    menu_runner_.reset();
    menu_model_.reset();
  }

  void SetUp() override {
    ViewsTestBase::SetUp();
    widget_ = CreateWidget();
    contents_ = widget_->GetContentsView();
    test_util_ = std::make_unique<ui::test::InteractionTestUtil>();
    test_util_->AddSimulator(
        std::make_unique<InteractionTestUtilSimulatorViews>());
#if BUILDFLAG(IS_MAC)
    test_util_->AddSimulator(
        std::make_unique<ui::test::InteractionTestUtilSimulatorMac>());
#endif
  }

  void TearDown() override {
    test_util_.reset();
    if (menu_runner_) {
      CloseMenu();
    }
    contents_ = nullptr;
    widget_.reset();
    ViewsTestBase::TearDown();
  }

  std::unique_ptr<ui::ComboboxModel> CreateComboboxModel() {
    return std::make_unique<ui::SimpleComboboxModel>(
        std::vector<ui::SimpleComboboxModel::Item>{
            ui::SimpleComboboxModel::Item(kComboBoxItem1),
            ui::SimpleComboboxModel::Item(kComboBoxItem2),
            ui::SimpleComboboxModel::Item(kComboBoxItem3)});
  }

 protected:
  std::unique_ptr<ui::test::InteractionTestUtil> test_util_;
  std::unique_ptr<Widget> widget_;
  raw_ptr<View> contents_ = nullptr;
  std::unique_ptr<ui::SimpleMenuModel> menu_model_;
  std::unique_ptr<MenuRunner> menu_runner_;
  raw_ptr<MenuItemView> menu_item_ = nullptr;
};

TEST_P(InteractionTestUtilViewsTest, PressButton) {
  UNCALLED_MOCK_CALLBACK(Button::PressedCallback::Callback, pressed);
  // Add a spacer view to make sure we're actually trying to send events in the
  // appropriate coordinate space.
  contents_->AddChildView(
      std::make_unique<LabelButton>(Button::PressedCallback(), u"Spacer"));
  auto* const button = contents_->AddChildView(std::make_unique<LabelButton>(
      Button::PressedCallback(pressed.Get()), u"Button"));
  widget_->LayoutRootViewIfNecessary();
  EXPECT_CALL_IN_SCOPE(pressed, Run,
                       EXPECT_EQ(ui::test::ActionResult::kSucceeded,
                                 test_util_->PressButton(
                                     views::ElementTrackerViews::GetInstance()
                                         ->GetElementForView(button, true),
                                     GetParam())));
}

TEST_P(InteractionTestUtilViewsTest, SelectMenuItem) {
  ShowMenu();
  UNCALLED_MOCK_CALLBACK(ui::ElementTracker::Callback, pressed);
  auto subscription =
      ui::ElementTracker::GetElementTracker()->AddElementActivatedCallback(
          kMenuItemIdentifier,
          ElementTrackerViews::GetContextForWidget(widget_.get()),
          pressed.Get());
  EXPECT_CALL_IN_SCOPE(pressed, Run,
                       EXPECT_EQ(ui::test::ActionResult::kSucceeded,
                                 test_util_->SelectMenuItem(
                                     views::ElementTrackerViews::GetInstance()
                                         ->GetElementForView(menu_item_),
                                     GetParam())));
}

TEST_P(InteractionTestUtilViewsTest, DoDefault) {
  if (GetParam() == ui::test::InteractionTestUtil::InputType::kDontCare) {
    // Unfortunately, buttons don't respond to AX events the same way, so use a
    // custom view for this one case.
    auto* const view =
        contents_->AddChildView(std::make_unique<DefaultActionTestView>());
    widget_->LayoutRootViewIfNecessary();
    EXPECT_EQ(ui::test::ActionResult::kSucceeded,
              test_util_->DoDefaultAction(
                  views::ElementTrackerViews::GetInstance()->GetElementForView(
                      view, true)));
    EXPECT_TRUE(view->activated());

  } else {
    // A button can be used for this because we are simulating a usual event
    // type, which buttons respond to.
    UNCALLED_MOCK_CALLBACK(Button::PressedCallback::Callback, pressed);
    // Add a spacer view to make sure we're actually trying to send events in
    // the appropriate coordinate space.
    contents_->AddChildView(
        std::make_unique<LabelButton>(Button::PressedCallback(), u"Spacer"));
    auto* const button = contents_->AddChildView(std::make_unique<LabelButton>(
        Button::PressedCallback(pressed.Get()), u"Button"));
    widget_->LayoutRootViewIfNecessary();
    EXPECT_CALL_IN_SCOPE(pressed, Run,
                         EXPECT_EQ(ui::test::ActionResult::kSucceeded,
                                   test_util_->DoDefaultAction(
                                       views::ElementTrackerViews::GetInstance()
                                           ->GetElementForView(button, true),
                                       GetParam())));
  }
}

TEST_P(InteractionTestUtilViewsTest, SelectTab) {
  auto* const pane = contents_->AddChildView(std::make_unique<TabbedPane>());
  pane->AddTab(kTab1Title, std::make_unique<LabelButton>(
                               Button::PressedCallback(), u"Button"));
  pane->AddTab(kTab2Title, std::make_unique<LabelButton>(
                               Button::PressedCallback(), u"Button"));
  pane->AddTab(kTab3Title, std::make_unique<LabelButton>(
                               Button::PressedCallback(), u"Button"));
  auto* const pane_el =
      views::ElementTrackerViews::GetInstance()->GetElementForView(pane, true);
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectTab(pane_el, 2, GetParam()));
  EXPECT_EQ(2U, pane->GetSelectedTabIndex());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectTab(pane_el, 0, GetParam()));
  EXPECT_EQ(0U, pane->GetSelectedTabIndex());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectTab(pane_el, 1, GetParam()));
  EXPECT_EQ(1U, pane->GetSelectedTabIndex());
}

TEST_P(InteractionTestUtilViewsTest, SelectDropdownItem_Combobox) {
#if BUILDFLAG(IS_MAC)
  // Only kDontCare is supported on Mac.
  if (GetParam() != ui::test::InteractionTestUtil::InputType::kDontCare) {
    GTEST_SKIP();
  }
#endif

  auto* const box = contents_->AddChildView(
      std::make_unique<Combobox>(CreateComboboxModel()));
  box->GetViewAccessibility().SetName(u"Combobox");
  widget_->LayoutRootViewIfNecessary();
  auto* const box_el =
      views::ElementTrackerViews::GetInstance()->GetElementForView(box, true);
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectDropdownItem(box_el, 2, GetParam()));
  EXPECT_EQ(2U, box->GetSelectedIndex());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectDropdownItem(box_el, 0, GetParam()));
  EXPECT_EQ(0U, box->GetSelectedIndex());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectDropdownItem(box_el, 1, GetParam()));
  EXPECT_EQ(1U, box->GetSelectedIndex());
}

TEST_P(InteractionTestUtilViewsTest, SelectDropdownItem_EditableCombobox) {
#if BUILDFLAG(IS_MAC)
  // Only kDontCare is supported on Mac.
  if (GetParam() != ui::test::InteractionTestUtil::InputType::kDontCare) {
    GTEST_SKIP();
  }
#endif

  auto* const box = contents_->AddChildView(
      std::make_unique<EditableCombobox>(CreateComboboxModel()));
  box->GetViewAccessibility().SetName(u"Editable Combobox");
  widget_->LayoutRootViewIfNecessary();
  auto* const box_el =
      views::ElementTrackerViews::GetInstance()->GetElementForView(box, true);
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectDropdownItem(box_el, 2, GetParam()));
  EXPECT_EQ(kComboBoxItem3, box->GetText());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectDropdownItem(box_el, 0, GetParam()));
  EXPECT_EQ(kComboBoxItem1, box->GetText());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectDropdownItem(box_el, 1, GetParam()));
  EXPECT_EQ(kComboBoxItem2, box->GetText());
}

TEST_P(InteractionTestUtilViewsTest, SelectDropdownItem_Combobox_NoArrow) {
#if BUILDFLAG(IS_MAC)
  // Only kDontCare is supported on Mac.
  if (GetParam() != ui::test::InteractionTestUtil::InputType::kDontCare) {
    GTEST_SKIP();
  }
#endif

  auto* const box = contents_->AddChildView(
      std::make_unique<Combobox>(CreateComboboxModel()));
  box->SetShouldShowArrow(false);
  box->GetViewAccessibility().SetName(u"Combobox");
  widget_->LayoutRootViewIfNecessary();
  auto* const box_el =
      views::ElementTrackerViews::GetInstance()->GetElementForView(box, true);
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectDropdownItem(box_el, 2, GetParam()));
  EXPECT_EQ(2U, box->GetSelectedIndex());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectDropdownItem(box_el, 0, GetParam()));
  EXPECT_EQ(0U, box->GetSelectedIndex());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectDropdownItem(box_el, 1, GetParam()));
  EXPECT_EQ(1U, box->GetSelectedIndex());
}

TEST_P(InteractionTestUtilViewsTest,
       SelectDropdownItem_EditableCombobox_NoArrow) {
#if BUILDFLAG(IS_MAC)
  // Only kDontCare is supported on Mac.
  if (GetParam() != ui::test::InteractionTestUtil::InputType::kDontCare) {
    GTEST_SKIP();
  }
#endif

  // These cases are not supported for editable combobox without an arrow
  // button; editable comboboxes without arrows trigger on specific text input.
  if (GetParam() == ui::test::InteractionTestUtil::InputType::kMouse ||
      GetParam() == ui::test::InteractionTestUtil::InputType::kTouch) {
    GTEST_SKIP();
  }
  // Pass the default values for every parameter except for `display_arrow`.
  auto* const box = contents_->AddChildView(std::make_unique<EditableCombobox>(
      CreateComboboxModel(), false, true, EditableCombobox::kDefaultTextContext,
      EditableCombobox::kDefaultTextStyle, /* display_arrow =*/false));
  box->GetViewAccessibility().SetName(u"Editable Combobox");
  auto* const box_el =
      views::ElementTrackerViews::GetInstance()->GetElementForView(box, true);
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectDropdownItem(box_el, 2, GetParam()));
  EXPECT_EQ(kComboBoxItem3, box->GetText());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectDropdownItem(box_el, 0, GetParam()));
  EXPECT_EQ(kComboBoxItem1, box->GetText());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SelectDropdownItem(box_el, 1, GetParam()));
  EXPECT_EQ(kComboBoxItem2, box->GetText());
}

TEST_F(InteractionTestUtilViewsTest, EnterText_Textfield) {
  auto* const edit = contents_->AddChildView(std::make_unique<Textfield>());
  edit->SetDefaultWidthInChars(20);
  widget_->LayoutRootViewIfNecessary();

  auto* const edit_el =
      views::ElementTrackerViews::GetInstance()->GetElementForView(edit, true);

  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->EnterText(edit_el, u"abcd"));
  EXPECT_EQ(u"abcd", edit->GetText());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->EnterText(
                edit_el, u"efgh",
                ui::test::InteractionTestUtil::TextEntryMode::kReplaceAll));
  EXPECT_EQ(u"efgh", edit->GetText());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->EnterText(
                edit_el, u"abcd",
                ui::test::InteractionTestUtil::TextEntryMode::kAppend));
  EXPECT_EQ(u"efghabcd", edit->GetText());
  edit->SetSelectedRange(gfx::Range(2, 6));
  EXPECT_EQ(
      ui::test::ActionResult::kSucceeded,
      test_util_->EnterText(
          edit_el, u"1234",
          ui::test::InteractionTestUtil::TextEntryMode::kInsertOrReplace));
  EXPECT_EQ(u"ef1234cd", edit->GetText());
}

TEST_F(InteractionTestUtilViewsTest, EnterText_EditableCombobox) {
  auto* const box = contents_->AddChildView(
      std::make_unique<EditableCombobox>(CreateComboboxModel()));
  box->GetViewAccessibility().SetName(u"Editable Combobox");
  widget_->LayoutRootViewIfNecessary();

  auto* const box_el =
      views::ElementTrackerViews::GetInstance()->GetElementForView(box, true);

  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->EnterText(box_el, u"abcd"));
  EXPECT_EQ(u"abcd", box->GetText());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->EnterText(
                box_el, u"efgh",
                ui::test::InteractionTestUtil::TextEntryMode::kReplaceAll));
  EXPECT_EQ(u"efgh", box->GetText());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->EnterText(
                box_el, u"abcd",
                ui::test::InteractionTestUtil::TextEntryMode::kAppend));
  EXPECT_EQ(u"efghabcd", box->GetText());
  box->SelectRange(gfx::Range(2, 6));
  EXPECT_EQ(
      ui::test::ActionResult::kSucceeded,
      test_util_->EnterText(
          box_el, u"1234",
          ui::test::InteractionTestUtil::TextEntryMode::kInsertOrReplace));
  EXPECT_EQ(u"ef1234cd", box->GetText());
}

TEST_F(InteractionTestUtilViewsTest, ActivateSurface) {
  // Create a bubble that will close on deactivation.
  auto dialog_ptr = std::make_unique<BubbleDialogDelegateView>(
      BubbleDialogDelegateView::CreatePassKey(), contents_,
      BubbleBorder::Arrow::TOP_LEFT);
  dialog_ptr->set_close_on_deactivate(true);
  auto* widget = BubbleDialogDelegateView::CreateBubble(std::move(dialog_ptr));
  WidgetVisibleWaiter shown_waiter(widget);
  widget->Show();
  shown_waiter.Wait();

  // Activating the primary widget should close the bubble again.
  WidgetDestroyedWaiter closed_waiter(widget);
  auto* const view_el =
      ElementTrackerViews::GetInstance()->GetElementForView(contents_, true);
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->ActivateSurface(view_el));
  closed_waiter.Wait();
}

TEST_F(InteractionTestUtilViewsTest, SendAccelerator) {
  ui::Accelerator accel(ui::VKEY_F5, ui::EF_SHIFT_DOWN);
  ui::Accelerator accel2(ui::VKEY_F6, ui::EF_NONE);
  auto* const view =
      contents_->AddChildView(std::make_unique<AcceleratorView>(accel));
  auto* const view_el =
      ElementTrackerViews::GetInstance()->GetElementForView(view, true);
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SendAccelerator(view_el, accel2));
  EXPECT_FALSE(view->pressed());
  EXPECT_EQ(ui::test::ActionResult::kSucceeded,
            test_util_->SendAccelerator(view_el, accel));
  EXPECT_TRUE(view->pressed());
}

TEST_F(InteractionTestUtilViewsTest, Confirm) {
  UNCALLED_MOCK_CALLBACK(base::OnceClosure, accept);

  auto dialog_ptr = std::make_unique<BubbleDialogDelegateView>(
      BubbleDialogDelegateView::CreatePassKey(), contents_,
      BubbleBorder::Arrow::TOP_LEFT);
  auto* dialog = dialog_ptr.get();
  dialog->SetAcceptCallback(accept.Get());
  auto* widget = BubbleDialogDelegateView::CreateBubble(std::move(dialog_ptr));
  WidgetVisibleWaiter shown_waiter(widget);
  widget->Show();
  shown_waiter.Wait();

  auto* const dialog_el =
      views::ElementTrackerViews::GetInstance()->GetElementForView(dialog,
                                                                   true);

  EXPECT_CALL_IN_SCOPE(accept, Run, {
    EXPECT_EQ(ui::test::ActionResult::kSucceeded,
              test_util_->Confirm(dialog_el));
    WidgetDestroyedWaiter closed_waiter(widget);
    closed_waiter.Wait();
  });
}

INSTANTIATE_TEST_SUITE_P(
    ,
    InteractionTestUtilViewsTest,
    ::testing::Values(ui::test::InteractionTestUtil::InputType::kDontCare,
                      ui::test::InteractionTestUtil::InputType::kMouse,
                      ui::test::InteractionTestUtil::InputType::kKeyboard,
                      ui::test::InteractionTestUtil::InputType::kTouch),
    [](testing::TestParamInfo<ui::test::InteractionTestUtil::InputType>
           input_type) -> std::string {
      switch (input_type.param) {
        case ui::test::InteractionTestUtil::InputType::kDontCare:
          return "DontCare";
        case ui::test::InteractionTestUtil::InputType::kMouse:
          return "Mouse";
        case ui::test::InteractionTestUtil::InputType::kKeyboard:
          return "Keyboard";
        case ui::test::InteractionTestUtil::InputType::kTouch:
          return "Touch";
      }
    });

}  // namespace views::test