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_ = {};
__anone8ad3c600202(const PointF& point) 284 std::function<bool(const PointF&)> checkTouchInArea = [](const PointF& point) { return false; };
__anone8ad3c600302() 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_ = {};
__anone8ad3c600402(const PointF& point) 324 std::function<bool(const PointF&)> checkTouchInArea = [](const PointF& point) { return true; };
__anone8ad3c600502() 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_ = {};
__anone8ad3c600602(const PointF& point) 378 std::function<bool(const PointF&)> checkTouchInArea = [](const PointF& point) { return false; };
__anone8ad3c600702() 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: IsTouchInNormalSelectOverlayArea001
635 * @tc.desc: test select_content_overlay_manager.cpp IsTouchInNormalSelectOverlayArea
636 * @tc.type: FUNC
637 */
638 HWTEST_F(SelectOverlayManagerTestTwoNg, IsTouchInNormalSelectOverlayArea001, TestSize.Level1)
639 {
640 /**
641 * @tc.steps: step1. init SelectContentOverlayManager
642 */
643 Init();
644 auto content = SelectContentOverlayManager(root_);
645 SelectOverlayInfo selectInfo;
646 selectInfo.enableHandleLevel = false;
647 selectInfo.menuInfo.showCut = true;
648 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
649 ASSERT_NE(content.shareOverlayInfo_, nullptr);
650
651 /**
652 * @tc.steps: step2. CreateSelectOverlayNode
653 */
654 auto frameNode = SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_);
655 ASSERT_NE(frameNode, nullptr);
656 content.selectOverlayNode_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
657 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
658
659 /**
660 * @tc.steps: step3. call IsTouchInNormalSelectOverlayArea
661 */
662 content.IsTouchInNormalSelectOverlayArea(PointF(0.0, 0.0));
663 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
664 }
665
666 /**
667 * @tc.name: IsTouchInNormalSelectOverlayArea002
668 * @tc.desc: test select_content_overlay_manager.cpp IsTouchInNormalSelectOverlayArea
669 * @tc.type: FUNC
670 */
671 HWTEST_F(SelectOverlayManagerTestTwoNg, IsTouchInNormalSelectOverlayArea002, TestSize.Level1)
672 {
673 /**
674 * @tc.steps: step1. init SelectContentOverlayManager
675 */
676 Init();
677 auto content = SelectContentOverlayManager(root_);
678 SelectOverlayInfo selectInfo;
679 selectInfo.isUsingMouse = true;
680 selectInfo.enableHandleLevel = false;
681 selectInfo.menuInfo.showCut = true;
682 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
683 ASSERT_NE(content.shareOverlayInfo_, nullptr);
684
685 /**
686 * @tc.steps: step2. CreateSelectOverlayNode
687 */
688 auto wrapperNode_ = FrameNode::CreateFrameNode(V2::MENU_WRAPPER_ETS_TAG,
689 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<MenuWrapperPattern>(1));
690 ASSERT_NE(wrapperNode_, nullptr);
691 content.selectOverlayNode_ = AceType::WeakClaim(AceType::RawPtr(wrapperNode_));
692 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
693
694 /**
695 * @tc.steps: step3. call IsTouchInNormalSelectOverlayArea
696 */
697 content.IsTouchInNormalSelectOverlayArea(PointF(0.0, 0.0));
698 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
699 }
700
701 /**
702 * @tc.name: GetHandleOverlayNode001
703 * @tc.desc: test select_content_overlay_manager.cpp GetHandleOverlayNode
704 * @tc.type: FUNC
705 */
706 HWTEST_F(SelectOverlayManagerTestTwoNg, GetHandleOverlayNode001, TestSize.Level1)
707 {
708 /**
709 * @tc.steps: step1. init SelectContentOverlayManager
710 */
711 Init();
712 auto content = SelectContentOverlayManager(root_);
713 SelectOverlayInfo selectInfo;
714 selectInfo.enableHandleLevel = true;
715 selectInfo.menuInfo.showCut = true;
716
717 /**
718 * @tc.steps: step2. CreateSelectOverlayNode
719 */
720 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
721 ASSERT_NE(content.shareOverlayInfo_, nullptr);
722 auto handleNode =
723 SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_, SelectOverlayMode::HANDLE_ONLY);
724 ASSERT_NE(handleNode, nullptr);
725 content.handleNode_ = AceType::WeakClaim(AceType::RawPtr(handleNode));
726 ASSERT_NE(content.handleNode_.Upgrade(), nullptr);
727
728 /**
729 * @tc.steps: step3. call GetHandleOverlayNode
730 */
731 auto weakHandleNode = content.GetHandleOverlayNode();
732 ASSERT_NE(weakHandleNode, nullptr);
733 }
734
735 /**
736 * @tc.name: MarkHandleDirtyNode001
737 * @tc.desc: test select_content_overlay_manager.cpp MarkHandleDirtyNode
738 * @tc.type: FUNC
739 */
740 HWTEST_F(SelectOverlayManagerTestTwoNg, MarkHandleDirtyNode001, TestSize.Level1)
741 {
742 /**
743 * @tc.steps: step1. init SelectContentOverlayManager
744 */
745 Init();
746 auto content = SelectContentOverlayManager(root_);
747 SelectOverlayInfo selectInfo;
748 selectInfo.enableHandleLevel = true;
749 selectInfo.menuInfo.showCut = true;
750 selectInfo.isUseOverlayNG = true;
751
752 /**
753 * @tc.steps: step2. CreateSelectOverlayNode
754 */
755 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
756 ASSERT_NE(content.shareOverlayInfo_, nullptr);
757 auto handleNode =
758 SelectOverlayNode::CreateSelectOverlayNode(content.shareOverlayInfo_, SelectOverlayMode::HANDLE_ONLY);
759 ASSERT_NE(handleNode, nullptr);
760 content.handleNode_ = AceType::WeakClaim(AceType::RawPtr(handleNode));
761 ASSERT_NE(content.handleNode_.Upgrade(), nullptr);
762
763 /**
764 * @tc.steps: step3. call MarkHandleDirtyNode
765 */
766 content.MarkHandleDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
767 ASSERT_NE(content.handleNode_.Upgrade(), nullptr);
768 }
769
770 /**
771 * @tc.name: UpdateRightClickSubWindowMenuProps001
772 * @tc.desc: test select_content_overlay_manager.cpp UpdateRightClickSubWindowMenuProps
773 * @tc.type: FUNC
774 */
775 HWTEST_F(SelectOverlayManagerTestTwoNg, UpdateRightClickSubWindowMenuProps001, TestSize.Level1)
776 {
777 /**
778 * @tc.steps: step1. init SelectContentOverlayManager
779 */
780 Init();
781 auto content = SelectContentOverlayManager(root_);
782 SelectOverlayInfo selectInfo;
783 selectInfo.isUsingMouse = true;
784 selectInfo.enableHandleLevel = false;
785 selectInfo.menuInfo.showCut = true;
786 content.shareOverlayInfo_ = std::make_shared<SelectOverlayInfo>(selectInfo);
787 ASSERT_NE(content.shareOverlayInfo_, nullptr);
788
789 /**
790 * @tc.steps: step2. CreateSelectOverlayNode
791 */
792 auto wrapperNode_ = FrameNode::CreateFrameNode(V2::MENU_WRAPPER_ETS_TAG,
793 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<MenuWrapperPattern>(1));
794 ASSERT_NE(wrapperNode_, nullptr);
795 content.selectOverlayNode_ = AceType::WeakClaim(AceType::RawPtr(wrapperNode_));
796 auto selectoverlayNode = content.selectOverlayNode_.Upgrade();
797 ASSERT_NE(selectoverlayNode, nullptr);
798
799 /**
800 * @tc.steps: step3. call UpdateRightClickSubWindowMenuProps
801 */
802 content.UpdateRightClickSubWindowMenuProps(selectoverlayNode);
803 ASSERT_NE(content.selectOverlayNode_.Upgrade(), nullptr);
804 }
805 } // namespace OHOS::Ace::NG