1 /*
2 * Copyright (c) 2022-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 <cstddef>
17 #include <cstdint>
18 #include <unistd.h>
19
20 #include "gtest/gtest.h"
21
22 #define private public
23 #define protected public
24 #include "test/mock/core/pipeline/mock_pipeline_context.h"
25
26 #include "core/components_ng/base/frame_node.h"
27 #include "core/components_ng/event/event_hub.h"
28 #include "core/components_ng/event/response_ctrl.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS::Ace::NG {
34 class ResponseCtrlTestNg : public testing::Test {
35 public:
36 static void SetUpTestSuite();
37 static void TearDownTestSuite();
38 };
39
SetUpTestSuite()40 void ResponseCtrlTestNg::SetUpTestSuite()
41 {
42 MockPipelineContext::SetUp();
43 GTEST_LOG_(INFO) << "ResponseCtrlTestNg SetUpTestCase";
44 }
45
TearDownTestSuite()46 void ResponseCtrlTestNg::TearDownTestSuite()
47 {
48 MockPipelineContext::TearDown();
49 GTEST_LOG_(INFO) << "ResponseCtrlTestNg TearDownTestCase";
50 }
51
52 /**
53 * @tc.name: ResponseCtrlTest001
54 * @tc.desc: Response ctrl test first valid node call shouldResponse
55 * @tc.type: FUNC
56 */
57 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest001, TestSize.Level1)
58 {
59 /**
60 * @tc.steps: step1. create ResponseCtrl.
61 */
62 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
63
64 /**
65 * @tc.steps: step2. create frame nodes.
66 */
67 auto node = FrameNode::CreateFrameNode(
68 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
69
70 /**
71 * @tc.steps: step3. Check ShouldResponse.
72 * @tc.expected: first node should return true.
73 */
74 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node));
75 EXPECT_EQ(shouldResponse, true);
76 }
77
78 /**
79 * @tc.name: ResponseCtrlTest002
80 * @tc.desc: Response ctrl test first invalid node call shouldResponse
81 * @tc.type: FUNC
82 */
83 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest002, TestSize.Level1)
84 {
85 /**
86 * @tc.steps: step1. create ResponseCtrl.
87 */
88 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
89
90 /**
91 * @tc.steps: step2. create empty node
92 */
93 RefPtr<FrameNode> emptyNode;
94
95 /**
96 * @tc.steps: step3. check ShouldResponse.
97 * @tc.expected: invalid node should return true.
98 */
99 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(emptyNode));
100 EXPECT_EQ(shouldResponse, true);
101 }
102
103 /**
104 * @tc.name: ResponseCtrlTest003
105 * @tc.desc: Response ctrl monopolize test
106 * @tc.type: FUNC
107 */
108 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest003, TestSize.Level1)
109 {
110 /**
111 * @tc.steps: step1. create ResponseCtrl.
112 */
113 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
114
115 /**
116 * @tc.steps: step2. create frame nodes.
117 */
118 auto node1 = FrameNode::CreateFrameNode(
119 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
120
121 auto node2 = FrameNode::CreateFrameNode(
122 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
123
124 /**
125 * @tc.steps: step3. first node Check ShouldResponse.
126 * @tc.expected: first node should return true.
127 */
128 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node1));
129 EXPECT_EQ(shouldResponse, true);
130
131 /**
132 * @tc.steps: step4. first node Check ShouldResponse.
133 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::OFF.
134 */
135 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node1));
136 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::OFF);
137 /**
138 * @tc.steps: step5. second node Check ShouldResponse.
139 * @tc.expected: second node should return true.
140 */
141 shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node2));
142 EXPECT_EQ(shouldResponse, true);
143 }
144
145 /**
146 * @tc.name: ResponseCtrlTest004
147 * @tc.desc: Response ctrl monopolize test
148 * @tc.type: FUNC
149 */
150 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest004, TestSize.Level1)
151 {
152 /**
153 * @tc.steps: step1. create ResponseCtrl.
154 */
155 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
156
157 /**
158 * @tc.steps: step2. create frame nodes.
159 */
160 auto node1 = FrameNode::CreateFrameNode(
161 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
162
163 auto node2 = FrameNode::CreateFrameNode(
164 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
165
166 /**
167 * @tc.steps: step3. set node1 monopolizeEvents.
168 * @tc.expected: gestureEventHub is not nullptr.
169 */
170 auto gestureEventHub = node1->GetOrCreateGestureEventHub();
171 EXPECT_NE(gestureEventHub, nullptr);
172 gestureEventHub->monopolizeEvents_ = true;
173
174 /**
175 * @tc.steps: step4. first node Check ShouldResponse.
176 * @tc.expected: first node should return true.
177 */
178 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node1));
179 EXPECT_EQ(shouldResponse, true);
180
181 /**
182 * @tc.steps: step5. first node SetFirstResponse.
183 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::ON.
184 */
185 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node1));
186 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::ON);
187 /**
188 * @tc.steps: step6. second node Check ShouldResponse.
189 * @tc.expected: second node should return false.
190 */
191 shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node2));
192 EXPECT_EQ(shouldResponse, false);
193 }
194
195 /**
196 * @tc.name: ResponseCtrlTest005
197 * @tc.desc: Response ctrl monopolize test
198 * @tc.type: FUNC
199 */
200 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest005, TestSize.Level1)
201 {
202 /**
203 * @tc.steps: step1. create ResponseCtrl.
204 */
205 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
206
207 /**
208 * @tc.steps: step2. create frame node.
209 */
210 auto node1 = FrameNode::CreateFrameNode(
211 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
212
213 /**
214 * @tc.steps: step3. set node1 monopolizeEvents.
215 * @tc.expected: gestureEventHub is not nullptr.
216 */
217 auto gestureEventHub = node1->GetOrCreateGestureEventHub();
218 EXPECT_NE(gestureEventHub, nullptr);
219 gestureEventHub->monopolizeEvents_ = true;
220
221 /**
222 * @tc.steps: step4. first node Check ShouldResponse.
223 * @tc.expected: first node should return true.
224 */
225 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node1));
226 EXPECT_EQ(shouldResponse, true);
227
228 /**
229 * @tc.steps: step5. first node SetFirstResponse.
230 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::ON.
231 */
232 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node1));
233 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::ON);
234 /**
235 * @tc.steps: step6. Check ShouldResponse twice.
236 * @tc.expected: twice check should return true.
237 */
238 shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node1));
239 EXPECT_EQ(shouldResponse, true);
240 }
241
242 /**
243 * @tc.name: ResponseCtrlTest006
244 * @tc.desc: Response ctrl monopolize test
245 * @tc.type: FUNC
246 */
247 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest006, TestSize.Level1)
248 {
249 /**
250 * @tc.steps: step1. create ResponseCtrl.
251 */
252 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
253
254 /**
255 * @tc.steps: step2. create frame nodes.
256 */
257 RefPtr<FrameNode> node1;
258
259 auto node2 = FrameNode::CreateFrameNode(
260 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
261
262 /**
263 * @tc.steps: step3. first node SetFirstResponse.
264 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::INIT.
265 */
266 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node1));
267 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::INIT);
268 /**
269 * @tc.steps: step4. Check ShouldResponse by node2.
270 * @tc.expected: should return true.
271 */
272 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node2));
273 EXPECT_EQ(shouldResponse, true);
274 }
275
276 /**
277 * @tc.name: ResponseCtrlTest007
278 * @tc.desc: Response ctrl monopolize test
279 * @tc.type: FUNC
280 */
281 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest007, TestSize.Level1)
282 {
283 /**
284 * @tc.steps: step1. create ResponseCtrl.
285 */
286 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
287
288 RefPtr<FrameNode> node1;
289 /**
290 * @tc.steps: step2. create frame nodes.
291 */
292 auto node2 = FrameNode::CreateFrameNode(
293 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
294
295 /**
296 * @tc.steps: step3. first node SetFirstResponse.
297 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::INIT.
298 */
299 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node1));
300 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::INIT);
301 /**
302 * @tc.steps: step4. Check ShouldResponse.
303 * @tc.expected: should return true.
304 */
305 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node2));
306 EXPECT_EQ(shouldResponse, true);
307
308 /**
309 * @tc.steps: step5. node2 SetFirstResponse.
310 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::OFF.
311 */
312 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node2));
313 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::OFF);
314 }
315
316 /**
317 * @tc.name: ResponseCtrlTest008
318 * @tc.desc: Response ctrl monopolize test
319 * @tc.type: FUNC
320 */
321 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest008, TestSize.Level1)
322 {
323 /**
324 * @tc.steps: step1. create ResponseCtrl.
325 */
326 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
327
328 /**
329 * @tc.steps: step2. create empty frame node.
330 */
331 RefPtr<FrameNode> node1;
332
333 /**
334 * @tc.steps: step3. create frame nodes.
335 */
336 auto node2 = FrameNode::CreateFrameNode(
337 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
338
339 auto node3 = FrameNode::CreateFrameNode(
340 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
341
342 /**
343 * @tc.steps: step4. first node SetFirstResponse.
344 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::INIT.
345 */
346 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node1));
347 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::INIT);
348 /**
349 * @tc.steps: step5. node2 check ShouldResponse.
350 * @tc.expected: should return true.
351 */
352 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node2));
353 EXPECT_EQ(shouldResponse, true);
354
355 /**
356 * @tc.steps: step6. node2 SetFirstResponse.
357 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::OFF.
358 */
359 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node2));
360 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::OFF);
361
362 /**
363 * @tc.steps: step7. node3 ShouldResponse.
364 * @tc.expected: should return true.
365 */
366 shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node3));
367 EXPECT_EQ(shouldResponse, true);
368 }
369
370 /**
371 * @tc.name: ResponseCtrlTest009
372 * @tc.desc: Response ctrl monopolize test
373 * @tc.type: FUNC
374 */
375 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest009, TestSize.Level1)
376 {
377 /**
378 * @tc.steps: step1. create ResponseCtrl.
379 */
380 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
381
382 /**
383 * @tc.steps: step2. create frame nodes.
384 * @tc.expected: frame node is not nullptr.
385 */
386 auto node1 = FrameNode::CreateFrameNode(
387 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
388
389 auto node2 = FrameNode::CreateFrameNode(
390 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
391
392 /**
393 * @tc.steps: step3. get gesture event hub and set node1 monopolizeEvents true.
394 * @tc.expected: gestureEventHub not nullptr
395 */
396 auto gestureEventHub = node1->GetOrCreateGestureEventHub();
397 EXPECT_NE(gestureEventHub, nullptr);
398 gestureEventHub->monopolizeEvents_ = true;
399
400 /**
401 * @tc.steps: step4. first node Check ShouldResponse.
402 * @tc.expected: first node should return true.
403 */
404 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node1));
405 EXPECT_EQ(shouldResponse, true);
406
407 /**
408 * @tc.steps: step5. first node SetFirstResponse.
409 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::ON.
410 */
411 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node1));
412 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::ON);
413 /**
414 * @tc.steps: step6. second node check ShouldResponse.
415 * @tc.expected: second node should return false.
416 */
417 shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node2));
418 EXPECT_EQ(shouldResponse, false);
419
420 /**
421 * @tc.steps: step7. response ctrl reset.
422 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::INIT.
423 */
424 responseCtrl->Reset();
425 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::INIT);
426
427 /**
428 * @tc.steps: step8. create new frame node.
429 * @tc.expected: frame node is not nullptr.
430 */
431 auto node3 = FrameNode::CreateFrameNode(
432 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
433
434 /**
435 * @tc.steps: step9. node3 Check ShouldResponse.
436 * @tc.expected: should return true.
437 */
438 shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node3));
439 EXPECT_EQ(shouldResponse, true);
440 }
441
442 /**
443 * @tc.name: ResponseCtrlTest010
444 * @tc.desc: Response ctrl monopolize test
445 * @tc.type: FUNC
446 */
447 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest010, TestSize.Level1)
448 {
449 /**
450 * @tc.steps: step1. create ResponseCtrl.
451 */
452 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
453
454 /**
455 * @tc.steps: step2. create frame nodes.
456 */
457 auto node1 = FrameNode::CreateFrameNode(
458 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
459
460 auto node2 = FrameNode::CreateFrameNode(
461 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
462
463 /**
464 * @tc.steps: step3. get gesture event hub and set node1 monopolizeEvents false.
465 * @tc.expected: gestureEventHub is not nullptr
466 */
467 auto gestureEventHub = node1->GetOrCreateGestureEventHub();
468 EXPECT_NE(gestureEventHub, nullptr);
469 gestureEventHub->monopolizeEvents_ = false;
470
471 /**
472 * @tc.steps: step4. first node Check ShouldResponse.
473 * @tc.expected: first node should return true.
474 */
475 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node1));
476 EXPECT_EQ(shouldResponse, true);
477
478 /**
479 * @tc.steps: step5. first node SetFirstResponse.
480 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::OFF.
481 */
482 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node1));
483 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::OFF);
484 /**
485 * @tc.steps: step6. second node Check ShouldResponse.
486 * @tc.expected: second node should return true.
487 */
488 shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node2));
489 EXPECT_EQ(shouldResponse, true);
490
491 /**
492 * @tc.steps: step7. response ctrl reset.
493 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::INIT.
494 */
495 responseCtrl->Reset();
496 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::INIT);
497
498 /**
499 * @tc.steps: step8. create new frame node.
500 */
501 auto node3 = FrameNode::CreateFrameNode(
502 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
503
504 /**
505 * @tc.steps: step9. node3 check ShouldResponse.
506 * @tc.expected: should return true.
507 */
508 shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node3));
509 EXPECT_EQ(shouldResponse, true);
510 }
511
512 /**
513 * @tc.name: ResponseCtrlTest011
514 * @tc.desc: Response ctrl monopolize test
515 * @tc.type: FUNC
516 */
517 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest011, TestSize.Level1)
518 {
519 /**
520 * @tc.steps: step1. create ResponseCtrl.
521 */
522 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
523
524 /**
525 * @tc.steps: step2. create frame node.
526 */
527 auto node1 = FrameNode::CreateFrameNode(
528 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
529
530 /**
531 * @tc.steps: step3. create empty frame node.
532 */
533 RefPtr<FrameNode> node2;
534
535 /**
536 * @tc.steps: step4. get gesture event hub and set node1 monopolizeEvents false.
537 * @tc.expected: gestureEventHub not nullptr
538 */
539 auto gestureEventHub = node1->GetOrCreateGestureEventHub();
540 EXPECT_NE(gestureEventHub, nullptr);
541 gestureEventHub->monopolizeEvents_ = false;
542
543 /**
544 * @tc.steps: step5. first node Check ShouldResponse.
545 * @tc.expected: first node should return true.
546 */
547 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node1));
548 EXPECT_EQ(shouldResponse, true);
549
550 /**
551 * @tc.steps: step6. first node SetFirstResponse.
552 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::OFF.
553 */
554 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node1));
555 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::OFF);
556 /**
557 * @tc.steps: step7. second node Check ShouldResponse.
558 * @tc.expected: second node should return true.
559 */
560 shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node2));
561 EXPECT_EQ(shouldResponse, true);
562 }
563
564 /**
565 * @tc.name: ResponseCtrlTest012
566 * @tc.desc: Response ctrl monopolize test
567 * @tc.type: FUNC
568 */
569 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest012, TestSize.Level1)
570 {
571 /**
572 * @tc.steps: step1. create ResponseCtrl.
573 */
574 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
575
576 /**
577 * @tc.steps: step2. create frame node.
578 */
579 auto node1 = FrameNode::CreateFrameNode(
580 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
581
582 /**
583 * @tc.steps: step3. get gesture event hub and set node1 monopolizeEvents false.
584 * @tc.expected: gestureEventHub not nullptr
585 */
586 auto gestureEventHub = node1->GetOrCreateGestureEventHub();
587 EXPECT_NE(gestureEventHub, nullptr);
588 gestureEventHub->monopolizeEvents_ = true;
589
590 /**
591 * @tc.steps: step4. first node Check ShouldResponse.
592 * @tc.expected: first node should return true.
593 */
594 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node1));
595 EXPECT_EQ(shouldResponse, true);
596
597 /**
598 * @tc.steps: step5. first node SetFirstResponse.
599 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::ON.
600 */
601 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node1));
602 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::ON);
603 /**
604 * @tc.steps: step6. reset response controller.
605 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::INIT.
606 */
607 responseCtrl->Reset();
608 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::INIT);
609 }
610
611 /**
612 * @tc.name: ResponseCtrlTest013
613 * @tc.desc: Response ctrl monopolize test
614 * @tc.type: FUNC
615 */
616 HWTEST_F(ResponseCtrlTestNg, ResponseCtrlTest013, TestSize.Level1)
617 {
618 /**
619 * @tc.steps: step1. create ResponseCtrl.
620 */
621 auto responseCtrl = AceType::MakeRefPtr<ResponseCtrl>();
622
623 /**
624 * @tc.steps: step2. create frame node.
625 */
626 auto node1 = FrameNode::CreateFrameNode(
627 V2::STAGE_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
628
629 /**
630 * @tc.steps: step3. get gesture event hub and set node1 monopolizeEvents false.
631 * @tc.expected: gestureEventHub not nullptr
632 */
633 auto gestureEventHub = node1->GetOrCreateGestureEventHub();
634 EXPECT_NE(gestureEventHub, nullptr);
635 gestureEventHub->monopolizeEvents_ = false;
636
637 /**
638 * @tc.steps: step4. first node Check ShouldResponse.
639 * @tc.expected: first node should return true.
640 */
641 bool shouldResponse = responseCtrl->ShouldResponse(WeakPtr<FrameNode>(node1));
642 EXPECT_EQ(shouldResponse, true);
643
644 /**
645 * @tc.steps: step5. first node SetFirstResponse.
646 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::OFF.
647 */
648 responseCtrl->TrySetFirstResponse(WeakPtr<FrameNode>(node1));
649 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::OFF);
650 /**
651 * @tc.steps: step6. reset response controller.
652 * @tc.expected: state equal to ResponseCtrl::MonopolizeState::INIT.
653 */
654 responseCtrl->Reset();
655 EXPECT_EQ(responseCtrl->state_, ResponseCtrl::MonopolizeState::INIT);
656 }
657 } // namespace OHOS::Ace::NG
658