1 /*
2 * Copyright (c) 2022 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 <memory>
17 #include <optional>
18
19 #include "gtest/gtest.h"
20 #define private public
21 #define protected public
22
23 #include "test/mock/base/mock_task_executor.h"
24 #include "test/mock/core/common/mock_container.h"
25 #include "test/mock/core/pipeline/mock_pipeline_context.h"
26
27 #include "base/geometry/ng/offset_t.h"
28 #include "base/geometry/ng/size_t.h"
29 #include "base/memory/ace_type.h"
30 #include "base/memory/referenced.h"
31 #include "core/components_ng/base/frame_node.h"
32 #include "core/components_ng/base/geometry_node.h"
33 #include "core/components_ng/manager/select_content_overlay/select_overlay_callback.h"
34 #include "core/components_ng/manager/select_content_overlay/select_overlay_holder.h"
35 #include "core/components_ng/manager/select_overlay/select_overlay_manager.h"
36 #include "core/components_ng/pattern/pattern.h"
37 #include "core/components_ng/pattern/select_overlay/select_overlay_pattern.h"
38 #include "core/components_ng/pattern/select_overlay/select_overlay_property.h"
39 #include "core/components_ng/pattern/text/text_base.h"
40 #include "core/components_ng/pattern/text/text_pattern.h"
41 #include "core/components_ng/pattern/text_field/text_field_pattern.h"
42 #include "core/components_ng/property/property.h"
43
44 using namespace testing;
45 using namespace testing::ext;
46
47 namespace OHOS::Ace::NG {
48 namespace {
49 const std::string ROOT_TAG("root");
50 constexpr int32_t NODE_ID = 143;
51 const OffsetF RIGHT_CLICK_OFFSET = OffsetF(10.0f, 10.0f);
52 const OffsetF ROOT_OFFSET = OffsetF(10.0f, 10.0f);
53 } // namespace
54
55 class SelectOverlayManagerTestTwoNg : public testing::Test {
56 public:
57 static void SetUpTestSuite();
58 static void TearDownTestSuite();
59 RefPtr<SelectOverlayManager> selectOverlayManager_;
60 RefPtr<SelectOverlayProxy> proxy_;
61 RefPtr<FrameNode> root_;
62 void Init();
63 };
64
65 class MockSelectOverlayHolder : public SelectOverlayHolder, public SelectOverlayCallback {
66 DECLARE_ACE_TYPE(MockSelectOverlayHolder, SelectOverlayHolder, SelectOverlayCallback);
67
68 public:
69 MockSelectOverlayHolder() = default;
70 ~MockSelectOverlayHolder() = default;
71
SetOwner(const RefPtr<FrameNode> & node)72 void SetOwner(const RefPtr<FrameNode>& node)
73 {
74 node_ = node;
75 }
76
GetOwner()77 RefPtr<FrameNode> GetOwner()
78 {
79 return node_;
80 }
81
GetCallback()82 RefPtr<SelectOverlayCallback> GetCallback() override
83 {
84 return Claim(this);
85 }
86
OnUpdateSelectOverlayInfo(SelectOverlayInfo & overlayInfo,int32_t requestCode)87 void OnUpdateSelectOverlayInfo(SelectOverlayInfo& overlayInfo, int32_t requestCode)
88 {
89 overlayInfo.enableHandleLevel = true;
90 overlayInfo.handleLevelMode = handleLevelMode_;
91 overlayInfo.menuInfo.menuIsShow = true;
92 }
93
OnHandleLevelModeChanged(HandleLevelMode mode)94 void OnHandleLevelModeChanged(HandleLevelMode mode) override
95 {
96 handleLevelMode_ = mode;
97 }
98
CheckSwitchToMode(HandleLevelMode mode)99 bool CheckSwitchToMode(HandleLevelMode mode) override
100 {
101 return allowSwitchMode_;
102 }
103
CheckTouchInHostNode(const PointF & touchPoint)104 bool CheckTouchInHostNode(const PointF& touchPoint)
105 {
106 return false;
107 }
108
109 private:
110 HandleLevelMode handleLevelMode_ = HandleLevelMode::OVERLAY;
111 bool allowSwitchMode_ = false;
112 RefPtr<FrameNode> node_;
113 };
114
SetUpTestSuite()115 void SelectOverlayManagerTestTwoNg::SetUpTestSuite()
116 {
117 MockPipelineContext::SetUp();
118 MockContainer::SetUp();
119 MockContainer::Current()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
120 }
121
TearDownTestSuite()122 void SelectOverlayManagerTestTwoNg::TearDownTestSuite()
123 {
124 MockPipelineContext::TearDown();
125 MockContainer::TearDown();
126 }
127
Init()128 void SelectOverlayManagerTestTwoNg::Init()
129 {
130 SelectOverlayInfo selectOverlayInfo;
131 selectOverlayInfo.singleLineHeight = NODE_ID;
132 root_ = AceType::MakeRefPtr<FrameNode>(ROOT_TAG, -1, AceType::MakeRefPtr<Pattern>(), true);
133 selectOverlayManager_ = AceType::MakeRefPtr<SelectOverlayManager>(root_);
134 ASSERT_NE(selectOverlayManager_, nullptr);
135 proxy_ = selectOverlayManager_->CreateAndShowSelectOverlay(selectOverlayInfo, nullptr);
136 ASSERT_NE(proxy_, nullptr);
137 }
138
139 /**
140 * @tc.name: RemoveHoldSelectionCallback
141 * @tc.desc: test select_content_overlay_manager.cpp RemoveHoldSelectionCallback
142 * @tc.type: FUNC
143 */
144 HWTEST_F(SelectOverlayManagerTestTwoNg, RemoveHoldSelectionCallback001, TestSize.Level1)
145 {
146 Init();
147 auto content = SelectContentOverlayManager(root_);
148 int32_t id = 1;
149 auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
150 HoldSelectionInfo holdSelectionInfo_;
151 holdSelectionInfo_ = {};
152 content.SetHolder(holder);
153 content.SetHoldSelectionCallback(id, holdSelectionInfo_);
154 EXPECT_EQ(content.selectionHoldId_, 1);
155 content.RemoveHoldSelectionCallback(id);
156 EXPECT_EQ(content.selectionHoldId_, -1);
157 }
158
159 /**
160 * @tc.name: RemoveHoldSelectionCallback
161 * @tc.desc: test select_content_overlay_manager.cpp RemoveHoldSelectionCallback
162 * @tc.type: FUNC
163 */
164 HWTEST_F(SelectOverlayManagerTestTwoNg, RemoveHoldSelectionCallback002, TestSize.Level1)
165 {
166 Init();
167 auto content = SelectContentOverlayManager(root_);
168 int32_t id = 1;
169 auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
170 HoldSelectionInfo holdSelectionInfo_;
171 holdSelectionInfo_ = {};
172 content.SetHolder(holder);
173 content.SetHoldSelectionCallback(id, holdSelectionInfo_);
174 content.RemoveHoldSelectionCallback(5);
175 EXPECT_EQ(content.selectionHoldId_, 1);
176 }
177
178 /**
179 * @tc.name: RevertRectRelativeToRoot
180 * @tc.desc: test select_content_overlay_manager.cpp RevertRectRelativeToRoot
181 * @tc.type: FUNC
182 */
183 HWTEST_F(SelectOverlayManagerTestTwoNg, RevertRectRelativeToRoot001, TestSize.Level1)
184 {
185 Init();
186 auto content = SelectContentOverlayManager(root_);
187 int32_t id = 1;
188 auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
189 HoldSelectionInfo holdSelectionInfo_;
190 holdSelectionInfo_ = {};
191 content.SetHolder(holder);
192 content.SetHoldSelectionCallback(id, holdSelectionInfo_);
193 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>();
194 content.shareOverlayInfo_->handleLevelMode = HandleLevelMode::EMBED;
195 RectF rect(1.0f, 20.0f, 100.0f, 150.0f);
196 auto rectCopy = rect.GetOffset();
197 content.RevertRectRelativeToRoot(rect);
198 EXPECT_EQ(rectCopy, rect.GetOffset());
199 }
200
201 /**
202 * @tc.name: DestroySelectOverlayNodeWithAnimation001
203 * @tc.desc: test select_content_overlay_manager.cpp DestroySelectOverlayNodeWithAnimation
204 * @tc.type: FUNC
205 */
206 HWTEST_F(SelectOverlayManagerTestTwoNg, DestroySelectOverlayNodeWithAnimation001, TestSize.Level1)
207 {
208 /**
209 * @tc.steps: step1. init SelectContentOverlayManager
210 */
211 Init();
212 auto content = SelectContentOverlayManager(root_);
213 SelectOverlayInfo selectInfo;
214 selectInfo.enableHandleLevel = true;
215 selectInfo.menuInfo.showCut = true;
216
217 /**
218 * @tc.steps: step2. CreateSelectOverlayNode
219 */
220 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
221 ASSERT_NE(content.shareOverlayInfo_, nullptr);
222 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
223 ASSERT_NE(frameNode, nullptr);
224
225 /**
226 * @tc.steps: step3. call DestroySelectOverlayNodeWithAnimation
227 */
228 content.DestroySelectOverlayNodeWithAnimation(frameNode);
229 content.ClearAllStatus();
230 EXPECT_EQ(content.selectionHoldId_, -1);
231 }
232
233 /**
234 * @tc.name: ResetSelectionRect001
235 * @tc.desc: test select_content_overlay_manager.cpp ResetSelectionRect
236 * @tc.type: FUNC
237 */
238 HWTEST_F(SelectOverlayManagerTestTwoNg, ResetSelectionRect001, TestSize.Level1)
239 {
240 /**
241 * @tc.steps: step1. init SelectContentOverlayManager
242 */
243 Init();
244 auto content = SelectContentOverlayManager(root_);
245
246 /**
247 * @tc.steps: step2. SetHoldSelectionCallback
248 */
249 int32_t id = 1;
250 auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
251 HoldSelectionInfo holdSelectionInfo_;
252 holdSelectionInfo_ = {};
253 content.SetHolder(holder);
254 content.SetHoldSelectionCallback(id, holdSelectionInfo_);
255 EXPECT_EQ(content.selectionHoldId_, 1);
256
257 /**
258 * @tc.steps: step3. call ResetSelectionRect
259 */
260 content.ResetSelectionRect();
261 EXPECT_EQ(content.selectionHoldId_, -1);
262 }
263
264 /**
265 * @tc.name: HandleSelectionEvent001
266 * @tc.desc: test select_content_overlay_manager.cpp HandleSelectionEvent
267 * @tc.type: FUNC
268 */
269 HWTEST_F(SelectOverlayManagerTestTwoNg, HandleSelectionEvent001, TestSize.Level1)
270 {
271 /**
272 * @tc.steps: step1. init SelectContentOverlayManager
273 */
274 Init();
275 auto content = SelectContentOverlayManager(root_);
276
277 /**
278 * @tc.steps: step2. SetHoldSelectionCallback
279 */
280 int32_t id = 1;
281 auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
282 HoldSelectionInfo holdSelectionInfo_;
283 holdSelectionInfo_ = {};
__anon926c14420202(const PointF& point, bool) 284 std::function<bool(const PointF&, bool)> checkTouchInArea = [](const PointF& point, bool) { return false; };
__anon926c14420302() 285 std::function<void()> resetSelectionCallback = []() {};
286 holdSelectionInfo_.checkTouchInArea = std::move(checkTouchInArea);
287 holdSelectionInfo_.resetSelectionCallback = std::move(resetSelectionCallback);
288
289 content.SetHolder(holder);
290 content.SetHoldSelectionCallback(id, holdSelectionInfo_);
291 EXPECT_EQ(content.selectionHoldId_, 1);
292
293 /**
294 * @tc.steps: step3. call HandleSelectionEvent
295 */
296 PointF point = PointF(0.0, 0.0);
297 TouchEvent rawTouchEvent;
298 rawTouchEvent.sourceType = SourceType::MOUSE;
299 rawTouchEvent.type = TouchType::DOWN;
300 content.HandleSelectionEvent(point, rawTouchEvent);
301 EXPECT_EQ(content.selectionHoldId_, -1);
302 }
303
304 /**
305 * @tc.name: HandleSelectionEvent002
306 * @tc.desc: test select_content_overlay_manager.cpp HandleSelectionEvent
307 * @tc.type: FUNC
308 */
309 HWTEST_F(SelectOverlayManagerTestTwoNg, HandleSelectionEvent002, TestSize.Level1)
310 {
311 /**
312 * @tc.steps: step1. init SelectContentOverlayManager
313 */
314 Init();
315 auto content = SelectContentOverlayManager(root_);
316
317 /**
318 * @tc.steps: step2. SetHoldSelectionCallback
319 */
320 int32_t id = 1;
321 auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
322 HoldSelectionInfo holdSelectionInfo_;
323 holdSelectionInfo_ = {};
__anon926c14420402(const PointF& point, bool) 324 std::function<bool(const PointF&, bool)> checkTouchInArea = [](const PointF& point, bool) { return true; };
__anon926c14420502() 325 std::function<void()> resetSelectionCallback = []() {};
326 holdSelectionInfo_.checkTouchInArea = std::move(checkTouchInArea);
327 holdSelectionInfo_.resetSelectionCallback = std::move(resetSelectionCallback);
328
329 content.SetHolder(holder);
330 content.SetHoldSelectionCallback(id, holdSelectionInfo_);
331 EXPECT_EQ(content.selectionHoldId_, 1);
332
333 /**
334 * @tc.steps: step3. call HandleSelectionEvent
335 */
336 PointF point = PointF(0.0, 0.0);
337 TouchEvent rawTouchEvent;
338 rawTouchEvent.sourceType = SourceType::MOUSE;
339 rawTouchEvent.type = TouchType::DOWN;
340 content.HandleSelectionEvent(point, rawTouchEvent);
341 EXPECT_EQ(content.selectionHoldId_, 1);
342 }
343
344 /**
345 * @tc.name: HandleSelectionEvent003
346 * @tc.desc: test select_content_overlay_manager.cpp HandleSelectionEvent
347 * @tc.type: FUNC
348 */
349 HWTEST_F(SelectOverlayManagerTestTwoNg, HandleSelectionEvent003, TestSize.Level1)
350 {
351 /**
352 * @tc.steps: step1. init SelectContentOverlayManager
353 */
354 Init();
355 auto content = SelectContentOverlayManager(root_);
356 SelectOverlayInfo selectInfo;
357 selectInfo.enableHandleLevel = true;
358 selectInfo.menuInfo.showCut = true;
359 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
360 ASSERT_NE(content.shareOverlayInfo_, nullptr);
361 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
362 ASSERT_NE(frameNode, nullptr);
363 content.menuNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
364 ASSERT_NE(content.menuNode_.Upgrade(), nullptr);
365
366 /**
367 * @tc.steps: step2. mount menuNode to root node
368 */
369 frameNode->SetParent(root_);
370
371 /**
372 * @tc.steps: step3. SetHoldSelectionCallback
373 */
374 int32_t id = 1;
375 auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
376 HoldSelectionInfo holdSelectionInfo_;
377 holdSelectionInfo_ = {};
__anon926c14420602(const PointF& point, bool) 378 std::function<bool(const PointF&, bool)> checkTouchInArea = [](const PointF& point, bool) { return false; };
__anon926c14420702() 379 std::function<void()> resetSelectionCallback = []() {};
380 holdSelectionInfo_.checkTouchInArea = std::move(checkTouchInArea);
381 holdSelectionInfo_.resetSelectionCallback = std::move(resetSelectionCallback);
382
383 content.SetHolder(holder);
384 content.SetHoldSelectionCallback(id, holdSelectionInfo_);
385 EXPECT_EQ(content.selectionHoldId_, 1);
386
387 /**
388 * @tc.steps: step4. call HandleSelectionEvent
389 */
390 PointF point = PointF(0.0, 0.0);
391 TouchEvent rawTouchEvent;
392 rawTouchEvent.sourceType = SourceType::MOUSE;
393 rawTouchEvent.type = TouchType::DOWN;
394 content.HandleSelectionEvent(point, rawTouchEvent);
395 EXPECT_EQ(content.selectionHoldId_, 1);
396 }
397
398 /**
399 * @tc.name: IsTouchInHandleLevelOverlayArea001
400 * @tc.desc: test select_content_overlay_manager.cpp IsTouchInHandleLevelOverlayArea
401 * @tc.type: FUNC
402 */
403 HWTEST_F(SelectOverlayManagerTestTwoNg, IsTouchInHandleLevelOverlayArea001, TestSize.Level1)
404 {
405 /**
406 * @tc.steps: step1. init SelectContentOverlayManager
407 */
408 Init();
409 auto content = SelectContentOverlayManager(root_);
410 SelectOverlayInfo selectInfo;
411 selectInfo.enableHandleLevel = true;
412 selectInfo.menuInfo.showCut = true;
413
414 /**
415 * @tc.steps: step2. CreateSelectOverlayNode
416 */
417 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
418 ASSERT_NE(content.shareOverlayInfo_, nullptr);
419 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
420 ASSERT_NE(frameNode, nullptr);
421 content.menuNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
422 ASSERT_NE(content.menuNode_.Upgrade(), nullptr);
423
424 /**
425 * @tc.steps: step3. call IsTouchInHandleLevelOverlayArea
426 */
427 content.IsTouchInHandleLevelOverlayArea(PointF(0.0, 0.0));
428 ASSERT_NE(content.menuNode_.Upgrade(), nullptr);
429 }
430
431 /**
432 * @tc.name: IsTouchInHandleLevelOverlayArea002
433 * @tc.desc: test select_content_overlay_manager.cpp IsTouchInHandleLevelOverlayArea
434 * @tc.type: FUNC
435 */
436 HWTEST_F(SelectOverlayManagerTestTwoNg, IsTouchInHandleLevelOverlayArea002, TestSize.Level1)
437 {
438 /**
439 * @tc.steps: step1. init SelectContentOverlayManager
440 */
441 Init();
442 auto content = SelectContentOverlayManager(root_);
443 SelectOverlayInfo selectInfo;
444 selectInfo.enableHandleLevel = true;
445 selectInfo.menuInfo.showCut = true;
446
447 /**
448 * @tc.steps: step2. CreateSelectOverlayNode
449 */
450 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
451 ASSERT_NE(content.shareOverlayInfo_, nullptr);
452 auto handleNode =
453 SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_, SelectOverlayMode::HANDLE_ONLY);
454 ASSERT_NE(handleNode, nullptr);
455 content.handleNode_ = AceType::WeakClaim(AceType::RawPtr(handleNode));
456 ASSERT_NE(content.handleNode_.Upgrade(), nullptr);
457
458 /**
459 * @tc.steps: step3. call IsTouchInHandleLevelOverlayArea
460 */
461 content.IsTouchInHandleLevelOverlayArea(PointF(0.0, 0.0));
462 ASSERT_NE(content.handleNode_.Upgrade(), nullptr);
463 }
464
465 /**
466 * @tc.name: MarkSelectOverlayDirty001
467 * @tc.desc: test select_content_overlay_manager.cpp MarkSelectOverlayDirty
468 * @tc.type: FUNC
469 */
470 HWTEST_F(SelectOverlayManagerTestTwoNg, MarkSelectOverlayDirty001, TestSize.Level1)
471 {
472 /**
473 * @tc.steps: step1. init SelectContentOverlayManager
474 */
475 Init();
476 auto content = SelectContentOverlayManager(root_);
477 SelectOverlayInfo selectInfo;
478 selectInfo.enableHandleLevel = false;
479 selectInfo.menuInfo.showCut = true;
480 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
481 ASSERT_NE(content.shareOverlayInfo_, nullptr);
482 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
483 ASSERT_NE(frameNode, nullptr);
484 content.selectOverlayNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
485 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
486
487 /**
488 * @tc.steps: step2. mount menuNode to root node
489 */
490 frameNode->SetParent(root_);
491
492 /**
493 * @tc.steps: step3. call MarkSelectOverlayDirty
494 */
495 content.MarkSelectOverlayDirty(PROPERTY_UPDATE_MEASURE_SELF);
496 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
497 }
498
499 /**
500 * @tc.name: MarkSelectOverlayDirty002
501 * @tc.desc: test select_content_overlay_manager.cpp MarkSelectOverlayDirty
502 * @tc.type: FUNC
503 */
504 HWTEST_F(SelectOverlayManagerTestTwoNg, MarkSelectOverlayDirty002, TestSize.Level1)
505 {
506 /**
507 * @tc.steps: step1. init SelectContentOverlayManager
508 */
509 Init();
510 auto content = SelectContentOverlayManager(root_);
511 SelectOverlayInfo selectInfo;
512 selectInfo.enableHandleLevel = false;
513 selectInfo.menuInfo.showCut = true;
514 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
515 ASSERT_NE(content.shareOverlayInfo_, nullptr);
516 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
517 ASSERT_NE(frameNode, nullptr);
518 content.selectOverlayNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
519 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
520
521 /**
522 * @tc.steps: step2. call MarkSelectOverlayDirty
523 */
524 content.MarkSelectOverlayDirty(PROPERTY_UPDATE_MEASURE_SELF);
525 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
526 }
527
528 /**
529 * @tc.name: CloseWithOverlayId001
530 * @tc.desc: test select_content_overlay_manager.cpp CloseWithOverlayId
531 * @tc.type: FUNC
532 */
533 HWTEST_F(SelectOverlayManagerTestTwoNg, CloseWithOverlayId001, TestSize.Level1)
534 {
535 /**
536 * @tc.steps: step1. init SelectContentOverlayManager
537 */
538 Init();
539 auto content = SelectContentOverlayManager(root_);
540 auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
541 content.SetHolder(holder);
542 SelectOverlayInfo selectInfo;
543 selectInfo.enableHandleLevel = false;
544 selectInfo.menuInfo.showCut = true;
545 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
546 ASSERT_NE(content.shareOverlayInfo_, nullptr);
547 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
548 ASSERT_NE(frameNode, nullptr);
549 content.selectOverlayNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
550 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
551
552 /**
553 * @tc.steps: step2. mount menuNode to root node
554 */
555 frameNode->SetParent(root_);
556
557 /**
558 * @tc.steps: step3. call CloseWithOverlayId
559 */
560 content.CloseWithOverlayId(frameNode->GetId(), CloseReason::CLOSE_REASON_NORMAL, true);
561 EXPECT_EQ(content.selectionHoldId_, -1);
562 }
563
564 /**
565 * @tc.name: CloseWithOverlayId002
566 * @tc.desc: test select_content_overlay_manager.cpp CloseWithOverlayId
567 * @tc.type: FUNC
568 */
569 HWTEST_F(SelectOverlayManagerTestTwoNg, CloseWithOverlayId002, TestSize.Level1)
570 {
571 /**
572 * @tc.steps: step1. init SelectContentOverlayManager
573 */
574 Init();
575 auto content = SelectContentOverlayManager(root_);
576 auto holder = AceType::MakeRefPtr<SelectOverlayHolder>();
577 content.SetHolder(holder);
578 SelectOverlayInfo selectInfo;
579 selectInfo.enableHandleLevel = true;
580 selectInfo.menuInfo.showCut = true;
581 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
582 ASSERT_NE(content.shareOverlayInfo_, nullptr);
583 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
584 ASSERT_NE(frameNode, nullptr);
585 content.menuNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
586 ASSERT_NE(content.menuNode_.Upgrade(), nullptr);
587
588 /**
589 * @tc.steps: step2. mount menuNode to root node
590 */
591 frameNode->SetParent(root_);
592
593 /**
594 * @tc.steps: step3. call CloseWithOverlayId
595 */
596 content.CloseWithOverlayId(frameNode->GetId(), CloseReason::CLOSE_REASON_NORMAL, true);
597 EXPECT_EQ(content.selectionHoldId_, -1);
598 }
599
600 /**
601 * @tc.name: ConvertPointRelativeToNode001
602 * @tc.desc: test select_content_overlay_manager.cpp ConvertPointRelativeToNode
603 * @tc.type: FUNC
604 */
605 HWTEST_F(SelectOverlayManagerTestTwoNg, ConvertPointRelativeToNode001, TestSize.Level1)
606 {
607 /**
608 * @tc.steps: step1. init SelectContentOverlayManager
609 */
610 Init();
611 auto content = SelectContentOverlayManager(root_);
612 SelectOverlayInfo selectInfo;
613 selectInfo.enableHandleLevel = true;
614 selectInfo.menuInfo.showCut = true;
615 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
616 ASSERT_NE(content.shareOverlayInfo_, nullptr);
617 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
618 ASSERT_NE(frameNode, nullptr);
619
620 /**
621 * @tc.steps: step2. mount menuNode to root node
622 */
623 frameNode->SetParent(root_);
624
625 /**
626 * @tc.steps: step3. call ConvertPointRelativeToNode
627 */
628 PointF point = PointF(0.0, 0.0);
629 content.ConvertPointRelativeToNode(frameNode, point);
630 EXPECT_EQ(content.selectionHoldId_, -1);
631 }
632
633 /**
634 * @tc.name: ConvertPointRelativeToNode002
635 * @tc.desc: test select_content_overlay_manager.cpp ConvertPointRelativeToNode
636 * @tc.type: FUNC
637 */
638 HWTEST_F(SelectOverlayManagerTestTwoNg, ConvertPointRelativeToNode002, TestSize.Level1)
639 {
640 /**
641 * @tc.steps: step1. init SelectContentOverlayManager
642 */
643 Init();
644 auto content = SelectContentOverlayManager(root_);
645 SelectOverlayInfo selectInfo;
646 selectInfo.enableHandleLevel = true;
647 selectInfo.menuInfo.showCut = true;
648 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
649 ASSERT_NE(content.shareOverlayInfo_, nullptr);
650 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
651 ASSERT_NE(frameNode, nullptr);
652
653 /**
654 * @tc.steps: step2. mount menuNode to root node
655 */
656 frameNode->SetParent(root_);
657
658 /**
659 * @tc.steps: step3. call ConvertPointRelativeToNode
660 */
661 PointF point = PointF(0.0, 0.0);
662 auto pipeline = PipelineContext::GetCurrentContextSafelyWithCheck();
663 ASSERT_NE(pipeline, nullptr);
664 pipeline->postEventManager_ = AceType::MakeRefPtr<PostEventManager>();
665 pipeline->postEventManager_->targetNode_ = root_;
666 content.ConvertPointRelativeToNode(frameNode, point);
667 EXPECT_EQ(content.selectionHoldId_, -1);
668 }
669
670 /**
671 * @tc.name: ConvertPointRelativeToNode003
672 * @tc.desc: test select_content_overlay_manager.cpp ConvertPointRelativeToNode
673 * @tc.type: FUNC
674 */
675 HWTEST_F(SelectOverlayManagerTestTwoNg, ConvertPointRelativeToNode003, TestSize.Level1)
676 {
677 /**
678 * @tc.steps: step1. init SelectContentOverlayManager
679 */
680 Init();
681 auto content = SelectContentOverlayManager(root_);
682 SelectOverlayInfo selectInfo;
683 selectInfo.enableHandleLevel = true;
684 selectInfo.menuInfo.showCut = true;
685 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
686 ASSERT_NE(content.shareOverlayInfo_, nullptr);
687 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
688 ASSERT_NE(frameNode, nullptr);
689
690 /**
691 * @tc.steps: step2. mount menuNode to root node
692 */
693 frameNode->SetParent(root_);
694
695 /**
696 * @tc.steps: step3. call ConvertPointRelativeToNode
697 */
698 PointF point = PointF(0.0, 0.0);
699 auto pipeline = PipelineContext::GetCurrentContextSafelyWithCheck();
700 pipeline = nullptr;
701 content.ConvertPointRelativeToNode(frameNode, point);
702 EXPECT_EQ(content.selectionHoldId_, -1);
703 }
704
705 /**
706 * @tc.name: ConvertPointRelativeToNode004
707 * @tc.desc: test select_content_overlay_manager.cpp ConvertPointRelativeToNode
708 * @tc.type: FUNC
709 */
710 HWTEST_F(SelectOverlayManagerTestTwoNg, ConvertPointRelativeToNode004, TestSize.Level1)
711 {
712 /**
713 * @tc.steps: step1. init SelectContentOverlayManager
714 */
715 Init();
716 auto content = SelectContentOverlayManager(root_);
717 SelectOverlayInfo selectInfo;
718 selectInfo.enableHandleLevel = true;
719 selectInfo.menuInfo.showCut = true;
720 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
721 ASSERT_NE(content.shareOverlayInfo_, nullptr);
722 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
723 ASSERT_NE(frameNode, nullptr);
724
725 /**
726 * @tc.steps: step2. mount menuNode to root node
727 */
728 frameNode->SetParent(root_);
729
730 /**
731 * @tc.steps: step3. call ConvertPointRelativeToNode
732 */
733 PointF point = PointF(0.0, 0.0);
734 auto pipeline = PipelineContext::GetCurrentContextSafelyWithCheck();
735 ASSERT_NE(pipeline, nullptr);
736 pipeline->postEventManager_ = AceType::MakeRefPtr<PostEventManager>();
737 pipeline->postEventManager_->targetNode_ = nullptr;
738 content.ConvertPointRelativeToNode(frameNode, point);
739 EXPECT_EQ(content.selectionHoldId_, -1);
740 }
741
742 /**
743 * @tc.name: IsTouchInNormalSelectOverlayArea001
744 * @tc.desc: test select_content_overlay_manager.cpp IsTouchInNormalSelectOverlayArea
745 * @tc.type: FUNC
746 */
747 HWTEST_F(SelectOverlayManagerTestTwoNg, IsTouchInNormalSelectOverlayArea001, TestSize.Level1)
748 {
749 /**
750 * @tc.steps: step1. init SelectContentOverlayManager
751 */
752 Init();
753 auto content = SelectContentOverlayManager(root_);
754 SelectOverlayInfo selectInfo;
755 selectInfo.enableHandleLevel = false;
756 selectInfo.menuInfo.showCut = true;
757 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
758 ASSERT_NE(content.shareOverlayInfo_, nullptr);
759
760 /**
761 * @tc.steps: step2. CreateSelectOverlayNode
762 */
763 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
764 ASSERT_NE(frameNode, nullptr);
765 content.selectOverlayNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
766 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
767
768 /**
769 * @tc.steps: step3. call IsTouchInNormalSelectOverlayArea
770 */
771 content.IsTouchInNormalSelectOverlayArea(PointF(0.0, 0.0));
772 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
773 }
774
775 /**
776 * @tc.name: IsTouchInNormalSelectOverlayArea002
777 * @tc.desc: test select_content_overlay_manager.cpp IsTouchInNormalSelectOverlayArea
778 * @tc.type: FUNC
779 */
780 HWTEST_F(SelectOverlayManagerTestTwoNg, IsTouchInNormalSelectOverlayArea002, TestSize.Level1)
781 {
782 /**
783 * @tc.steps: step1. init SelectContentOverlayManager
784 */
785 Init();
786 auto content = SelectContentOverlayManager(root_);
787 SelectOverlayInfo selectInfo;
788 selectInfo.isUsingMouse = true;
789 selectInfo.enableHandleLevel = false;
790 selectInfo.menuInfo.showCut = true;
791 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
792 ASSERT_NE(content.shareOverlayInfo_, nullptr);
793
794 /**
795 * @tc.steps: step2. CreateSelectOverlayNode
796 */
797 auto wrapperNode_ = FrameNode::CreateFrameNode(V2::MENU_WRAPPER_ETS_TAG,
798 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<MenuWrapperPattern>(1));
799 ASSERT_NE(wrapperNode_, nullptr);
800 content.selectOverlayNode_ = AceType::WeakClaim(AceType::RawPtr(wrapperNode_));
801 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
802
803 /**
804 * @tc.steps: step3. call IsTouchInNormalSelectOverlayArea
805 */
806 content.IsTouchInNormalSelectOverlayArea(PointF(0.0, 0.0));
807 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
808 }
809
810 /**
811 * @tc.name: GetHandleOverlayNode001
812 * @tc.desc: test select_content_overlay_manager.cpp GetHandleOverlayNode
813 * @tc.type: FUNC
814 */
815 HWTEST_F(SelectOverlayManagerTestTwoNg, GetHandleOverlayNode001, TestSize.Level1)
816 {
817 /**
818 * @tc.steps: step1. init SelectContentOverlayManager
819 */
820 Init();
821 auto content = SelectContentOverlayManager(root_);
822 SelectOverlayInfo selectInfo;
823 selectInfo.enableHandleLevel = true;
824 selectInfo.menuInfo.showCut = true;
825
826 /**
827 * @tc.steps: step2. CreateSelectOverlayNode
828 */
829 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
830 ASSERT_NE(content.shareOverlayInfo_, nullptr);
831 auto handleNode =
832 SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_, SelectOverlayMode::HANDLE_ONLY);
833 ASSERT_NE(handleNode, nullptr);
834 content.handleNode_ = AceType::WeakClaim(AceType::RawPtr(handleNode));
835 ASSERT_NE(content.handleNode_.Upgrade(), nullptr);
836
837 /**
838 * @tc.steps: step3. call GetHandleOverlayNode
839 */
840 auto weakHandleNode = content.GetHandleOverlayNode();
841 ASSERT_NE(weakHandleNode, nullptr);
842 }
843
844 /**
845 * @tc.name: MarkHandleDirtyNode001
846 * @tc.desc: test select_content_overlay_manager.cpp MarkHandleDirtyNode
847 * @tc.type: FUNC
848 */
849 HWTEST_F(SelectOverlayManagerTestTwoNg, MarkHandleDirtyNode001, TestSize.Level1)
850 {
851 /**
852 * @tc.steps: step1. init SelectContentOverlayManager
853 */
854 Init();
855 auto content = SelectContentOverlayManager(root_);
856 SelectOverlayInfo selectInfo;
857 selectInfo.enableHandleLevel = true;
858 selectInfo.menuInfo.showCut = true;
859 selectInfo.isUseOverlayNG = true;
860
861 /**
862 * @tc.steps: step2. CreateSelectOverlayNode
863 */
864 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
865 ASSERT_NE(content.shareOverlayInfo_, nullptr);
866 auto handleNode =
867 SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_, SelectOverlayMode::HANDLE_ONLY);
868 ASSERT_NE(handleNode, nullptr);
869 content.handleNode_ = AceType::WeakClaim(AceType::RawPtr(handleNode));
870 ASSERT_NE(content.handleNode_.Upgrade(), nullptr);
871
872 /**
873 * @tc.steps: step3. call MarkHandleDirtyNode
874 */
875 content.MarkHandleDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
876 ASSERT_NE(content.handleNode_.Upgrade(), nullptr);
877 }
878
879 /**
880 * @tc.name: UpdateRightClickSubWindowMenuProps001
881 * @tc.desc: test select_content_overlay_manager.cpp UpdateRightClickSubWindowMenuProps
882 * @tc.type: FUNC
883 */
884 HWTEST_F(SelectOverlayManagerTestTwoNg, UpdateRightClickSubWindowMenuProps001, TestSize.Level1)
885 {
886 /**
887 * @tc.steps: step1. init SelectContentOverlayManager
888 */
889 Init();
890 auto content = SelectContentOverlayManager(root_);
891 SelectOverlayInfo selectInfo;
892 selectInfo.isUsingMouse = true;
893 selectInfo.enableHandleLevel = false;
894 selectInfo.menuInfo.showCut = true;
895 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
896 ASSERT_NE(content.shareOverlayInfo_, nullptr);
897
898 /**
899 * @tc.steps: step2. CreateSelectOverlayNode
900 */
901 auto wrapperNode_ = FrameNode::CreateFrameNode(V2::MENU_WRAPPER_ETS_TAG,
902 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<MenuWrapperPattern>(1));
903 ASSERT_NE(wrapperNode_, nullptr);
904 content.selectOverlayNode_ = AceType::WeakClaim(AceType::RawPtr(wrapperNode_));
905 auto selectoverlayNode = content.selectOverlayNode_.Upgrade();
906 ASSERT_NE(selectoverlayNode, nullptr);
907
908 /**
909 * @tc.steps: step3. call UpdateRightClickSubWindowMenuProps
910 */
911 content.UpdateRightClickSubWindowMenuProps(selectoverlayNode);
912 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
913 }
914
915 /**
916 * @tc.name: FocusFirstFocusableChildInMenu001
917 * @tc.desc: test select_content_overlay_manager.cpp FocusFirstFocusableChildInMenu
918 * @tc.type: FUNC
919 */
920 HWTEST_F(SelectOverlayManagerTestTwoNg, FocusFirstFocusableChildInMenu001, TestSize.Level1)
921 {
922 /**
923 * @tc.steps: step1. init SelectContentOverlayManager
924 */
925 Init();
926 auto content = SelectContentOverlayManager(root_);
927 SelectOverlayInfo selectInfo;
928 selectInfo.enableHandleLevel = true;
929 selectInfo.menuInfo.showCut = true;
930
931 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
932 ASSERT_NE(content.shareOverlayInfo_, nullptr);
933 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
934 ASSERT_NE(frameNode, nullptr);
935 content.menuNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
936 ASSERT_NE(content.menuNode_.Upgrade(), nullptr);
937 content.FocusFirstFocusableChildInMenu();
938 EXPECT_TRUE(frameNode->GetContext()->taskScheduler_->afterLayoutCallbacksInImplicitAnimationTask_.empty());
939 EXPECT_TRUE(frameNode->GetContext()->taskScheduler_->afterLayoutTasks_.empty());
940 }
941
942 /**
943 * @tc.name: DestroySelectOverlayNode
944 * @tc.desc: test select_content_overlay_manager.cpp DestroySelectOverlayNode
945 * @tc.type: FUNC
946 */
947 HWTEST_F(SelectOverlayManagerTestTwoNg, DestroySelectOverlayNode, TestSize.Level1)
948 {
949 /**
950 * @tc.steps: step1. init SelectContentOverlayManager
951 */
952 Init();
953 auto content = SelectContentOverlayManager(root_);
954 SelectOverlayInfo selectInfo;
955 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
956 ASSERT_NE(content.shareOverlayInfo_, nullptr);
957
958 /**
959 * @tc.steps: step2. CreateSelectOverlayNode
960 */
961 auto menuNode =
962 SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_, SelectOverlayMode::MENU_ONLY);
963 ASSERT_NE(menuNode, nullptr);
964 menuNode->MountToParent(root_);
965 /**
966 * @tc.steps: step3. call DestroySelectOverlayNode
967 */
968 content.DestroySelectOverlayNode(menuNode);
969 EXPECT_FALSE(menuNode->IsInDestroying());
970 }
971
972 /**
973 * @tc.name: DestroySelectOverlayNode001
974 * @tc.desc: test select_content_overlay_manager.cpp DestroySelectOverlayNode
975 * @tc.type: FUNC
976 */
977 HWTEST_F(SelectOverlayManagerTestTwoNg, DestroySelectOverlayNode001, TestSize.Level1)
978 {
979 /**
980 * @tc.steps: step1. init SelectContentOverlayManager
981 */
982 Init();
983 auto content = SelectContentOverlayManager(root_);
984 SelectOverlayInfo selectInfo;
985 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
986 ASSERT_NE(content.shareOverlayInfo_, nullptr);
987
988 /**
989 * @tc.steps: step2. CreateSelectOverlayNode
990 */
991 auto menuNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_, SelectOverlayMode::MENU_ONLY);
992 ASSERT_NE(menuNode, nullptr);
993 menuNode->MountToParent(root_);
994 auto selectOverlayPattern = menuNode->GetPattern<SelectOverlayPattern>();
995 ASSERT_NE(selectOverlayPattern, nullptr);
996 selectOverlayPattern->SetIsMenuShowInSubWindow(true);
997
998 /**
999 * @tc.steps: step3. call DestroySelectOverlayNode
1000 */
1001 content.DestroySelectOverlayNode(menuNode);
1002 EXPECT_FALSE(menuNode->IsInDestroying());
1003 }
1004
1005 /**
1006 * @tc.name: DestroySelectOverlayNode002
1007 * @tc.desc: test select_content_overlay_manager.cpp DestroySelectOverlayNode
1008 * @tc.type: FUNC
1009 */
1010 HWTEST_F(SelectOverlayManagerTestTwoNg, DestroySelectOverlayNode002, TestSize.Level1)
1011 {
1012 /**
1013 * @tc.steps: step1. init SelectContentOverlayManager
1014 */
1015 Init();
1016 auto content = SelectContentOverlayManager(root_);
1017 SelectOverlayInfo selectInfo;
1018 selectInfo.enableHandleLevel = false;
1019 selectInfo.isUsingMouse = true;
1020 selectInfo.isUseOverlayNG = true;
1021
1022 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
1023 ASSERT_NE(content.shareOverlayInfo_, nullptr);
1024
1025 /**
1026 * @tc.steps: step2. CreateSelectOverlayNode
1027 */
1028 auto menuNode = FrameNode::CreateFrameNode(V2::MENU_WRAPPER_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
1029 AceType::MakeRefPtr<MenuWrapperPattern>(1));
1030 ASSERT_NE(menuNode, nullptr);
1031 menuNode->MountToParent(root_);
1032 auto menuWrapperPattern = menuNode->GetPattern<MenuWrapperPattern>();
1033 ASSERT_NE(menuWrapperPattern, nullptr);
1034 menuWrapperPattern->SetIsSelectOverlaySubWindowWrapper(true);
1035
1036 /**
1037 * @tc.steps: step3. call DestroySelectOverlayNode
1038 */
1039 content.DestroySelectOverlayNode(menuNode);
1040 EXPECT_TRUE(content.shareOverlayInfo_->isUsingMouse);
1041 }
1042
1043 /**
1044 * @tc.name: CreateSelectOverlayNode001
1045 * @tc.desc: test SelectOverlayNode.cpp CreateSelectOverlayNode
1046 * @tc.type: FUNC
1047 */
1048 HWTEST_F(SelectOverlayManagerTestTwoNg, CreateSelectOverlayNode001, TestSize.Level1)
1049 {
1050 /**
1051 * @tc.steps: step1. init SelectContentOverlayManager
1052 */
1053 Init();
1054 auto content = SelectContentOverlayManager(root_);
1055 SelectOverlayInfo selectInfo;
1056 selectInfo.enableHandleLevel = true;
1057 selectInfo.menuInfo.showCut = true;
1058 selectInfo.menuInfo.showCopyAll = true;
1059 selectInfo.menuInfo.showAIWrite = true;
1060
1061 /**
1062 * @tc.steps: step2. CreateSelectOverlayNode
1063 */
1064 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
1065 ASSERT_NE(content.shareOverlayInfo_, nullptr);
1066 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
1067 ASSERT_NE(frameNode, nullptr);
1068 auto size = frameNode->GetChildren().size();
1069 EXPECT_EQ(size, 1);
1070 }
1071 } // namespace OHOS::Ace::NG