result_selection_controller_unittest.cc 57 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471
  1. // Copyright 2019 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ash/app_list/views/result_selection_controller.h"
  5. #include <gtest/gtest.h>
  6. #include <cctype>
  7. #include <map>
  8. #include <memory>
  9. #include <string>
  10. #include <utility>
  11. #include <vector>
  12. #include "ash/app_list/app_list_test_view_delegate.h"
  13. #include "ash/app_list/model/search/test_search_result.h"
  14. #include "ash/app_list/views/search_result_actions_view.h"
  15. #include "ash/app_list/views/search_result_actions_view_delegate.h"
  16. #include "ash/app_list/views/search_result_container_view.h"
  17. #include "base/bind.h"
  18. #include "base/i18n/rtl.h"
  19. #include "base/strings/stringprintf.h"
  20. #include "ui/events/event.h"
  21. namespace ash {
  22. namespace {
  23. int g_last_created_result_index = -1;
  24. class TestResultViewWithActions;
  25. class TestResultView : public SearchResultBaseView {
  26. public:
  27. TestResultView() = default;
  28. TestResultView(const TestResultView&) = delete;
  29. TestResultView& operator=(const TestResultView&) = delete;
  30. ~TestResultView() override = default;
  31. virtual TestResultViewWithActions* AsResultViewWithActions() {
  32. return nullptr;
  33. }
  34. };
  35. class TestResultViewWithActions : public TestResultView,
  36. public SearchResultActionsViewDelegate {
  37. public:
  38. TestResultViewWithActions()
  39. : actions_view_owned_(std::make_unique<SearchResultActionsView>(this)) {
  40. set_actions_view(actions_view_owned_.get());
  41. }
  42. TestResultViewWithActions(const TestResultViewWithActions&) = delete;
  43. TestResultViewWithActions& operator=(const TestResultViewWithActions&) =
  44. delete;
  45. // TestResultView:
  46. TestResultViewWithActions* AsResultViewWithActions() override { return this; }
  47. // SearchResultActionsViewDelegate:
  48. void OnSearchResultActionActivated(size_t index) override {}
  49. bool IsSearchResultHoveredOrSelected() override { return selected(); }
  50. SearchResultActionsView* GetActionsView() {
  51. return actions_view_owned_.get();
  52. }
  53. private:
  54. std::unique_ptr<SearchResultActionsView> actions_view_owned_;
  55. };
  56. struct TestContainerParams {
  57. TestContainerParams() = default;
  58. TestContainerParams(bool horizontal, int result_count)
  59. : horizontal(horizontal), result_count(result_count) {}
  60. TestContainerParams(bool horizontal, int result_count, int actions_per_result)
  61. : horizontal(horizontal),
  62. result_count(result_count),
  63. actions_per_result(actions_per_result) {}
  64. // Whether the contairne is horizontal.
  65. bool horizontal = false;
  66. // Number of results in the container.
  67. int result_count = 0;
  68. // If set, the container will contain TestResultViewWithActions that
  69. // have |actions_per_result| actions each.
  70. absl::optional<int> actions_per_result;
  71. };
  72. class TestContainer : public SearchResultContainerView {
  73. public:
  74. TestContainer(const TestContainerParams& params,
  75. test::AppListTestViewDelegate* view_delegate)
  76. : SearchResultContainerView(view_delegate) {
  77. set_horizontally_traversable(params.horizontal);
  78. for (int i = 0; i < params.result_count; ++i) {
  79. std::string result_id =
  80. base::StringPrintf("result %d", ++g_last_created_result_index);
  81. auto result = std::make_unique<TestSearchResult>();
  82. result->set_result_id(result_id);
  83. if (params.actions_per_result.has_value()) {
  84. auto result_view = std::make_unique<TestResultViewWithActions>();
  85. result_view->SetResult(result.get());
  86. result_view->GetActionsView()->SetActions(
  87. std::vector<SearchResult::Action>(
  88. params.actions_per_result.value(),
  89. SearchResult::Action(SearchResultActionType::kRemove,
  90. std::u16string(), false)));
  91. search_result_views_.emplace_back(std::move(result_view));
  92. } else {
  93. auto result_view = std::make_unique<TestResultView>();
  94. result_view->SetResult(result.get());
  95. search_result_views_.emplace_back(std::move(result_view));
  96. }
  97. search_result_views_.back()->set_index_in_container(i);
  98. results_.emplace(result_id, std::move(result));
  99. }
  100. Update();
  101. }
  102. TestContainer(const TestContainer&) = delete;
  103. TestContainer& operator=(const TestContainer&) = delete;
  104. ~TestContainer() override = default;
  105. // SearchResultContainerView:
  106. SearchResultBaseView* GetResultViewAt(size_t index) override {
  107. DCHECK_LT(index, search_result_views_.size());
  108. return search_result_views_[index].get();
  109. }
  110. private:
  111. int DoUpdate() override { return search_result_views_.size(); }
  112. std::map<std::string, std::unique_ptr<TestSearchResult>> results_;
  113. std::vector<std::unique_ptr<TestResultView>> search_result_views_;
  114. };
  115. class ResultSelectionTest : public testing::Test,
  116. public testing::WithParamInterface<bool> {
  117. public:
  118. ResultSelectionTest() = default;
  119. ResultSelectionTest(const ResultSelectionTest&) = delete;
  120. ResultSelectionTest& operator=(const ResultSelectionTest&) = delete;
  121. ~ResultSelectionTest() override = default;
  122. void SetUp() override {
  123. if (testing::UnitTest::GetInstance()->current_test_info()->value_param()) {
  124. // Setup right to left environment if necessary.
  125. is_rtl_ = GetParam();
  126. if (is_rtl_)
  127. base::i18n::SetICUDefaultLocale("he");
  128. }
  129. if (!is_rtl_) {
  130. // Reset RTL if not needed.
  131. base::i18n::SetICUDefaultLocale("en");
  132. }
  133. app_list_test_delegate_ = std::make_unique<test::AppListTestViewDelegate>();
  134. result_selection_controller_ = std::make_unique<ResultSelectionController>(
  135. &containers_,
  136. base::BindRepeating(&ResultSelectionTest::OnSelectionChanged,
  137. base::Unretained(this)));
  138. testing::Test::SetUp();
  139. }
  140. void TearDown() override { g_last_created_result_index = -1; }
  141. protected:
  142. std::unique_ptr<TestContainer> CreateTestContainer(bool horizontal,
  143. int results) {
  144. return std::make_unique<TestContainer>(
  145. TestContainerParams(horizontal, results),
  146. app_list_test_delegate_.get());
  147. }
  148. std::vector<std::unique_ptr<SearchResultContainerView>> CreateContainerVector(
  149. int container_count,
  150. const TestContainerParams& container_params) {
  151. std::vector<std::unique_ptr<SearchResultContainerView>> containers;
  152. for (int i = 0; i < container_count; i++) {
  153. containers.emplace_back(std::make_unique<TestContainer>(
  154. container_params, app_list_test_delegate_.get()));
  155. }
  156. return containers;
  157. }
  158. std::vector<ResultLocationDetails> CreateLocationVector(
  159. int results,
  160. bool horizontal,
  161. int container_count = 1,
  162. int container_index = 0) {
  163. std::vector<ResultLocationDetails> locations;
  164. for (int i = 0; i < results; i++) {
  165. locations.emplace_back(ResultLocationDetails(
  166. container_index /*container_index*/,
  167. container_count /*container_count*/, i /*result_index*/,
  168. results /*result_count*/, horizontal /*container_is_horizontal*/));
  169. }
  170. return locations;
  171. }
  172. ResultLocationDetails GetCurrentLocation() const {
  173. return *result_selection_controller_->selected_location_details();
  174. }
  175. TestResultView* GetCurrentSelection() {
  176. ResultLocationDetails location = GetCurrentLocation();
  177. SearchResultBaseView* view =
  178. containers_[location.container_index]->GetResultViewAt(
  179. location.result_index);
  180. return static_cast<TestResultView*>(view);
  181. }
  182. // Asserts that currently selected result has a result action selected.
  183. // |action_index| - the index of the selected result action.
  184. testing::AssertionResult CurrentResultActionSelected(int action_index) {
  185. TestResultViewWithActions* view =
  186. GetCurrentSelection()->AsResultViewWithActions();
  187. if (!view) {
  188. return testing::AssertionFailure()
  189. << "Selected view with no action support";
  190. }
  191. if (!view->selected())
  192. return testing::AssertionFailure() << "View not selected";
  193. if (!view->GetActionsView()->HasSelectedAction())
  194. return testing::AssertionFailure() << "No selected action";
  195. int selected_action = view->GetActionsView()->GetSelectedAction();
  196. if (selected_action != action_index) {
  197. return testing::AssertionFailure()
  198. << "Wrong selected action " << selected_action;
  199. }
  200. return testing::AssertionSuccess();
  201. }
  202. // Asserts that the currently selected result has no selected result actions.
  203. testing::AssertionResult CurrentResultActionNotSelected() {
  204. TestResultViewWithActions* view =
  205. GetCurrentSelection()->AsResultViewWithActions();
  206. if (!view) {
  207. return testing::AssertionFailure()
  208. << "Selected view with no action support";
  209. }
  210. if (!view->selected())
  211. return testing::AssertionFailure() << "View not selected";
  212. int selected_action = view->GetActionsView()->GetSelectedAction();
  213. if (view->GetActionsView()->HasSelectedAction()) {
  214. return testing::AssertionFailure()
  215. << "Selected action found " << selected_action;
  216. }
  217. if (selected_action != -1) {
  218. return testing::AssertionFailure()
  219. << "Expected selected action index -1; found " << selected_action;
  220. }
  221. return testing::AssertionSuccess();
  222. }
  223. void SetContainers(
  224. const std::vector<std::unique_ptr<SearchResultContainerView>>&
  225. containers) {
  226. containers_.clear();
  227. for (auto& container : containers) {
  228. containers_.emplace_back(container.get());
  229. }
  230. }
  231. void TestSingleAxisTraversal(ui::KeyEvent* forward, ui::KeyEvent* backward) {
  232. const bool horizontal =
  233. result_selection_controller_->selected_location_details()
  234. ->container_is_horizontal;
  235. std::vector<ResultLocationDetails> locations =
  236. CreateLocationVector(4, horizontal);
  237. // These are divided to give as much detail as possible for a test failure.
  238. TestSingleAxisForward(forward, locations);
  239. if (horizontal) {
  240. TestSingleAxisLoop(forward, locations);
  241. TestSingleAxisLoopBack(backward, locations);
  242. } else {
  243. TestSingleAxisLoopRejected(forward, locations);
  244. }
  245. TestSingleAxisBackward(backward, locations);
  246. if (!horizontal) {
  247. TestSingleAxisLoopBackRejected(backward, locations);
  248. }
  249. }
  250. void TestSingleAxisForward(
  251. ui::KeyEvent* forward,
  252. const std::vector<ResultLocationDetails>& locations) {
  253. // Starts at the beginning
  254. ASSERT_EQ(*result_selection_controller_->selected_location_details(),
  255. locations[0]);
  256. for (size_t i = 1; i < locations.size(); i++) {
  257. ASSERT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  258. result_selection_controller_->MoveSelection(*forward));
  259. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  260. ASSERT_EQ(*result_selection_controller_->selected_location_details(),
  261. locations[i]);
  262. }
  263. // Expect steady traversal to the end
  264. }
  265. void TestSingleAxisLoop(ui::KeyEvent* forward,
  266. const std::vector<ResultLocationDetails>& locations) {
  267. // Starts at the end
  268. ASSERT_EQ(*result_selection_controller_->selected_location_details(),
  269. locations[3]);
  270. // Expect loop back to first result.
  271. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  272. result_selection_controller_->MoveSelection(*forward));
  273. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  274. ASSERT_EQ(*result_selection_controller_->selected_location_details(),
  275. locations[0]);
  276. }
  277. void TestSingleAxisLoopBack(
  278. ui::KeyEvent* backward,
  279. const std::vector<ResultLocationDetails>& locations) {
  280. // Starts at the first
  281. ASSERT_EQ(*result_selection_controller_->selected_location_details(),
  282. locations[0]);
  283. // Expect loop back to last result.
  284. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  285. result_selection_controller_->MoveSelection(*backward));
  286. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  287. ASSERT_EQ(*result_selection_controller_->selected_location_details(),
  288. locations[3]);
  289. }
  290. void TestSingleAxisLoopRejected(
  291. ui::KeyEvent* forward,
  292. const std::vector<ResultLocationDetails>& locations) {
  293. // Starts at the end
  294. ASSERT_EQ(*result_selection_controller_->selected_location_details(),
  295. locations[3]);
  296. // Expect no change in location.
  297. ASSERT_EQ(ResultSelectionController::MoveResult::kSelectionCycleRejected,
  298. result_selection_controller_->MoveSelection(*forward));
  299. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  300. ASSERT_EQ(*result_selection_controller_->selected_location_details(),
  301. locations[3]);
  302. }
  303. void TestSingleAxisLoopBackRejected(
  304. ui::KeyEvent* backward,
  305. const std::vector<ResultLocationDetails>& locations) {
  306. // Starts at the first
  307. ASSERT_EQ(*result_selection_controller_->selected_location_details(),
  308. locations[0]);
  309. // Expect no change in location.
  310. ASSERT_EQ(ResultSelectionController::MoveResult::kSelectionCycleRejected,
  311. result_selection_controller_->MoveSelection(*backward));
  312. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  313. ASSERT_EQ(*result_selection_controller_->selected_location_details(),
  314. locations[0]);
  315. }
  316. void TestSingleAxisBackward(
  317. ui::KeyEvent* backward,
  318. const std::vector<ResultLocationDetails>& locations) {
  319. ASSERT_FALSE(locations.empty());
  320. const size_t last_index = locations.size() - 1;
  321. // Test reverse direction from last result
  322. ASSERT_EQ(*result_selection_controller_->selected_location_details(),
  323. locations[last_index]);
  324. for (size_t i = last_index; i > 0; i--) {
  325. ASSERT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  326. result_selection_controller_->MoveSelection(*backward));
  327. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  328. ASSERT_EQ(*result_selection_controller_->selected_location_details(),
  329. locations[i - 1]);
  330. }
  331. }
  332. void TestMultiAxisTraversal(bool tab) {
  333. ui::KeyEvent* forward;
  334. ui::KeyEvent* backward;
  335. ui::KeyEvent* vertical_forward;
  336. ui::KeyEvent* vertical_backward;
  337. if (tab) {
  338. // Set up for tab traversal
  339. forward = vertical_forward = &tab_key_;
  340. backward = vertical_backward = &shift_tab_key_;
  341. } else {
  342. // Set up for arrow key traversal
  343. forward = is_rtl_ ? &left_arrow_ : &right_arrow_;
  344. backward = is_rtl_ ? &right_arrow_ : &left_arrow_;
  345. vertical_forward = &down_arrow_;
  346. vertical_backward = &up_arrow_;
  347. }
  348. int num_containers = containers_.size();
  349. for (int i = 0; i < num_containers; i++) {
  350. const bool horizontal =
  351. result_selection_controller_->selected_location_details()
  352. ->container_is_horizontal;
  353. std::vector<ResultLocationDetails> locations =
  354. CreateLocationVector(4, horizontal, num_containers, i);
  355. if (horizontal && !tab) {
  356. TestSingleAxisForward(forward, locations);
  357. TestSingleAxisLoop(forward, locations);
  358. TestSingleAxisLoopBack(backward, locations);
  359. TestSingleAxisBackward(backward, locations);
  360. TestSingleAxisLoopBack(backward, locations);
  361. // End on the last result.
  362. } else {
  363. // Tab and Vertical traversal are identical
  364. TestSingleAxisForward(vertical_forward, locations);
  365. TestSingleAxisBackward(vertical_backward, locations);
  366. TestSingleAxisForward(vertical_forward, locations);
  367. // End on the last result.
  368. }
  369. // Change Containers, if not the last container.
  370. ASSERT_EQ(
  371. i == num_containers - 1
  372. ? ResultSelectionController::MoveResult::kSelectionCycleRejected
  373. : ResultSelectionController::MoveResult::kResultChanged,
  374. result_selection_controller_->MoveSelection(*vertical_forward));
  375. EXPECT_EQ(i == num_containers - 1 ? 0 : 1,
  376. GetAndResetSelectionChangeCount());
  377. }
  378. }
  379. // Runs test for TAB traversal over containers that contain results with extra
  380. // result actions.
  381. void TestTabTraversalWithResultActions(bool horizontal_containers) {
  382. const int kContainerCount = 2;
  383. const int kResultsPerContainer = 2;
  384. const int kActionsPerResult = 2;
  385. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  386. CreateContainerVector(
  387. kContainerCount,
  388. TestContainerParams(horizontal_containers, kResultsPerContainer,
  389. kActionsPerResult));
  390. SetContainers(containers);
  391. auto create_test_location = [horizontal_containers](int container_index,
  392. int result_index) {
  393. return ResultLocationDetails(container_index, kContainerCount,
  394. result_index, kResultsPerContainer,
  395. horizontal_containers);
  396. };
  397. // Initialize the RSC for test.
  398. result_selection_controller_->ResetSelection(nullptr, false);
  399. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  400. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  401. EXPECT_TRUE(CurrentResultActionNotSelected());
  402. // TAB - the result should remain the same, but the selected action is
  403. // expected to change.
  404. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  405. result_selection_controller_->MoveSelection(tab_key_));
  406. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  407. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  408. EXPECT_TRUE(CurrentResultActionSelected(0));
  409. // TAB - the result should remain the same, but the selected action is
  410. // expected to change.
  411. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  412. result_selection_controller_->MoveSelection(tab_key_));
  413. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  414. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  415. EXPECT_TRUE(CurrentResultActionSelected(1));
  416. // TAB - move to the next result.
  417. TestResultView* previous_result = GetCurrentSelection();
  418. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  419. result_selection_controller_->MoveSelection(tab_key_));
  420. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  421. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  422. EXPECT_TRUE(CurrentResultActionNotSelected());
  423. EXPECT_FALSE(previous_result->selected());
  424. // Shift-TAB - move back to the previous result, and expect the last action
  425. // to be selected.
  426. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  427. result_selection_controller_->MoveSelection(shift_tab_key_));
  428. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  429. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  430. EXPECT_TRUE(CurrentResultActionSelected(1));
  431. // TAB - move back to next result.
  432. previous_result = GetCurrentSelection();
  433. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  434. result_selection_controller_->MoveSelection(tab_key_));
  435. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  436. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  437. EXPECT_TRUE(CurrentResultActionNotSelected());
  438. EXPECT_FALSE(previous_result->selected());
  439. // TAB - stay at the same result, but select next action.
  440. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  441. result_selection_controller_->MoveSelection(tab_key_));
  442. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  443. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  444. EXPECT_TRUE(CurrentResultActionSelected(0));
  445. // Shift-TAB - same result, but deselects actions.
  446. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  447. result_selection_controller_->MoveSelection(shift_tab_key_));
  448. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  449. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  450. EXPECT_TRUE(CurrentResultActionNotSelected());
  451. // TAB - reselect the first action.
  452. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  453. result_selection_controller_->MoveSelection(tab_key_));
  454. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  455. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  456. EXPECT_TRUE(CurrentResultActionSelected(0));
  457. // TAB - select the next action.
  458. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  459. result_selection_controller_->MoveSelection(tab_key_));
  460. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  461. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  462. EXPECT_TRUE(CurrentResultActionSelected(1));
  463. // TAB - select a result in the next container.
  464. previous_result = GetCurrentSelection();
  465. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  466. result_selection_controller_->MoveSelection(tab_key_));
  467. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  468. ASSERT_EQ(create_test_location(1, 0), GetCurrentLocation());
  469. EXPECT_TRUE(CurrentResultActionNotSelected());
  470. EXPECT_FALSE(previous_result->selected());
  471. // Shift-TAB - move to previous result/action.
  472. previous_result = GetCurrentSelection();
  473. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  474. result_selection_controller_->MoveSelection(shift_tab_key_));
  475. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  476. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  477. EXPECT_TRUE(CurrentResultActionSelected(1));
  478. EXPECT_FALSE(previous_result->selected());
  479. // Shift-TAB - move to previous action.
  480. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  481. result_selection_controller_->MoveSelection(shift_tab_key_));
  482. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  483. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  484. EXPECT_TRUE(CurrentResultActionSelected(0));
  485. }
  486. // Tests calling MoveSelection when none of the results are selected. The
  487. // effect should be the same as resetting selection.
  488. void TestMoveNullSelection(const ui::KeyEvent& key_event,
  489. bool expect_reverse,
  490. bool expect_action_selected) {
  491. const int kContainerCount = 2;
  492. const int kResultsPerContainer = 2;
  493. const int kActionsPerResult = 1;
  494. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  495. CreateContainerVector(kContainerCount,
  496. TestContainerParams(false, kResultsPerContainer,
  497. kActionsPerResult));
  498. SetContainers(containers);
  499. auto create_test_location = [](int container_index, int result_index) {
  500. return ResultLocationDetails(container_index, kContainerCount,
  501. result_index, kResultsPerContainer,
  502. false /*container_is_horizontal*/);
  503. };
  504. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  505. result_selection_controller_->MoveSelection(key_event));
  506. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  507. if (expect_reverse) {
  508. ASSERT_EQ(create_test_location(1, 1), GetCurrentLocation());
  509. } else {
  510. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  511. }
  512. if (expect_action_selected) {
  513. EXPECT_TRUE(CurrentResultActionSelected(0));
  514. } else {
  515. EXPECT_TRUE(CurrentResultActionNotSelected());
  516. }
  517. }
  518. std::unique_ptr<test::AppListTestViewDelegate> app_list_test_delegate_;
  519. std::unique_ptr<ResultSelectionController> result_selection_controller_;
  520. std::vector<SearchResultContainerView*> containers_;
  521. // Set up key events for test. These will never be marked as 'handled'.
  522. ui::KeyEvent down_arrow_ =
  523. ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_DOWN, ui::EF_NONE);
  524. ui::KeyEvent up_arrow_ =
  525. ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_UP, ui::EF_NONE);
  526. ui::KeyEvent left_arrow_ =
  527. ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_LEFT, ui::EF_NONE);
  528. ui::KeyEvent right_arrow_ =
  529. ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_RIGHT, ui::EF_NONE);
  530. ui::KeyEvent tab_key_ =
  531. ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_TAB, ui::EF_NONE);
  532. ui::KeyEvent shift_tab_key_ =
  533. ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_TAB, ui::EF_SHIFT_DOWN);
  534. int GetAndResetSelectionChangeCount() {
  535. const int result = selection_change_count_;
  536. selection_change_count_ = 0;
  537. return result;
  538. }
  539. void OnSelectionChanged() { selection_change_count_++; }
  540. bool is_rtl_ = false;
  541. int selection_change_count_ = 0;
  542. };
  543. INSTANTIATE_TEST_SUITE_P(RTL, ResultSelectionTest, testing::Bool());
  544. } // namespace
  545. TEST_F(ResultSelectionTest, VerticalTraversalOneContainerArrowKeys) {
  546. std::unique_ptr<TestContainer> vertical_container =
  547. CreateTestContainer(false, 4);
  548. // The vertical container is not horizontally traversable
  549. ASSERT_FALSE(vertical_container->horizontally_traversable());
  550. containers_.clear();
  551. containers_.emplace_back(vertical_container.get());
  552. // Initialize the RSC for test.
  553. result_selection_controller_->ResetSelection(nullptr, false);
  554. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  555. TestSingleAxisTraversal(&down_arrow_, &up_arrow_);
  556. }
  557. TEST_F(ResultSelectionTest, VerticalTraversalOneContainerTabKey) {
  558. std::unique_ptr<TestContainer> vertical_container =
  559. CreateTestContainer(false, 4);
  560. // The vertical container is not horizontally traversable
  561. ASSERT_FALSE(vertical_container->horizontally_traversable());
  562. containers_.clear();
  563. containers_.emplace_back(vertical_container.get());
  564. // Initialize the RSC for test.
  565. result_selection_controller_->ResetSelection(nullptr, false);
  566. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  567. TestSingleAxisTraversal(&tab_key_, &shift_tab_key_);
  568. }
  569. TEST_P(ResultSelectionTest, HorizontalTraversalOneContainerArrowKeys) {
  570. ui::KeyEvent* forward = is_rtl_ ? &left_arrow_ : &right_arrow_;
  571. ui::KeyEvent* backward = is_rtl_ ? &right_arrow_ : &left_arrow_;
  572. std::unique_ptr<TestContainer> horizontal_container =
  573. CreateTestContainer(true, 4);
  574. // The horizontal container is horizontally traversable
  575. ASSERT_TRUE(horizontal_container->horizontally_traversable());
  576. containers_.clear();
  577. containers_.emplace_back(horizontal_container.get());
  578. // Initialize the RSC for test.
  579. result_selection_controller_->ResetSelection(nullptr, false);
  580. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  581. TestSingleAxisTraversal(forward, backward);
  582. }
  583. TEST_P(ResultSelectionTest, HorizontalVerticalArrowKeys) {
  584. std::unique_ptr<TestContainer> horizontal_container =
  585. CreateTestContainer(true, 4);
  586. std::unique_ptr<TestContainer> vertical_container =
  587. CreateTestContainer(false, 4);
  588. containers_.clear();
  589. containers_.emplace_back(horizontal_container.get());
  590. containers_.emplace_back(vertical_container.get());
  591. // Initialize the RSC for test.
  592. result_selection_controller_->ResetSelection(nullptr, false);
  593. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  594. TestMultiAxisTraversal(false);
  595. }
  596. TEST_F(ResultSelectionTest, HorizontalVerticalTab) {
  597. std::unique_ptr<TestContainer> horizontal_container =
  598. CreateTestContainer(true, 4);
  599. std::unique_ptr<TestContainer> vertical_container =
  600. CreateTestContainer(false, 4);
  601. containers_.clear();
  602. containers_.emplace_back(horizontal_container.get());
  603. containers_.emplace_back(vertical_container.get());
  604. // Initialize the RSC for test.
  605. result_selection_controller_->ResetSelection(nullptr, false);
  606. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  607. TestMultiAxisTraversal(true);
  608. }
  609. TEST_F(ResultSelectionTest, TestVerticalStackArrows) {
  610. std::vector<std::unique_ptr<SearchResultContainerView>> vertical_containers =
  611. CreateContainerVector(4, TestContainerParams(false, 4));
  612. SetContainers(vertical_containers);
  613. // Initialize the RSC for test.
  614. result_selection_controller_->ResetSelection(nullptr, false);
  615. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  616. TestMultiAxisTraversal(false);
  617. }
  618. TEST_F(ResultSelectionTest, TestVerticalStackTab) {
  619. std::vector<std::unique_ptr<SearchResultContainerView>> vertical_containers =
  620. CreateContainerVector(4, TestContainerParams(false, 4));
  621. SetContainers(vertical_containers);
  622. // Initialize the RSC for test.
  623. result_selection_controller_->ResetSelection(nullptr, false);
  624. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  625. TestMultiAxisTraversal(true);
  626. }
  627. TEST_P(ResultSelectionTest, TestHorizontalStackArrows) {
  628. std::vector<std::unique_ptr<SearchResultContainerView>>
  629. horizontal_containers =
  630. CreateContainerVector(4, TestContainerParams(true, 4));
  631. SetContainers(horizontal_containers);
  632. // Initialize the RSC for test.
  633. result_selection_controller_->ResetSelection(nullptr, false);
  634. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  635. TestMultiAxisTraversal(false);
  636. }
  637. TEST_F(ResultSelectionTest, TestHorizontalStackTab) {
  638. std::vector<std::unique_ptr<SearchResultContainerView>>
  639. horizontal_containers =
  640. CreateContainerVector(4, TestContainerParams(true, 4));
  641. SetContainers(horizontal_containers);
  642. // Initialize the RSC for test.
  643. result_selection_controller_->ResetSelection(nullptr, false);
  644. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  645. TestMultiAxisTraversal(true);
  646. }
  647. TEST_P(ResultSelectionTest, TestHorizontalStackWithResultActionsArrows) {
  648. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  649. CreateContainerVector(4, TestContainerParams(true, 4, 2));
  650. SetContainers(containers);
  651. // Initialize the RSC for test.
  652. result_selection_controller_->ResetSelection(nullptr, false);
  653. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  654. TestMultiAxisTraversal(false);
  655. }
  656. TEST_F(ResultSelectionTest, TestVerticalStackWithResultActionsArrows) {
  657. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  658. CreateContainerVector(4, TestContainerParams(false, 4, 2));
  659. SetContainers(containers);
  660. // Initialize the RSC for test.
  661. result_selection_controller_->ResetSelection(nullptr, false);
  662. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  663. TestMultiAxisTraversal(false);
  664. }
  665. TEST_F(ResultSelectionTest, TestVerticalStackWithEmptyResultActionsTab) {
  666. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  667. CreateContainerVector(4, TestContainerParams(false, 4, 0));
  668. SetContainers(containers);
  669. // Initialize the RSC for test.
  670. result_selection_controller_->ResetSelection(nullptr, false);
  671. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  672. TestMultiAxisTraversal(false);
  673. }
  674. TEST_F(ResultSelectionTest, TestHorizontalStackWithEmptyResultActionsTab) {
  675. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  676. CreateContainerVector(4, TestContainerParams(false, 4, 0));
  677. SetContainers(containers);
  678. // Initialize the RSC for test.
  679. result_selection_controller_->ResetSelection(nullptr, false);
  680. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  681. TestMultiAxisTraversal(false);
  682. }
  683. TEST_F(ResultSelectionTest, TestHorizontalStackWithResultActionsTab) {
  684. TestTabTraversalWithResultActions(true /*horizontal_container*/);
  685. }
  686. TEST_F(ResultSelectionTest, TestVerticalStackWithResultActionsTab) {
  687. TestTabTraversalWithResultActions(false /*horizontal_container*/);
  688. }
  689. TEST_F(ResultSelectionTest, TabCycleInContainerWithResultActions) {
  690. const int kContainerCount = 2;
  691. const int kResultsPerContainer = 1;
  692. const int kActionsPerResult = 1;
  693. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  694. CreateContainerVector(
  695. kContainerCount,
  696. TestContainerParams(false, kResultsPerContainer, kActionsPerResult));
  697. SetContainers(containers);
  698. auto create_test_location = [](int container_index, int result_index) {
  699. return ResultLocationDetails(container_index, kContainerCount, result_index,
  700. kResultsPerContainer, false);
  701. };
  702. // Initialize the RSC for test.
  703. result_selection_controller_->ResetSelection(nullptr, false);
  704. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  705. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  706. EXPECT_TRUE(CurrentResultActionNotSelected());
  707. // Shift TAB - reject.
  708. EXPECT_EQ(ResultSelectionController::MoveResult::kSelectionCycleRejected,
  709. result_selection_controller_->MoveSelection(shift_tab_key_));
  710. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  711. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  712. EXPECT_TRUE(CurrentResultActionNotSelected());
  713. // TAB - the result should remain the same, but the selected action is
  714. // expected to change.
  715. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  716. result_selection_controller_->MoveSelection(tab_key_));
  717. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  718. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  719. EXPECT_TRUE(CurrentResultActionSelected(0));
  720. // TAB - move to the next result, which is in the next container.
  721. TestResultView* previous_result = GetCurrentSelection();
  722. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  723. result_selection_controller_->MoveSelection(tab_key_));
  724. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  725. ASSERT_EQ(create_test_location(1, 0), GetCurrentLocation());
  726. EXPECT_TRUE(CurrentResultActionNotSelected());
  727. EXPECT_FALSE(previous_result->selected());
  728. // TAB - next action selected.
  729. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  730. result_selection_controller_->MoveSelection(tab_key_));
  731. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  732. ASSERT_EQ(create_test_location(1, 0), GetCurrentLocation());
  733. EXPECT_TRUE(CurrentResultActionSelected(0));
  734. // TAB - rejected, as selection would cycle to the beginning.
  735. EXPECT_EQ(ResultSelectionController::MoveResult::kSelectionCycleRejected,
  736. result_selection_controller_->MoveSelection(tab_key_));
  737. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  738. ASSERT_EQ(create_test_location(1, 0), GetCurrentLocation());
  739. EXPECT_TRUE(CurrentResultActionSelected(0));
  740. }
  741. TEST_F(ResultSelectionTest, TabCycleInContainerSingleResult) {
  742. const int kContainerCount = 1;
  743. const int kResultsPerContainer = 1;
  744. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  745. CreateContainerVector(kContainerCount,
  746. TestContainerParams(false, kResultsPerContainer));
  747. SetContainers(containers);
  748. auto create_test_location = [](int container_index, int result_index) {
  749. return ResultLocationDetails(container_index, kContainerCount, result_index,
  750. kResultsPerContainer, false);
  751. };
  752. // Initialize the RSC for test.
  753. result_selection_controller_->ResetSelection(nullptr, false);
  754. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  755. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  756. // Shift TAB - reject going to the last result (even though it's the same as
  757. // the first result).
  758. EXPECT_EQ(ResultSelectionController::MoveResult::kSelectionCycleRejected,
  759. result_selection_controller_->MoveSelection(shift_tab_key_));
  760. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  761. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  762. // TAB - reject goting to the first result (event though it's the same as the
  763. // last result).
  764. EXPECT_EQ(ResultSelectionController::MoveResult::kSelectionCycleRejected,
  765. result_selection_controller_->MoveSelection(tab_key_));
  766. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  767. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  768. }
  769. TEST_F(ResultSelectionTest, TabCycleInContainerSingleResultWithActionUsingTab) {
  770. const int kContainerCount = 1;
  771. const int kResultsPerContainer = 1;
  772. const int kActionsPerResult = 1;
  773. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  774. CreateContainerVector(
  775. kContainerCount,
  776. TestContainerParams(false, kResultsPerContainer, kActionsPerResult));
  777. SetContainers(containers);
  778. auto create_test_location = [](int container_index, int result_index) {
  779. return ResultLocationDetails(container_index, kContainerCount, result_index,
  780. kResultsPerContainer, false);
  781. };
  782. // Initialize the RSC for test.
  783. result_selection_controller_->ResetSelection(nullptr, false);
  784. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  785. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  786. EXPECT_TRUE(CurrentResultActionNotSelected());
  787. // Shift TAB - reject going to the last result.
  788. EXPECT_EQ(ResultSelectionController::MoveResult::kSelectionCycleRejected,
  789. result_selection_controller_->MoveSelection(shift_tab_key_));
  790. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  791. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  792. EXPECT_TRUE(CurrentResultActionNotSelected());
  793. // TAB - the result should remain the same, but the selected action is
  794. // expected to change.
  795. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  796. result_selection_controller_->MoveSelection(tab_key_));
  797. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  798. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  799. EXPECT_TRUE(CurrentResultActionSelected(0));
  800. // TAB - rejected, as selection would cycle to the beginning.
  801. EXPECT_EQ(ResultSelectionController::MoveResult::kSelectionCycleRejected,
  802. result_selection_controller_->MoveSelection(tab_key_));
  803. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  804. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  805. EXPECT_TRUE(CurrentResultActionSelected(0));
  806. }
  807. TEST_F(ResultSelectionTest,
  808. TabCycleInContainerSingleResultWithActionUsingUpDown) {
  809. const int kContainerCount = 1;
  810. const int kResultsPerContainer = 1;
  811. const int kActionsPerResult = 1;
  812. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  813. CreateContainerVector(
  814. kContainerCount,
  815. TestContainerParams(false, kResultsPerContainer, kActionsPerResult));
  816. SetContainers(containers);
  817. auto create_test_location = [](int container_index, int result_index) {
  818. return ResultLocationDetails(container_index, kContainerCount, result_index,
  819. kResultsPerContainer, false);
  820. };
  821. // Initialize the RSC for test.
  822. result_selection_controller_->ResetSelection(nullptr, false);
  823. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  824. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  825. EXPECT_TRUE(CurrentResultActionNotSelected());
  826. // UP - reject going to the last result.
  827. EXPECT_EQ(ResultSelectionController::MoveResult::kSelectionCycleRejected,
  828. result_selection_controller_->MoveSelection(up_arrow_));
  829. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  830. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  831. EXPECT_TRUE(CurrentResultActionNotSelected());
  832. // DOWN - rejected, as selection would cycle to the beginning (even though the
  833. // first element is the same as the last).
  834. EXPECT_EQ(ResultSelectionController::MoveResult::kSelectionCycleRejected,
  835. result_selection_controller_->MoveSelection(down_arrow_));
  836. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  837. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  838. EXPECT_TRUE(CurrentResultActionNotSelected());
  839. }
  840. TEST_P(ResultSelectionTest,
  841. TestHorizontalStackWithResultActions_ForwardBackWithActionSelected) {
  842. const int kContainerCount = 2;
  843. const int kResultsPerContainer = 2;
  844. const int kActionsPerResult = 2;
  845. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  846. CreateContainerVector(
  847. kContainerCount,
  848. TestContainerParams(true, kResultsPerContainer, kActionsPerResult));
  849. SetContainers(containers);
  850. auto create_test_location = [](int container_index, int result_index) {
  851. return ResultLocationDetails(container_index, kContainerCount, result_index,
  852. kResultsPerContainer,
  853. true /*container_is_horizontal*/);
  854. };
  855. // Initialize the RSC for test.
  856. result_selection_controller_->ResetSelection(nullptr, false);
  857. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  858. ui::KeyEvent* forward = is_rtl_ ? &left_arrow_ : &right_arrow_;
  859. ui::KeyEvent* backward = is_rtl_ ? &right_arrow_ : &left_arrow_;
  860. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  861. EXPECT_TRUE(CurrentResultActionNotSelected());
  862. // TAB to select an action.
  863. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  864. result_selection_controller_->MoveSelection(tab_key_));
  865. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  866. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  867. EXPECT_TRUE(CurrentResultActionSelected(0));
  868. // Forward selects the next result.
  869. TestResultView* previous_result = GetCurrentSelection();
  870. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  871. result_selection_controller_->MoveSelection(*forward));
  872. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  873. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  874. EXPECT_TRUE(CurrentResultActionNotSelected());
  875. EXPECT_FALSE(previous_result->selected());
  876. // TAB to select an action.
  877. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  878. result_selection_controller_->MoveSelection(tab_key_));
  879. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  880. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  881. EXPECT_TRUE(CurrentResultActionSelected(0));
  882. // Backward selects the previous result.
  883. previous_result = GetCurrentSelection();
  884. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  885. result_selection_controller_->MoveSelection(*backward));
  886. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  887. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  888. EXPECT_TRUE(CurrentResultActionNotSelected());
  889. EXPECT_FALSE(previous_result->selected());
  890. }
  891. TEST_F(ResultSelectionTest,
  892. TestVerticalStackWithResultActions_UpDownWithActionSelected) {
  893. const int kContainerCount = 2;
  894. const int kResultsPerContainer = 2;
  895. const int kActionsPerResult = 2;
  896. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  897. CreateContainerVector(
  898. kContainerCount,
  899. TestContainerParams(false, kResultsPerContainer, kActionsPerResult));
  900. SetContainers(containers);
  901. auto create_test_location = [](int container_index, int result_index) {
  902. return ResultLocationDetails(container_index, kContainerCount, result_index,
  903. kResultsPerContainer,
  904. false /*container_is_horizontal*/);
  905. };
  906. // Initialize the RSC for test.
  907. result_selection_controller_->ResetSelection(nullptr, false);
  908. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  909. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  910. EXPECT_TRUE(CurrentResultActionNotSelected());
  911. // TAB to select an action.
  912. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  913. result_selection_controller_->MoveSelection(tab_key_));
  914. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  915. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  916. EXPECT_TRUE(CurrentResultActionSelected(0));
  917. // DOWN selects the next result.
  918. TestResultView* previous_result = GetCurrentSelection();
  919. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  920. result_selection_controller_->MoveSelection(down_arrow_));
  921. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  922. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  923. EXPECT_TRUE(CurrentResultActionNotSelected());
  924. EXPECT_FALSE(previous_result->selected());
  925. // TAB to select an action.
  926. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  927. result_selection_controller_->MoveSelection(tab_key_));
  928. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  929. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  930. EXPECT_TRUE(CurrentResultActionSelected(0));
  931. // UP selects the previous result.
  932. previous_result = GetCurrentSelection();
  933. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  934. result_selection_controller_->MoveSelection(up_arrow_));
  935. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  936. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  937. EXPECT_TRUE(CurrentResultActionNotSelected());
  938. EXPECT_FALSE(previous_result->selected());
  939. }
  940. TEST_F(ResultSelectionTest, ResetWhileFirstResultActionSelected) {
  941. const int kContainerCount = 2;
  942. const int kResultsPerContainer = 2;
  943. const int kActionsPerResult = 2;
  944. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  945. CreateContainerVector(
  946. kContainerCount,
  947. TestContainerParams(false, kResultsPerContainer, kActionsPerResult));
  948. SetContainers(containers);
  949. auto create_test_location = [](int container_index, int result_index) {
  950. return ResultLocationDetails(container_index, kContainerCount, result_index,
  951. kResultsPerContainer,
  952. false /*container_is_horizontal*/);
  953. };
  954. // Initialize the RSC for test.
  955. result_selection_controller_->ResetSelection(nullptr, false);
  956. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  957. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  958. EXPECT_TRUE(CurrentResultActionNotSelected());
  959. // TAB to select an action.
  960. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  961. result_selection_controller_->MoveSelection(tab_key_));
  962. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  963. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  964. EXPECT_TRUE(CurrentResultActionSelected(0));
  965. // Reset selection - reset selects the new first result, i.e. the same result
  966. // as before reset. The selected action should remain the same.
  967. TestResultView* pre_reset_selection = GetCurrentSelection();
  968. result_selection_controller_->ResetSelection(nullptr, false);
  969. EXPECT_EQ(pre_reset_selection, GetCurrentSelection());
  970. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  971. EXPECT_TRUE(CurrentResultActionSelected(0));
  972. }
  973. TEST_F(ResultSelectionTest, ResetWhileResultActionSelected) {
  974. const int kContainerCount = 2;
  975. const int kResultsPerContainer = 2;
  976. const int kActionsPerResult = 2;
  977. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  978. CreateContainerVector(
  979. kContainerCount,
  980. TestContainerParams(false, kResultsPerContainer, kActionsPerResult));
  981. SetContainers(containers);
  982. auto create_test_location = [](int container_index, int result_index) {
  983. return ResultLocationDetails(container_index, kContainerCount, result_index,
  984. kResultsPerContainer,
  985. false /*container_is_horizontal*/);
  986. };
  987. // Initialize the RSC for test.
  988. result_selection_controller_->ResetSelection(nullptr, false);
  989. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  990. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  991. EXPECT_TRUE(CurrentResultActionNotSelected());
  992. // DOWN to select another result.
  993. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  994. result_selection_controller_->MoveSelection(down_arrow_));
  995. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  996. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  997. EXPECT_TRUE(CurrentResultActionNotSelected());
  998. // TAB to select an action.
  999. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  1000. result_selection_controller_->MoveSelection(tab_key_));
  1001. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  1002. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  1003. EXPECT_TRUE(CurrentResultActionSelected(0));
  1004. // Reset selection.
  1005. TestResultView* pre_reset_selection = GetCurrentSelection();
  1006. result_selection_controller_->ResetSelection(nullptr, false);
  1007. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  1008. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  1009. EXPECT_TRUE(CurrentResultActionSelected(0));
  1010. EXPECT_TRUE(pre_reset_selection->selected());
  1011. }
  1012. TEST_F(ResultSelectionTest, ActionRemovedWhileSelected) {
  1013. const int kContainerCount = 2;
  1014. const int kResultsPerContainer = 2;
  1015. const int kActionsPerResult = 3;
  1016. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  1017. CreateContainerVector(
  1018. kContainerCount,
  1019. TestContainerParams(false, kResultsPerContainer, kActionsPerResult));
  1020. SetContainers(containers);
  1021. auto create_test_location = [](int container_index, int result_index) {
  1022. return ResultLocationDetails(container_index, kContainerCount, result_index,
  1023. kResultsPerContainer,
  1024. false /*container_is_horizontal*/);
  1025. };
  1026. // Initialize the RSC for test.
  1027. result_selection_controller_->ResetSelection(nullptr, false);
  1028. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  1029. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  1030. EXPECT_TRUE(CurrentResultActionNotSelected());
  1031. // DOWN to select another result.
  1032. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  1033. result_selection_controller_->MoveSelection(down_arrow_));
  1034. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  1035. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  1036. EXPECT_TRUE(CurrentResultActionNotSelected());
  1037. // TAB to select the last action.
  1038. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  1039. result_selection_controller_->MoveSelection(tab_key_));
  1040. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  1041. result_selection_controller_->MoveSelection(tab_key_));
  1042. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  1043. result_selection_controller_->MoveSelection(tab_key_));
  1044. EXPECT_EQ(3, GetAndResetSelectionChangeCount());
  1045. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  1046. EXPECT_TRUE(CurrentResultActionSelected(2));
  1047. TestResultView* selected_view = GetCurrentSelection();
  1048. ASSERT_TRUE(selected_view);
  1049. ASSERT_TRUE(selected_view->AsResultViewWithActions());
  1050. // Remove two trailing actions - the result action is de-selected.
  1051. selected_view->AsResultViewWithActions()->GetActionsView()->SetActions(
  1052. std::vector<SearchResult::Action>(
  1053. 1, SearchResult::Action(ash::SearchResultActionType::kRemove,
  1054. std::u16string(), false)));
  1055. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  1056. EXPECT_TRUE(CurrentResultActionNotSelected());
  1057. // Shift-TAB move selection to the previous result.
  1058. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  1059. result_selection_controller_->MoveSelection(shift_tab_key_));
  1060. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  1061. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  1062. EXPECT_TRUE(CurrentResultActionSelected(2));
  1063. }
  1064. TEST_F(ResultSelectionTest, MoveNullSelectionTab) {
  1065. TestMoveNullSelection(tab_key_, false /*reverse*/,
  1066. false /*expect_action_selected*/);
  1067. }
  1068. TEST_F(ResultSelectionTest, MoveNullSelectionShiftTab) {
  1069. TestMoveNullSelection(shift_tab_key_, true /*reverse*/,
  1070. true /*expect_action_selected*/);
  1071. }
  1072. TEST_F(ResultSelectionTest, MoveNullSelectionDown) {
  1073. TestMoveNullSelection(down_arrow_, false /*reverse*/,
  1074. false /*expect_action_selected*/);
  1075. }
  1076. TEST_F(ResultSelectionTest, MoveNullSelectionUp) {
  1077. TestMoveNullSelection(up_arrow_, true /*reverse*/,
  1078. false /*expect_action_selected*/);
  1079. }
  1080. TEST_F(ResultSelectionTest, MoveNullSelectionForward) {
  1081. TestMoveNullSelection(right_arrow_, false /*reverse*/,
  1082. false /*expect_action_selected*/);
  1083. }
  1084. TEST_F(ResultSelectionTest, MoveNullSelectionBack) {
  1085. TestMoveNullSelection(left_arrow_, false /*reverse*/,
  1086. false /*expect_action_selected*/);
  1087. }
  1088. TEST_F(ResultSelectionTest, ResetSelectionWithSelectionChangesBlocked) {
  1089. const int kContainerCount = 2;
  1090. const int kResultsPerContainer = 2;
  1091. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  1092. CreateContainerVector(kContainerCount,
  1093. TestContainerParams(false, kResultsPerContainer));
  1094. SetContainers(containers);
  1095. auto create_test_location = [](int container_index, int result_index) {
  1096. return ResultLocationDetails(container_index, kContainerCount, result_index,
  1097. kResultsPerContainer,
  1098. false /*container_is_horizontal*/);
  1099. };
  1100. // Set up non default selection,
  1101. result_selection_controller_->ResetSelection(nullptr, false);
  1102. result_selection_controller_->MoveSelection(down_arrow_);
  1103. EXPECT_EQ(2, GetAndResetSelectionChangeCount());
  1104. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  1105. // Test that calling reset selection while selection changes are blocked does
  1106. // not change the selected result.
  1107. result_selection_controller_->set_block_selection_changes(true);
  1108. result_selection_controller_->ResetSelection(nullptr, false);
  1109. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  1110. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  1111. EXPECT_TRUE(result_selection_controller_->selected_result());
  1112. // Reset should be enabled once selection changes are unblocked.
  1113. result_selection_controller_->set_block_selection_changes(false);
  1114. result_selection_controller_->ResetSelection(nullptr, false);
  1115. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  1116. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  1117. EXPECT_TRUE(result_selection_controller_->selected_result());
  1118. }
  1119. TEST_F(ResultSelectionTest, InitialResetSelectionWithSelectionChangesBlocked) {
  1120. const int kContainerCount = 2;
  1121. const int kResultsPerContainer = 2;
  1122. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  1123. CreateContainerVector(kContainerCount,
  1124. TestContainerParams(false, kResultsPerContainer));
  1125. SetContainers(containers);
  1126. // Test that calling reset selection while selection changes are blocked does
  1127. // not set the selected result.
  1128. result_selection_controller_->set_block_selection_changes(true);
  1129. result_selection_controller_->ResetSelection(nullptr, false);
  1130. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  1131. EXPECT_FALSE(result_selection_controller_->selected_result());
  1132. EXPECT_FALSE(result_selection_controller_->selected_location_details());
  1133. // Reset should be enabled once selection changes are unblocked.
  1134. result_selection_controller_->set_block_selection_changes(false);
  1135. result_selection_controller_->ResetSelection(nullptr, false);
  1136. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  1137. EXPECT_TRUE(result_selection_controller_->selected_result());
  1138. EXPECT_TRUE(result_selection_controller_->selected_location_details());
  1139. }
  1140. TEST_F(ResultSelectionTest, MoveSelectionWithSelectionChangesBlocked) {
  1141. const int kContainerCount = 2;
  1142. const int kResultsPerContainer = 2;
  1143. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  1144. CreateContainerVector(kContainerCount,
  1145. TestContainerParams(false, kResultsPerContainer));
  1146. SetContainers(containers);
  1147. auto create_test_location = [](int container_index, int result_index) {
  1148. return ResultLocationDetails(container_index, kContainerCount, result_index,
  1149. kResultsPerContainer,
  1150. false /*container_is_horizontal*/);
  1151. };
  1152. result_selection_controller_->ResetSelection(nullptr, false);
  1153. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  1154. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  1155. // Test that calling move selection while selection chages are blocked does
  1156. // not change the selected result.
  1157. result_selection_controller_->set_block_selection_changes(true);
  1158. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  1159. result_selection_controller_->MoveSelection(down_arrow_));
  1160. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  1161. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  1162. EXPECT_TRUE(result_selection_controller_->selected_result());
  1163. // Move should succeed once selection changes are unblocked.
  1164. result_selection_controller_->set_block_selection_changes(false);
  1165. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  1166. result_selection_controller_->MoveSelection(down_arrow_));
  1167. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  1168. ASSERT_EQ(create_test_location(0, 1), GetCurrentLocation());
  1169. EXPECT_TRUE(result_selection_controller_->selected_result());
  1170. }
  1171. TEST_F(ResultSelectionTest, MoveNullSelectionWithSelectionChangesBlocked) {
  1172. const int kContainerCount = 2;
  1173. const int kResultsPerContainer = 2;
  1174. std::vector<std::unique_ptr<SearchResultContainerView>> containers =
  1175. CreateContainerVector(kContainerCount,
  1176. TestContainerParams(false, kResultsPerContainer));
  1177. SetContainers(containers);
  1178. auto create_test_location = [](int container_index, int result_index) {
  1179. return ResultLocationDetails(container_index, kContainerCount, result_index,
  1180. kResultsPerContainer,
  1181. false /*container_is_horizontal*/);
  1182. };
  1183. // Test that calling move selection while selection chages are blocked does
  1184. // not change the selected result.
  1185. result_selection_controller_->set_block_selection_changes(true);
  1186. EXPECT_EQ(ResultSelectionController::MoveResult::kNone,
  1187. result_selection_controller_->MoveSelection(down_arrow_));
  1188. EXPECT_EQ(0, GetAndResetSelectionChangeCount());
  1189. EXPECT_FALSE(result_selection_controller_->selected_result());
  1190. EXPECT_FALSE(result_selection_controller_->selected_location_details());
  1191. // Move should succeed once selection changes are unblocked.
  1192. result_selection_controller_->set_block_selection_changes(false);
  1193. EXPECT_EQ(ResultSelectionController::MoveResult::kResultChanged,
  1194. result_selection_controller_->MoveSelection(down_arrow_));
  1195. EXPECT_EQ(1, GetAndResetSelectionChangeCount());
  1196. ASSERT_EQ(create_test_location(0, 0), GetCurrentLocation());
  1197. EXPECT_TRUE(result_selection_controller_->selected_result());
  1198. }
  1199. } // namespace ash