1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17
18 #include "mock_element_node_iterator.h"
19 #define private public
20 #define protected public
21 #include "select_strategy.h"
22 #undef private
23 #undef protected
24 #include "ui_controller.h"
25 #include "ui_action.h"
26
27 using namespace OHOS::uitest;
28 using namespace std;
29
TEST(SelectStrategyTest,refreshWidgetBoundsParentAndChild)30 TEST(SelectStrategyTest, refreshWidgetBoundsParentAndChild)
31 {
32 std::vector<WidgetMatchModel> emptyMatcher;
33 StrategyBuildParam buildParam;
34 buildParam.myselfMatcher = emptyMatcher;
35 std::unique_ptr<SelectStrategy> plain = SelectStrategy::BuildSelectStrategy(buildParam, false);
36 Rect selectWindow{10, 100, 10, 300};
37 Rect layer1{10, 50, 10, 40};
38 Rect layer2{10, 20, 50, 100};
39 std::vector<Rect> overlay;
40 overlay.emplace_back(layer1);
41 overlay.emplace_back(layer2);
42 plain->SetAndCalcSelectWindowRect(selectWindow, overlay);
43 Widget widget{"test"};
44 Rect widOriBounds{30, 30, 30, 60};
45 widget.SetBounds(widOriBounds);
46 widget.SetAttr(UiAttr::VISIBLE, "true");
47 widget.SetAttr(UiAttr::TYPE, "Scroll");
48 plain->RefreshWidgetBounds(selectWindow, widget);
49 ASSERT_EQ(widget.GetAttr(UiAttr::VISIBLE), "true");
50 auto rect = widget.GetBounds();
51 ASSERT_EQ(rect.left_, 30);
52 ASSERT_EQ(rect.right_, 30);
53 ASSERT_EQ(rect.top_, 30);
54 ASSERT_EQ(rect.bottom_, 60);
55 }
56
TEST(SelectStrategyTest,refreshWidgetBoundsOver)57 TEST(SelectStrategyTest, refreshWidgetBoundsOver)
58 {
59 std::vector<WidgetMatchModel> emptyMatcher;
60 StrategyBuildParam buildParam;
61 buildParam.myselfMatcher = emptyMatcher;
62 std::unique_ptr<SelectStrategy> plain = SelectStrategy::BuildSelectStrategy(buildParam, false);
63 Rect selectWindow{10, 100, 10, 300};
64 Rect layer1{10, 50, 10, 40};
65 Rect layer2{10, 20, 50, 100};
66 std::vector<Rect> overlay;
67 overlay.emplace_back(layer1);
68 overlay.emplace_back(layer2);
69 plain->SetAndCalcSelectWindowRect(selectWindow, overlay);
70 Widget widget{"test"};
71 Rect widOriBounds{20, 50, 30, 40};
72 widget.SetBounds(widOriBounds);
73 plain->RefreshWidgetBounds(selectWindow, widget);
74 ASSERT_EQ(widget.GetAttr(UiAttr::VISIBLE), "false");
75 auto rect = widget.GetBounds();
76 ASSERT_EQ(rect.left_, 0);
77 ASSERT_EQ(rect.right_, 0);
78 ASSERT_EQ(rect.top_, 0);
79 ASSERT_EQ(rect.bottom_, 0);
80 }
81
TEST(SelectStrategyTest,refreshWidgetBoundsPartOver)82 TEST(SelectStrategyTest, refreshWidgetBoundsPartOver)
83 {
84 std::vector<WidgetMatchModel> emptyMatcher;
85 StrategyBuildParam buildParam;
86 buildParam.myselfMatcher = emptyMatcher;
87 std::unique_ptr<SelectStrategy> plain = SelectStrategy::BuildSelectStrategy(buildParam, false);
88 Rect selectWindow{10, 100, 10, 300};
89 Rect layer1{10, 50, 10, 40};
90 Rect layer2{10, 20, 50, 100};
91 std::vector<Rect> overlay;
92 overlay.emplace_back(layer1);
93 overlay.emplace_back(layer2);
94 plain->SetAndCalcSelectWindowRect(selectWindow, overlay);
95 Widget widget{"test"};
96 Rect widOriBounds{20, 50, 30, 50};
97 widget.SetBounds(widOriBounds);
98 plain->RefreshWidgetBounds(selectWindow, widget);
99 ASSERT_EQ(widget.GetAttr(UiAttr::VISIBLE), "true");
100 auto rect = widget.GetBounds();
101 ASSERT_EQ(rect.left_, 20);
102 ASSERT_EQ(rect.right_, 50);
103 ASSERT_EQ(rect.top_, 40);
104 ASSERT_EQ(rect.bottom_, 50);
105 }
106
ConstructIterator(std::unique_ptr<ElementNodeIterator> & iterator)107 void ConstructIterator(std::unique_ptr<ElementNodeIterator> &iterator)
108 {
109 std::string afterDom = R"(
110 {
111 "attributes":{
112 "windowId":"12",
113 "componentType":"List",
114 "content":"Text List",
115 "rectInScreen":"30,60,10,120"
116 },
117 "children":[
118 {
119 "attributes":{
120 "windowId":"12",
121 "componentType":"List",
122 "content":"Text List",
123 "rectInScreen":"30,60,10,120"
124 },
125 "children":[
126 {
127 "attributes":{
128 "windowId":"12",
129 "componentType":"Image",
130 "content":"Button",
131 "rectInScreen":"30,40,10,20"
132 },
133 "children":[
134 {
135 "attributes":{
136 "windowId":"12",
137 "accessibilityId":"4",
138 "componentType":"Text",
139 "content":"Text One",
140 "rectInScreen":"30,40,10,20"
141 },
142 "children":[]
143 }
144 ]
145 },
146 {
147 "attributes":{
148 "windowId":"12",
149 "componentType":"List",
150 "accessibilityId":"7",
151 "content":"Text List12",
152 "rectInScreen":"40,60,10,20"
153 },
154 "children":[
155 {
156 "attributes":{
157 "windowId":"12",
158 "accessibilityId":"5",
159 "componentType":"Text",
160 "content":"Text One",
161 "rectInScreen":"40,50,10,20"
162 },
163 "children":[]
164 },
165 {
166 "attributes":{
167 "windowId":"12",
168 "accessibilityId":"4",
169 "componentType":"Text",
170 "rectInScreen":"50,60,10,20"
171 },
172 "children":[]
173 }
174 ]
175 }
176 ]
177 },
178 {
179 "attributes":{
180 "windowId":"12",
181 "componentType":"Image",
182 "content":"Button",
183 "rectInScreen":"10,20,20,100"
184 },
185 "children":[]
186 },
187 {
188 "attributes":{
189 "windowId":"12",
190 "componentType":"Scroll",
191 "content":"Button",
192 "rectInScreen":"20,100,20,100"
193 },
194 "children":[
195 {
196 "attributes":{
197 "windowId":"12",
198 "componentType":"Image",
199 "content":"",
200 "rectInScreen":"20,100,20,100"
201 },
202 "children":[]
203 },
204 {
205 "attributes":{
206 "windowId":"12",
207 "componentType":"Button",
208 "accessibilityId":"11",
209 "content":"Button text2",
210 "focused":"true",
211 "rectInScreen":"20,100,20,100"
212 },
213 "children":[
214 {
215 "attributes":{
216 "windowId":"12",
217 "componentType":"Text",
218 "content":"Text End",
219 "rectInScreen":"20,100,20,100"
220 },
221 "children":[]
222 }
223 ]
224 }
225 ]
226 }
227 ]
228 }
229 )";
230 iterator = MockElementNodeIterator::ConstructIteratorByJson(afterDom);
231 }
232
TEST(SelectStrategyTest,afterStrategyForAnchorIsBeforeTarget)233 TEST(SelectStrategyTest, afterStrategyForAnchorIsBeforeTarget)
234 {
235 Window w1{12};
236 w1.windowLayer_ = 2;
237 w1.bounds_ = Rect{0, 100, 0, 120};
238 std::vector<Widget> visits;
239 std::vector<int> targets;
240 WidgetMatchModel anchor1{UiAttr::TEXT, "test", ValueMatchPattern::EQ};
241 std::vector<WidgetMatchModel> anchorMatchers;
242 anchorMatchers.emplace_back(anchor1);
243 WidgetMatchModel sef1{UiAttr::TEXT, "Text One", ValueMatchPattern::EQ};
244 std::vector<WidgetMatchModel> myselfMatchers;
245 myselfMatchers.emplace_back(sef1);
246 StrategyBuildParam buildParam;
247 buildParam.myselfMatcher = myselfMatchers;
248 buildParam.afterAnchorMatcherVec.emplace_back(anchorMatchers);
249 std::unique_ptr<SelectStrategy> afterStrategy = SelectStrategy::BuildSelectStrategy(buildParam, false);
250 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
251 ConstructIterator(iterator);
252 afterStrategy->LocateNode(w1, *iterator.get(), visits, targets);
253 ASSERT_EQ(visits.size(), 12);
254 ASSERT_EQ(targets.size(), 0);
255 }
TEST(SelectStrategyTest,afterStrategyForAnchorIsAfterSingleTarget)256 TEST(SelectStrategyTest, afterStrategyForAnchorIsAfterSingleTarget)
257 {
258 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
259 ConstructIterator(iterator);
260 Window w1{12};
261 w1.windowLayer_ = 2;
262 w1.bounds_ = Rect{0, 100, 0, 120};
263 std::vector<Widget> visits2;
264 std::vector<int> targets2;
265 WidgetMatchModel anchor2{UiAttr::TEXT, "Text List12", ValueMatchPattern::EQ};
266 std::vector<WidgetMatchModel> anchorMatchers;
267 anchorMatchers.emplace_back(anchor2);
268 WidgetMatchModel sef2{UiAttr::TEXT, "Text One", ValueMatchPattern::EQ};
269 std::vector<WidgetMatchModel> myselfMatchers;
270 myselfMatchers.emplace_back(sef2);
271 StrategyBuildParam buildParam;
272 buildParam.myselfMatcher = myselfMatchers;
273 buildParam.afterAnchorMatcherVec.emplace_back(anchorMatchers);
274 std::unique_ptr<SelectStrategy> afterStrategy2 = SelectStrategy::BuildSelectStrategy(buildParam, false);
275 afterStrategy2->LocateNode(w1, *iterator.get(), visits2, targets2);
276 ASSERT_EQ(targets2.size(), 1);
277 ASSERT_EQ(visits2[targets2[0]].GetAttr(UiAttr::ACCESSIBILITY_ID), "5");
278 }
279
TEST(SelectStrategyTest,afterStrategyForAnchorIsAfterMultiTarget)280 TEST(SelectStrategyTest, afterStrategyForAnchorIsAfterMultiTarget)
281 {
282 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
283 ConstructIterator(iterator);
284 Window w1{12};
285 w1.windowLayer_ = 2;
286 w1.bounds_ = Rect{0, 100, 0, 120};
287 std::vector<Widget> visits3;
288 std::vector<int> targets3;
289 WidgetMatchModel anchor3{UiAttr::TEXT, "Text List", ValueMatchPattern::EQ};
290 WidgetMatchModel sef3{UiAttr::TEXT, "Text One", ValueMatchPattern::EQ};
291 std::vector<WidgetMatchModel> anchorMatchers;
292 anchorMatchers.emplace_back(anchor3);
293 std::vector<WidgetMatchModel> myselfMatchers;
294 myselfMatchers.emplace_back(sef3);
295 StrategyBuildParam buildParam;
296 buildParam.myselfMatcher = myselfMatchers;
297 buildParam.afterAnchorMatcherVec.emplace_back(anchorMatchers);
298 std::unique_ptr<SelectStrategy> afterStrategy3 = SelectStrategy::BuildSelectStrategy(buildParam, true);
299 afterStrategy3->LocateNode(w1, *iterator.get(), visits3, targets3);
300 ASSERT_EQ(visits3.size(), 12);
301 ASSERT_EQ(targets3.size(), 2);
302 ASSERT_EQ(visits3[targets3[0]].GetAttr(UiAttr::ACCESSIBILITY_ID), "4");
303 ASSERT_EQ(visits3[targets3[1]].GetAttr(UiAttr::ACCESSIBILITY_ID), "5");
304 }
305
TEST(SelectStrategyTest,beforeStrategyForAnchorIsAfterTarget)306 TEST(SelectStrategyTest, beforeStrategyForAnchorIsAfterTarget)
307 {
308 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
309 ConstructIterator(iterator);
310 Window w1{12};
311 w1.windowLayer_ = 2;
312 w1.bounds_ = Rect{0, 100, 0, 120};
313 std::vector<Widget> visits;
314 std::vector<int> targets;
315 WidgetMatchModel anchor1{UiAttr::TEXT, "test", ValueMatchPattern::EQ};
316 WidgetMatchModel sef1{UiAttr::TEXT, "Text One", ValueMatchPattern::EQ};
317 std::vector<WidgetMatchModel> anchorMatchers;
318 anchorMatchers.emplace_back(anchor1);
319 std::vector<WidgetMatchModel> myselfMatchers;
320 myselfMatchers.emplace_back(sef1);
321 StrategyBuildParam buildParam;
322 buildParam.myselfMatcher = myselfMatchers;
323 buildParam.beforeAnchorMatcherVec.emplace_back(anchorMatchers);
324 std::unique_ptr<SelectStrategy> beforeStrategy = SelectStrategy::BuildSelectStrategy(buildParam, false);
325 beforeStrategy->LocateNode(w1, *iterator.get(), visits, targets);
326 ASSERT_EQ(visits.size(), 12);
327 ASSERT_EQ(targets.size(), 0);
328 }
TEST(SelectStrategyTest,beforeStrategyForAnchorIsBeforeSingleTarget)329 TEST(SelectStrategyTest, beforeStrategyForAnchorIsBeforeSingleTarget)
330 {
331 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
332 ConstructIterator(iterator);
333 Window w1{12};
334 w1.windowLayer_ = 2;
335 w1.bounds_ = Rect{0, 100, 0, 120};
336 std::vector<Widget> visits2;
337 std::vector<int> targets2;
338 WidgetMatchModel anchor2{UiAttr::TEXT, "Text One", ValueMatchPattern::EQ};
339 WidgetMatchModel sef2{UiAttr::TEXT, "Text List12", ValueMatchPattern::EQ};
340 std::vector<WidgetMatchModel> anchorMatchers;
341 anchorMatchers.emplace_back(anchor2);
342 std::vector<WidgetMatchModel> myselfMatchers;
343 myselfMatchers.emplace_back(sef2);
344 StrategyBuildParam buildParam;
345 buildParam.myselfMatcher = myselfMatchers;
346 buildParam.beforeAnchorMatcherVec.emplace_back(anchorMatchers);
347 std::unique_ptr<SelectStrategy> beforeStrategy2 = SelectStrategy::BuildSelectStrategy(buildParam, false);
348 beforeStrategy2->LocateNode(w1, *iterator.get(), visits2, targets2);
349 ASSERT_EQ(targets2.size(), 1);
350 ASSERT_EQ(visits2[targets2[0]].GetAttr(UiAttr::ACCESSIBILITY_ID), "7");
351 }
TEST(SelectStrategyTest,beforeStrategyForAnchorIsBeforeMultiTarget)352 TEST(SelectStrategyTest, beforeStrategyForAnchorIsBeforeMultiTarget)
353 {
354 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
355 ConstructIterator(iterator);
356 Window w1{12};
357 w1.windowLayer_ = 2;
358 w1.bounds_ = Rect{0, 100, 0, 120};
359 std::vector<Widget> visits3;
360 std::vector<int> targets3;
361 WidgetMatchModel anchor3{UiAttr::TEXT, "Text End", ValueMatchPattern::EQ};
362 WidgetMatchModel sef3{UiAttr::TEXT, "Text One", ValueMatchPattern::EQ};
363 std::vector<WidgetMatchModel> anchorMatchers;
364 anchorMatchers.emplace_back(anchor3);
365 std::vector<WidgetMatchModel> myselfMatchers;
366 myselfMatchers.emplace_back(sef3);
367 StrategyBuildParam buildParam;
368 buildParam.myselfMatcher = myselfMatchers;
369 buildParam.beforeAnchorMatcherVec.emplace_back(anchorMatchers);
370 std::unique_ptr<SelectStrategy> beforeStrategy3 = SelectStrategy::BuildSelectStrategy(buildParam, true);
371 beforeStrategy3->LocateNode(w1, *iterator.get(), visits3, targets3, false);
372 ASSERT_EQ(visits3.size(), 12);
373 ASSERT_EQ(targets3.size(), 2);
374 ASSERT_EQ(visits3[targets3[0]].GetAttr(UiAttr::ACCESSIBILITY_ID), "4");
375 ASSERT_EQ(visits3[targets3[1]].GetAttr(UiAttr::ACCESSIBILITY_ID), "5");
376 }
377
TEST(SelectStrategyTest,beforeStrategyForAnchorIsTargetForMultiTargets)378 TEST(SelectStrategyTest, beforeStrategyForAnchorIsTargetForMultiTargets)
379 {
380 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
381 ConstructIterator(iterator);
382 Window w1{12};
383 w1.windowLayer_ = 2;
384 w1.bounds_ = Rect{0, 100, 0, 120};
385 std::vector<Widget> visits3;
386 std::vector<int> targets3;
387 WidgetMatchModel anchor3{UiAttr::TEXT, "Text End", ValueMatchPattern::EQ};
388 WidgetMatchModel sef3{UiAttr::TYPE, "Text", ValueMatchPattern::EQ};
389 std::vector<WidgetMatchModel> anchorMatchers;
390 anchorMatchers.emplace_back(anchor3);
391 std::vector<WidgetMatchModel> myselfMatchers;
392 myselfMatchers.emplace_back(sef3);
393 StrategyBuildParam buildParam;
394 buildParam.myselfMatcher = myselfMatchers;
395 buildParam.beforeAnchorMatcherVec.emplace_back(anchorMatchers);
396 std::unique_ptr<SelectStrategy> beforeStrategy3 = SelectStrategy::BuildSelectStrategy(buildParam, true);
397 beforeStrategy3->LocateNode(w1, *iterator.get(), visits3, targets3, false);
398 ASSERT_EQ(visits3.size(), 12);
399 ASSERT_EQ(targets3.size(), 3);
400 ASSERT_EQ(visits3[targets3[0]].GetAttr(UiAttr::TEXT), "Text One");
401 ASSERT_EQ(visits3[targets3[1]].GetAttr(UiAttr::TEXT), "Text One");
402 ASSERT_EQ(visits3[targets3[2]].GetAttr(UiAttr::TEXT), "");
403 }
404
TEST(SelectStrategyTest,beforeStrategyForAnchorIsTargetForSingleTarget)405 TEST(SelectStrategyTest, beforeStrategyForAnchorIsTargetForSingleTarget)
406 {
407 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
408 ConstructIterator(iterator);
409 Window w1{12};
410 w1.windowLayer_ = 2;
411 w1.bounds_ = Rect{0, 100, 0, 120};
412 std::vector<Widget> visits3;
413 std::vector<int> targets3;
414 WidgetMatchModel anchor3{UiAttr::TEXT, "Text One", ValueMatchPattern::EQ};
415 WidgetMatchModel sef3{UiAttr::TYPE, "Image", ValueMatchPattern::EQ};
416 std::vector<WidgetMatchModel> anchorMatchers;
417 anchorMatchers.emplace_back(anchor3);
418 std::vector<WidgetMatchModel> myselfMatchers;
419 myselfMatchers.emplace_back(sef3);
420 StrategyBuildParam buildParam;
421 buildParam.myselfMatcher = myselfMatchers;
422 buildParam.beforeAnchorMatcherVec.emplace_back(anchorMatchers);
423 std::unique_ptr<SelectStrategy> beforeStrategy3 = SelectStrategy::BuildSelectStrategy(buildParam, true);
424 beforeStrategy3->LocateNode(w1, *iterator.get(), visits3, targets3, false);
425 ASSERT_EQ(visits3.size(), 12);
426 ASSERT_EQ(targets3.size(), 1);
427 ASSERT_EQ(visits3[targets3[0]].GetAttr(UiAttr::TEXT), "Button");
428 }
429
TEST(SelectStrategyTest,withInStrategyForAnchorIsOutTarget)430 TEST(SelectStrategyTest, withInStrategyForAnchorIsOutTarget)
431 {
432 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
433 ConstructIterator(iterator);
434 Window w1{12};
435 w1.windowLayer_ = 2;
436 w1.bounds_ = Rect{0, 100, 0, 120};
437 std::vector<Widget> visits;
438 std::vector<int> targets;
439 WidgetMatchModel anchor1{UiAttr::TEXT, "test", ValueMatchPattern::EQ};
440 WidgetMatchModel sef1{UiAttr::TEXT, "Text One", ValueMatchPattern::EQ};
441 std::vector<WidgetMatchModel> anchorMatchers;
442 anchorMatchers.emplace_back(anchor1);
443 std::vector<WidgetMatchModel> myselfMatchers;
444 myselfMatchers.emplace_back(sef1);
445 StrategyBuildParam buildParam;
446 buildParam.myselfMatcher = myselfMatchers;
447 buildParam.withInAnchorMatcherVec.emplace_back(anchorMatchers);
448 std::unique_ptr<SelectStrategy> withInStrategy = SelectStrategy::BuildSelectStrategy(buildParam, false);
449
450 withInStrategy->LocateNode(w1, *iterator.get(), visits, targets);
451 ASSERT_EQ(visits.size(), 12);
452 ASSERT_EQ(targets.size(), 0);
453 }
TEST(SelectStrategyTest,withInStrategyForOneAnchorIsInTarget)454 TEST(SelectStrategyTest, withInStrategyForOneAnchorIsInTarget)
455 {
456 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
457 ConstructIterator(iterator);
458 Window w1{12};
459 w1.windowLayer_ = 2;
460 w1.bounds_ = Rect{0, 100, 0, 120};
461 std::vector<Widget> visits2;
462 std::vector<int> targets2;
463 WidgetMatchModel anchor2{UiAttr::TEXT, "Text List12", ValueMatchPattern::EQ};
464 WidgetMatchModel sef2{UiAttr::TEXT, "Text One", ValueMatchPattern::EQ};
465 std::vector<WidgetMatchModel> anchorMatchers;
466 anchorMatchers.emplace_back(anchor2);
467 std::vector<WidgetMatchModel> myselfMatchers;
468 myselfMatchers.emplace_back(sef2);
469 StrategyBuildParam buildParam;
470 buildParam.myselfMatcher = myselfMatchers;
471 buildParam.withInAnchorMatcherVec.emplace_back(anchorMatchers);
472 std::unique_ptr<SelectStrategy> withInStrategy2 = SelectStrategy::BuildSelectStrategy(buildParam, false);
473 withInStrategy2->LocateNode(w1, *iterator.get(), visits2, targets2);
474 ASSERT_EQ(targets2.size(), 1);
475 ASSERT_EQ(visits2[targets2[0]].GetAttr(UiAttr::ACCESSIBILITY_ID), "5");
476 }
TEST(SelectStrategyTest,withInStrategyFoTwoAnchorIsInTarget)477 TEST(SelectStrategyTest, withInStrategyFoTwoAnchorIsInTarget)
478 {
479 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
480 ConstructIterator(iterator);
481 Window w1{12};
482 w1.windowLayer_ = 2;
483 w1.bounds_ = Rect{0, 100, 0, 120};
484 std::vector<Widget> visits3;
485 std::vector<int> targets3;
486 WidgetMatchModel anchor3{UiAttr::TEXT, "Button", ValueMatchPattern::EQ};
487 WidgetMatchModel sef3{UiAttr::TEXT, "Button text2", ValueMatchPattern::EQ};
488 std::vector<WidgetMatchModel> anchorMatchers;
489 anchorMatchers.emplace_back(anchor3);
490 std::vector<WidgetMatchModel> myselfMatchers;
491 myselfMatchers.emplace_back(sef3);
492 StrategyBuildParam buildParam;
493 buildParam.myselfMatcher = myselfMatchers;
494 buildParam.withInAnchorMatcherVec.emplace_back(anchorMatchers);
495 std::unique_ptr<SelectStrategy> withInStrategy3 = SelectStrategy::BuildSelectStrategy(buildParam, false);
496 withInStrategy3->LocateNode(w1, *iterator.get(), visits3, targets3);
497 ASSERT_EQ(targets3.size(), 1);
498 ASSERT_EQ(visits3[targets3[0]].GetAttr(UiAttr::ACCESSIBILITY_ID), "11");
499 }
500
TEST(SelectStrategyTest,withInStrategyFoTwoAnchorIsInMultiTarget)501 TEST(SelectStrategyTest, withInStrategyFoTwoAnchorIsInMultiTarget)
502 {
503 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
504 ConstructIterator(iterator);
505 Window w1{12};
506 w1.windowLayer_ = 2;
507 w1.bounds_ = Rect{0, 100, 0, 120};
508 std::vector<Widget> visits3;
509 std::vector<int> targets3;
510 WidgetMatchModel anchor3{UiAttr::TEXT, "Text List", ValueMatchPattern::EQ};
511 WidgetMatchModel sef3{UiAttr::TEXT, "Button", ValueMatchPattern::EQ};
512 std::vector<WidgetMatchModel> anchorMatchers;
513 anchorMatchers.emplace_back(anchor3);
514 std::vector<WidgetMatchModel> myselfMatchers;
515 myselfMatchers.emplace_back(sef3);
516 StrategyBuildParam buildParam;
517 buildParam.myselfMatcher = myselfMatchers;
518 buildParam.withInAnchorMatcherVec.emplace_back(anchorMatchers);
519 std::unique_ptr<SelectStrategy> withInStrategy3 = SelectStrategy::BuildSelectStrategy(buildParam, true);
520 withInStrategy3->LocateNode(w1, *iterator.get(), visits3, targets3);
521 ASSERT_EQ(targets3.size(), 3);
522 ASSERT_EQ(visits3[targets3[0]].GetAttr(UiAttr::TYPE), "Image");
523 ASSERT_EQ(visits3[targets3[1]].GetAttr(UiAttr::TYPE), "Image");
524 ASSERT_EQ(visits3[targets3[2]].GetAttr(UiAttr::TYPE), "Scroll");
525 }
526
TEST(SelectStrategyTest,plainStrategyForOnlyOneTarget)527 TEST(SelectStrategyTest, plainStrategyForOnlyOneTarget)
528 {
529 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
530 ConstructIterator(iterator);
531 Window w1{12};
532 w1.windowLayer_ = 2;
533 w1.bounds_ = Rect{0, 100, 0, 120};
534 std::vector<Widget> visits;
535 std::vector<int> targets;
536 WidgetMatchModel sef1{UiAttr::TEXT, "Text One", ValueMatchPattern::EQ};
537 std::vector<WidgetMatchModel> myselfMatchers;
538 myselfMatchers.emplace_back(sef1);
539 StrategyBuildParam buildParam;
540 buildParam.myselfMatcher = myselfMatchers;
541 std::unique_ptr<SelectStrategy> plainStrategy = SelectStrategy::BuildSelectStrategy(buildParam, false);
542 plainStrategy->LocateNode(w1, *iterator.get(), visits, targets);
543 ASSERT_EQ(targets.size(), 1);
544 ASSERT_EQ(visits[targets[0]].GetAttr(UiAttr::ACCESSIBILITY_ID), "4");
545 }
TEST(SelectStrategyTest,plainStrategyForMultiTarget)546 TEST(SelectStrategyTest, plainStrategyForMultiTarget)
547 {
548 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
549 ConstructIterator(iterator);
550 Window w1{12};
551 w1.windowLayer_ = 2;
552 w1.bounds_ = Rect{0, 100, 0, 120};
553 std::vector<Widget> visits;
554 std::vector<Widget> visits2;
555 std::vector<int> targets2;
556 WidgetMatchModel sef2{UiAttr::TEXT, "Text One", ValueMatchPattern::EQ};
557 std::vector<WidgetMatchModel> myselfMatchers;
558 myselfMatchers.emplace_back(sef2);
559 StrategyBuildParam buildParam;
560 buildParam.myselfMatcher = myselfMatchers;
561 std::unique_ptr<SelectStrategy> plainStrategy2 = SelectStrategy::BuildSelectStrategy(buildParam, true);
562 plainStrategy2->LocateNode(w1, *iterator.get(), visits2, targets2);
563 ASSERT_EQ(targets2.size(), 2);
564 ASSERT_EQ(visits2[targets2[0]].GetAttr(UiAttr::ACCESSIBILITY_ID), "4");
565 ASSERT_EQ(visits2[targets2[1]].GetAttr(UiAttr::ACCESSIBILITY_ID), "5");
566 }
TEST(SelectStrategyTest,plainStrategyForNoneTarget)567 TEST(SelectStrategyTest, plainStrategyForNoneTarget)
568 {
569 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
570 ConstructIterator(iterator);
571
572 Window w1{12};
573 w1.windowLayer_ = 2;
574 w1.bounds_ = Rect{0, 100, 0, 120};
575 std::vector<Widget> visits3;
576 std::vector<int> targets3;
577 WidgetMatchModel sef3{UiAttr::TEXT, "Button text2112", ValueMatchPattern::EQ};
578 std::vector<WidgetMatchModel> anchorMatchers;
579 std::vector<WidgetMatchModel> myselfMatchers;
580 myselfMatchers.emplace_back(sef3);
581 StrategyBuildParam buildParam;
582 buildParam.myselfMatcher = myselfMatchers;
583 std::unique_ptr<SelectStrategy> plainStrategy3 = SelectStrategy::BuildSelectStrategy(buildParam, false);
584 plainStrategy3->LocateNode(w1, *iterator.get(), visits3, targets3);
585 ASSERT_EQ(visits3.size(), 12);
586 ASSERT_EQ(targets3.size(), 0);
587 }
588
TEST(SelectStrategyTest,complexStrategyForAfterAndBeforeNoneTarget)589 TEST(SelectStrategyTest, complexStrategyForAfterAndBeforeNoneTarget)
590 {
591 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
592 ConstructIterator(iterator);
593
594 Window w1{12};
595 w1.windowLayer_ = 2;
596 w1.bounds_ = Rect{0, 100, 0, 120};
597 std::vector<Widget> visits;
598 std::vector<int> targets;
599 WidgetMatchModel sef{UiAttr::TEXT, "Text End", ValueMatchPattern::EQ};
600 std::vector<WidgetMatchModel> beforeAnchorMatchers;
601 std::vector<WidgetMatchModel> afterAnchorMatchers;
602 std::vector<WidgetMatchModel> myselfMatchers;
603 myselfMatchers.emplace_back(sef);
604 WidgetMatchModel beforeAnchor{UiAttr::ACCESSIBILITY_ID, "11", ValueMatchPattern::EQ};
605 WidgetMatchModel afterAnchor{UiAttr::ACCESSIBILITY_ID, "7", ValueMatchPattern::EQ};
606 beforeAnchorMatchers.emplace_back(beforeAnchor);
607 afterAnchorMatchers.emplace_back(afterAnchor);
608
609 StrategyBuildParam buildParam;
610 buildParam.myselfMatcher = myselfMatchers;
611 buildParam.afterAnchorMatcherVec.emplace_back(afterAnchorMatchers);
612 buildParam.beforeAnchorMatcherVec.emplace_back(beforeAnchorMatchers);
613 std::unique_ptr<SelectStrategy> plainStrategy3 = SelectStrategy::BuildSelectStrategy(buildParam, false);
614 plainStrategy3->LocateNode(w1, *iterator.get(), visits, targets);
615 ASSERT_EQ(targets.size(), 0);
616 }
617
TEST(SelectStrategyTest,complexStrategyForAfterAndBeforeSingleTarget)618 TEST(SelectStrategyTest, complexStrategyForAfterAndBeforeSingleTarget)
619 {
620 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
621 ConstructIterator(iterator);
622
623 Window w1{12};
624 w1.windowLayer_ = 2;
625 w1.bounds_ = Rect{0, 100, 0, 120};
626 std::vector<Widget> visits;
627 std::vector<int> targets;
628 WidgetMatchModel sef{UiAttr::TEXT, "Button", ValueMatchPattern::EQ};
629 std::vector<WidgetMatchModel> beforeAnchorMatchers;
630 std::vector<WidgetMatchModel> afterAnchorMatchers;
631 std::vector<WidgetMatchModel> myselfMatchers;
632 myselfMatchers.emplace_back(sef);
633 WidgetMatchModel afterAnchor{UiAttr::ACCESSIBILITY_ID, "7", ValueMatchPattern::EQ};
634 WidgetMatchModel beforeAnchor{UiAttr::ACCESSIBILITY_ID, "11", ValueMatchPattern::EQ};
635 beforeAnchorMatchers.emplace_back(beforeAnchor);
636 afterAnchorMatchers.emplace_back(afterAnchor);
637
638 StrategyBuildParam buildParam;
639 buildParam.myselfMatcher = myselfMatchers;
640 buildParam.afterAnchorMatcherVec.emplace_back(afterAnchorMatchers);
641 buildParam.beforeAnchorMatcherVec.emplace_back(beforeAnchorMatchers);
642 std::unique_ptr<SelectStrategy> plainStrategy3 = SelectStrategy::BuildSelectStrategy(buildParam, false);
643 plainStrategy3->LocateNode(w1, *iterator.get(), visits, targets);
644 ASSERT_EQ(targets.size(), 1);
645 ASSERT_EQ(visits.at(targets.at(0)).GetAttr(UiAttr::TYPE), "Image");
646 }
647
TEST(SelectStrategyTest,complexStrategyForAfterAndBeforeMultiTarget)648 TEST(SelectStrategyTest, complexStrategyForAfterAndBeforeMultiTarget)
649 {
650 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
651 ConstructIterator(iterator);
652
653 Window w1{12};
654 w1.windowLayer_ = 2;
655 w1.bounds_ = Rect{0, 100, 0, 120};
656 std::vector<Widget> visits;
657 std::vector<int> targets;
658 WidgetMatchModel sef{UiAttr::TEXT, "Button", ValueMatchPattern::EQ};
659 std::vector<WidgetMatchModel> beforeAnchorMatchers;
660 std::vector<WidgetMatchModel> afterAnchorMatchers;
661 std::vector<WidgetMatchModel> myselfMatchers;
662 myselfMatchers.emplace_back(sef);
663 WidgetMatchModel afterAnchor{UiAttr::ACCESSIBILITY_ID, "7", ValueMatchPattern::EQ};
664 WidgetMatchModel beforeAnchor{UiAttr::ACCESSIBILITY_ID, "11", ValueMatchPattern::EQ};
665 beforeAnchorMatchers.emplace_back(beforeAnchor);
666 afterAnchorMatchers.emplace_back(afterAnchor);
667
668 StrategyBuildParam buildParam;
669 buildParam.myselfMatcher = myselfMatchers;
670 buildParam.afterAnchorMatcherVec.emplace_back(afterAnchorMatchers);
671 buildParam.beforeAnchorMatcherVec.emplace_back(beforeAnchorMatchers);
672 std::unique_ptr<SelectStrategy> plainStrategy3 = SelectStrategy::BuildSelectStrategy(buildParam, true);
673 plainStrategy3->LocateNode(w1, *iterator.get(), visits, targets);
674 ASSERT_EQ(targets.size(), 2);
675 ASSERT_EQ(visits.at(targets.at(0)).GetAttr(UiAttr::TYPE), "Image");
676 ASSERT_EQ(visits.at(targets.at(1)).GetAttr(UiAttr::TYPE), "Scroll");
677 }
678
TEST(SelectStrategyTest,complexStrategyForAfterAndWithInNoneTarget)679 TEST(SelectStrategyTest, complexStrategyForAfterAndWithInNoneTarget)
680 {
681 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
682 ConstructIterator(iterator);
683
684 Window w1{12};
685 w1.windowLayer_ = 2;
686 w1.bounds_ = Rect{0, 100, 0, 120};
687 std::vector<Widget> visits;
688 std::vector<int> targets;
689 WidgetMatchModel sef{UiAttr::TEXT, "Text End", ValueMatchPattern::EQ};
690 std::vector<WidgetMatchModel> withInAnchorMatchers;
691 std::vector<WidgetMatchModel> afterAnchorMatchers;
692 std::vector<WidgetMatchModel> myselfMatchers;
693 myselfMatchers.emplace_back(sef);
694 WidgetMatchModel withInAnchor{UiAttr::ACCESSIBILITY_ID, "7", ValueMatchPattern::EQ};
695 WidgetMatchModel afterAnchor{UiAttr::ACCESSIBILITY_ID, "11", ValueMatchPattern::EQ};
696 withInAnchorMatchers.emplace_back(withInAnchor);
697 afterAnchorMatchers.emplace_back(afterAnchor);
698
699 StrategyBuildParam buildParam;
700 buildParam.myselfMatcher = myselfMatchers;
701 buildParam.afterAnchorMatcherVec.emplace_back(afterAnchorMatchers);
702 buildParam.withInAnchorMatcherVec.emplace_back(withInAnchorMatchers);
703 std::unique_ptr<SelectStrategy> plainStrategy3 = SelectStrategy::BuildSelectStrategy(buildParam, false);
704 plainStrategy3->LocateNode(w1, *iterator.get(), visits, targets);
705 ASSERT_EQ(targets.size(), 0);
706 }
707
TEST(SelectStrategyTest,complexStrategyForAfterAndWithInSingleTarget)708 TEST(SelectStrategyTest, complexStrategyForAfterAndWithInSingleTarget)
709 {
710 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
711 ConstructIterator(iterator);
712
713 Window w1{12};
714 w1.windowLayer_ = 2;
715 w1.bounds_ = Rect{0, 100, 0, 120};
716 std::vector<Widget> visits;
717 std::vector<int> targets;
718 WidgetMatchModel sef{UiAttr::TYPE, "Text", ValueMatchPattern::EQ};
719 std::vector<WidgetMatchModel> withInAnchorMatchers;
720 std::vector<WidgetMatchModel> afterAnchorMatchers;
721 std::vector<WidgetMatchModel> myselfMatchers;
722 myselfMatchers.emplace_back(sef);
723 WidgetMatchModel withInAnchor{UiAttr::ACCESSIBILITY_ID, "7", ValueMatchPattern::EQ};
724 WidgetMatchModel afterAnchor{UiAttr::ACCESSIBILITY_ID, "5", ValueMatchPattern::EQ};
725 withInAnchorMatchers.emplace_back(withInAnchor);
726 afterAnchorMatchers.emplace_back(afterAnchor);
727
728 StrategyBuildParam buildParam;
729 buildParam.myselfMatcher = myselfMatchers;
730 buildParam.afterAnchorMatcherVec.emplace_back(afterAnchorMatchers);
731 buildParam.withInAnchorMatcherVec.emplace_back(withInAnchorMatchers);
732 std::unique_ptr<SelectStrategy> plainStrategy3 = SelectStrategy::BuildSelectStrategy(buildParam, false);
733 plainStrategy3->LocateNode(w1, *iterator.get(), visits, targets);
734 ASSERT_EQ(targets.size(), 1);
735 ASSERT_EQ(visits.at(targets.at(0)).GetAttr(UiAttr::ACCESSIBILITY_ID), "4");
736 }
737
TEST(SelectStrategyTest,complexStrategyForAfterAndWithInMultiTarget)738 TEST(SelectStrategyTest, complexStrategyForAfterAndWithInMultiTarget)
739 {
740 std::unique_ptr<ElementNodeIterator> iterator = nullptr;
741 ConstructIterator(iterator);
742
743 Window w1{12};
744 w1.windowLayer_ = 2;
745 w1.bounds_ = Rect{0, 100, 0, 120};
746 std::vector<Widget> visits;
747 std::vector<int> targets;
748 WidgetMatchModel sef{UiAttr::TYPE, "Text", ValueMatchPattern::EQ};
749 std::vector<WidgetMatchModel> withInAnchorMatchers;
750 std::vector<WidgetMatchModel> afterAnchorMatchers;
751 std::vector<WidgetMatchModel> myselfMatchers;
752 myselfMatchers.emplace_back(sef);
753 WidgetMatchModel withInAnchor{UiAttr::ACCESSIBILITY_ID, "7", ValueMatchPattern::EQ};
754 WidgetMatchModel afterAnchor{UiAttr::TEXT, "Text One", ValueMatchPattern::EQ};
755 withInAnchorMatchers.emplace_back(withInAnchor);
756 afterAnchorMatchers.emplace_back(afterAnchor);
757
758 StrategyBuildParam buildParam;
759 buildParam.myselfMatcher = myselfMatchers;
760 buildParam.afterAnchorMatcherVec.emplace_back(afterAnchorMatchers);
761 buildParam.withInAnchorMatcherVec.emplace_back(withInAnchorMatchers);
762 std::unique_ptr<SelectStrategy> complexStrategy = SelectStrategy::BuildSelectStrategy(buildParam, true);
763 complexStrategy->LocateNode(w1, *iterator.get(), visits, targets);
764 ASSERT_EQ(targets.size(), 2);
765 ASSERT_EQ(visits.at(targets.at(0)).GetAttr(UiAttr::ACCESSIBILITY_ID), "5");
766 ASSERT_EQ(visits.at(targets.at(1)).GetAttr(UiAttr::ACCESSIBILITY_ID), "4");
767 }
768