1 /*
2 * Copyright (c) 2024 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 #include "drag_manager_test.h"
16
17 #define BUFF_SIZE 100
18 #include <future>
19 #ifndef OHOS_BUILD_ENABLE_ARKUI_X
20 #include "parameters.h"
21 #endif // OHOS_BUILD_ENABLE_ARKUI_X
22 #include "pointer_event.h"
23 #include "securec.h"
24 #include "message_parcel.h"
25
26 #include "devicestatus_define.h"
27 #include "devicestatus_errors.h"
28 #include "interaction_manager.h"
29 #include "stationary_data.h"
30
31 namespace OHOS {
32 namespace Msdp {
33 namespace DeviceStatus {
34 using namespace testing::ext;
35 namespace {
36 #ifdef OHOS_BUILD_INTERNAL_DROP_ANIMATION
37 constexpr int32_t TIME_WAIT_FOR_INTERNAL_DROP_ANIMATION { 500 };
38 #endif // OHOS_BUILD_INTERNAL_DROP_ANIMATION
39 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
40 constexpr uint32_t DEFAULT_ICON_COLOR { 0xFF };
41 constexpr int32_t PIXEL_MAP_HEIGHT { 3 };
42 constexpr int32_t PIXEL_MAP_WIDTH { 3 };
43 constexpr int32_t MAX_PIXEL_MAP_WIDTH { 600 };
44 constexpr int32_t MAX_PIXEL_MAP_HEIGHT { 600 };
45 constexpr int32_t POINTER_ID { 0 };
46 constexpr int32_t DISPLAY_X { 50 };
47 constexpr int32_t DISPLAY_ID { 0 };
48 constexpr int32_t DISPLAY_Y { 50 };
49 constexpr int32_t DRAG_NUM_ONE { 1 };
50 constexpr int32_t INT32_BYTE { 4 };
51 constexpr int32_t PROMISE_WAIT_SPAN_MS { 2000 };
52 constexpr int32_t FOREGROUND_COLOR_IN { 0x33FF0000 };
53 constexpr int32_t FOREGROUND_COLOR_OUT { 0x00000000 };
54 int32_t g_shadowinfo_x { 0 };
55 int32_t g_shadowinfo_y { 0 };
56 constexpr int32_t ANIMATION_DURATION { 500 };
57 const std::string CURVE_NAME { "cubic-bezier" };
58 constexpr bool HAS_CUSTOM_ANIMATION { true };
59 constexpr int32_t TARGET_MAIN_WINDOW { 0 };
60 constexpr bool HAS_CANCELED_ANIMATION { true };
61 const std::string UD_KEY { "Unified data key" };
62 const std::string FILTER_INFO { "Undefined filter info" };
63 const std::string EXTRA_INFO { "Undefined extra info" };
64 constexpr int32_t SHADOW_NUM_ONE { 1 };
65 ContextService *g_instance = nullptr;
66 DelegateTasks g_delegateTasks;
67 DeviceManager g_devMgr;
68 TimerManager g_timerMgr;
69 DragManager g_dragMgr;
70 SocketSessionManager g_socketSessionMgr;
71 std::unique_ptr<IInputAdapter> g_input { nullptr };
72 std::unique_ptr<IPluginManager> g_pluginMgr { nullptr };
73 std::unique_ptr<IDSoftbusAdapter> g_dsoftbus { nullptr };
74 IContext *g_context { nullptr };
75 } // namespace
76
ContextService()77 ContextService::ContextService()
78 {
79 ddm_ = std::make_unique<DDMAdapter>();
80 }
81
~ContextService()82 ContextService::~ContextService()
83 {
84 }
85
GetDelegateTasks()86 IDelegateTasks& ContextService::GetDelegateTasks()
87 {
88 return g_delegateTasks;
89 }
90
GetDeviceManager()91 IDeviceManager& ContextService::GetDeviceManager()
92 {
93 return g_devMgr;
94 }
95
GetTimerManager()96 ITimerManager& ContextService::GetTimerManager()
97 {
98 return g_timerMgr;
99 }
100
GetDragManager()101 IDragManager& ContextService::GetDragManager()
102 {
103 return g_dragMgr;
104 }
105
GetInstance()106 ContextService* ContextService::GetInstance()
107 {
108 static std::once_flag flag;
109 std::call_once(flag, [&]() {
110 ContextService *cooContext = new (std::nothrow) ContextService();
111 CHKPL(cooContext);
112 g_instance = cooContext;
113 });
114 return g_instance;
115 }
116
GetSocketSessionManager()117 ISocketSessionManager& ContextService::GetSocketSessionManager()
118 {
119 return g_socketSessionMgr;
120 }
121
GetDDM()122 IDDMAdapter& ContextService::GetDDM()
123 {
124 return *ddm_;
125 }
126
GetPluginManager()127 IPluginManager& ContextService::GetPluginManager()
128 {
129 return *g_pluginMgr;
130 }
131
GetInput()132 IInputAdapter& ContextService::GetInput()
133 {
134 return *g_input;
135 }
136
GetDSoftbus()137 IDSoftbusAdapter& ContextService::GetDSoftbus()
138 {
139 return *g_dsoftbus;
140 }
141
SetUpTestCase()142 void DragManagerTest::SetUpTestCase() {}
143
SetUp()144 void DragManagerTest::SetUp()
145 {
146 g_context = ContextService::GetInstance();
147 g_dragMgr.Init(g_context);
148 }
149
TearDown()150 void DragManagerTest::TearDown()
151 {
152 g_context = nullptr;
153 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
154 }
155
CreatePixelMap(int32_t width,int32_t height)156 std::shared_ptr<Media::PixelMap> DragManagerTest::CreatePixelMap(int32_t width, int32_t height)
157 {
158 CALL_DEBUG_ENTER;
159 if (width <= 0 || width > MAX_PIXEL_MAP_WIDTH || height <= 0 || height > MAX_PIXEL_MAP_HEIGHT) {
160 FI_HILOGE("invalid, height:%{public}d, width:%{public}d", height, width);
161 return nullptr;
162 }
163 Media::InitializationOptions opts;
164 opts.size.width = width;
165 opts.size.height = height;
166 opts.pixelFormat = Media::PixelFormat::BGRA_8888;
167 opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
168 opts.scaleMode = Media::ScaleMode::FIT_TARGET_SIZE;
169
170 int32_t colorLen = width * height;
171 uint32_t *pixelColors = new (std::nothrow) uint32_t[BUFF_SIZE];
172 CHKPP(pixelColors);
173 int32_t colorByteCount = colorLen * INT32_BYTE;
174 errno_t ret = memset_s(pixelColors, BUFF_SIZE, DEFAULT_ICON_COLOR, colorByteCount);
175 if (ret != EOK) {
176 FI_HILOGE("memset_s failed");
177 delete[] pixelColors;
178 return nullptr;
179 }
180 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(pixelColors, colorLen, opts);
181 if (pixelMap == nullptr) {
182 FI_HILOGE("Create pixelMap failed");
183 delete[] pixelColors;
184 return nullptr;
185 }
186 delete[] pixelColors;
187 return pixelMap;
188 }
189
CreateDragData(int32_t sourceType,int32_t pointerId,int32_t dragNum,bool hasCoordinateCorrected,int32_t shadowNum)190 std::optional<DragData> DragManagerTest::CreateDragData(int32_t sourceType,
191 int32_t pointerId, int32_t dragNum, bool hasCoordinateCorrected, int32_t shadowNum)
192 {
193 CALL_DEBUG_ENTER;
194 DragData dragData;
195 for (int32_t i = 0; i < shadowNum; i++) {
196 std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(PIXEL_MAP_WIDTH, PIXEL_MAP_HEIGHT);
197 if (pixelMap == nullptr) {
198 FI_HILOGE("pixelMap nullptr");
199 return std::nullopt;
200 }
201 dragData.shadowInfos.push_back({ pixelMap, g_shadowinfo_x, g_shadowinfo_y });
202 }
203 dragData.buffer = std::vector<uint8_t>(MAX_BUFFER_SIZE, 0);
204 dragData.extraInfo = FILTER_INFO;
205 dragData.udKey = UD_KEY;
206 dragData.sourceType = sourceType;
207 dragData.extraInfo = EXTRA_INFO;
208 dragData.displayId = DISPLAY_ID;
209 dragData.pointerId = pointerId;
210 dragData.dragNum = dragNum;
211 dragData.displayX = DISPLAY_X;
212 dragData.displayY = DISPLAY_Y;
213 dragData.hasCoordinateCorrected = hasCoordinateCorrected;
214 dragData.hasCanceledAnimation = HAS_CANCELED_ANIMATION;
215 return dragData;
216 }
217
218 class TestStartDragListener : public IStartDragListener {
219 public:
TestStartDragListener(std::function<void (const DragNotifyMsg &)> function)220 explicit TestStartDragListener(std::function<void(const DragNotifyMsg&)> function) : function_(function) { }
OnDragEndMessage(const DragNotifyMsg & msg)221 void OnDragEndMessage(const DragNotifyMsg &msg) override
222 {
223 FI_HILOGD("DisplayX:%{public}d, displayY:%{public}d, targetPid:%{public}d, result:%{public}d",
224 msg.displayX, msg.displayY, msg.targetPid, static_cast<int32_t>(msg.result));
225 if (function_ != nullptr) {
226 function_(msg);
227 }
228 FI_HILOGD("Test OnDragEndMessage");
229 }
230
OnHideIconMessage()231 void OnHideIconMessage() override
232 {
233 FI_HILOGD("Test OnHideIconMessage");
234 }
235 private:
236 std::function<void(const DragNotifyMsg&)> function_;
237 };
238
239 class DragListenerTest : public IDragListener {
240 public:
DragListenerTest()241 DragListenerTest() {}
DragListenerTest(const std::string & name)242 explicit DragListenerTest(const std::string& name) : moduleName_(name) {}
OnDragMessage(DragState state)243 void OnDragMessage(DragState state) override
244 {
245 if (moduleName_.empty()) {
246 moduleName_ = std::string("DragListenerTest");
247 }
248 FI_HILOGD("%{public}s, state:%{public}s", moduleName_.c_str(), PrintDragMessage(state).c_str());
249 }
250 private:
PrintDragMessage(DragState state)251 std::string PrintDragMessage(DragState state)
252 {
253 std::string type = "unknow";
254 const std::map<DragState, std::string> stateType = {
255 { DragState::ERROR, "error"},
256 { DragState::START, "start"},
257 { DragState::STOP, "stop"},
258 { DragState::CANCEL, "cancel"}
259 };
260 auto item = stateType.find(state);
261 if (item != stateType.end()) {
262 type = item->second;
263 }
264 return type;
265 }
266 private:
267 std::string moduleName_;
268 };
269
270 class SubscriptListenerTest : public ISubscriptListener {
271 public:
SubscriptListenerTest()272 SubscriptListenerTest() {}
SubscriptListenerTest(const std::string & name)273 explicit SubscriptListenerTest(const std::string& name) : moduleName_(name) {}
OnMessage(DragCursorStyle style)274 void OnMessage(DragCursorStyle style) override
275 {
276 SetDragSyle(style);
277 if (moduleName_.empty()) {
278 moduleName_ = std::string("SubscriptListenerTest");
279 }
280 FI_HILOGD("subscriptListener, %{public}s, state:%{public}s",
281 moduleName_.c_str(), PrintStyleMessage(style).c_str());
282 }
283
GetDragStyle()284 DragCursorStyle GetDragStyle()
285 {
286 return dragStyle_;
287 }
288
289 private:
SetDragSyle(DragCursorStyle style)290 void SetDragSyle(DragCursorStyle style)
291 {
292 dragStyle_ = style;
293 }
294
PrintStyleMessage(DragCursorStyle style)295 std::string PrintStyleMessage(DragCursorStyle style)
296 {
297 std::string type = "unknow";
298 const std::map<DragCursorStyle, std::string> cursorStyles = {
299 { DragCursorStyle::DEFAULT, "default"},
300 { DragCursorStyle::FORBIDDEN, "forbidden"},
301 { DragCursorStyle::COPY, "copy"},
302 { DragCursorStyle::MOVE, "move"}
303 };
304 auto item = cursorStyles.find(style);
305 if (item != cursorStyles.end()) {
306 type = item->second;
307 }
308 return type;
309 }
310
311 private:
312 DragCursorStyle dragStyle_ { DragCursorStyle::DEFAULT };
313 std::string moduleName_;
314 };
315
AssignToAnimation(PreviewAnimation & animation)316 void DragManagerTest::AssignToAnimation(PreviewAnimation &animation)
317 {
318 animation.duration = ANIMATION_DURATION;
319 animation.curveName = CURVE_NAME;
320 animation.curve = { 0.33, 0, 0.67, 1 };
321 }
322
323 /**
324 * @tc.name: DragManagerTest1
325 * @tc.desc: Drag Drawing
326 * @tc.type: FUNC
327 * @tc.require:
328 */
329 HWTEST_F(DragManagerTest, DragManagerTest1, TestSize.Level0)
330 {
331 CALL_TEST_DEBUG;
332 std::optional<DragData> dragData = CreateDragData(
333 MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
334 EXPECT_TRUE(dragData);
335 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(), nullptr);
336 ASSERT_EQ(ret, RET_ERR);
337 }
338
339 /**
340 * @tc.name: DragManagerTest2
341 * @tc.desc: Drag Drawing
342 * @tc.type: FUNC
343 * @tc.require:
344 */
345 HWTEST_F(DragManagerTest, DragManagerTest2, TestSize.Level0)
346 {
347 CALL_TEST_DEBUG;
348 std::promise<bool> promiseFlag;
__anon73fbce6b0302(const DragNotifyMsg ¬ifyMessage) 349 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
350 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
351 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
352 promiseFlag.set_value(true);
353 };
354 std::optional<DragData> dragData = CreateDragData(
355 MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_ONE, false, 0);
356 EXPECT_TRUE(dragData);
357 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
358 std::make_shared<TestStartDragListener>(callback));
359 ASSERT_EQ(ret, ERR_INVALID_VALUE);
360 }
361
362 /**
363 * @tc.name: DragManagerTest3
364 * @tc.desc: Drag Drawing
365 * @tc.type: FUNC
366 * @tc.require:
367 */
368 HWTEST_F(DragManagerTest, DragManagerTest3, TestSize.Level0)
369 {
370 CALL_TEST_DEBUG;
371 std::promise<bool> promiseFlag;
372 g_shadowinfo_x = 2;
__anon73fbce6b0402(const DragNotifyMsg ¬ifyMessage) 373 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
374 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
375 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
376 promiseFlag.set_value(true);
377 };
378 std::optional<DragData> dragData = CreateDragData(
379 MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
380 EXPECT_TRUE(dragData);
381 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
382 std::make_shared<TestStartDragListener>(callback));
383 ASSERT_EQ(ret, RET_ERR);
384 }
385
386 /**
387 * @tc.name: DragManagerTest4
388 * @tc.desc: Drag Drawing
389 * @tc.type: FUNC
390 * @tc.require:
391 */
392 HWTEST_F(DragManagerTest, DragManagerTest4, TestSize.Level0)
393 {
394 CALL_TEST_DEBUG;
395 g_shadowinfo_x = 0;
396 std::promise<bool> promiseFlag;
__anon73fbce6b0502(const DragNotifyMsg ¬ifyMessage) 397 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
398 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
399 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
400 promiseFlag.set_value(true);
401 };
402 std::optional<DragData> dragData = CreateDragData(
403 MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, -1, false, SHADOW_NUM_ONE);
404 EXPECT_TRUE(dragData);
405 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
406 std::make_shared<TestStartDragListener>(callback));
407 ASSERT_EQ(ret, RET_ERR);
408 }
409
410 /**
411 * @tc.name: DragManagerTest5
412 * @tc.desc: Drag Drawing
413 * @tc.type: FUNC
414 * @tc.require:
415 */
416 HWTEST_F(DragManagerTest, DragManagerTest5, TestSize.Level0)
417 {
418 CALL_TEST_DEBUG;
419 int32_t ret = InteractionManager::GetInstance()->AddDraglistener(nullptr);
420 ASSERT_EQ(ret, RET_ERR);
421 ret = InteractionManager::GetInstance()->RemoveDraglistener(nullptr);
422 ASSERT_EQ(ret, RET_OK);
423 }
424
425 /**
426 * @tc.name: DragManagerTest6
427 * @tc.desc: Drag Drawing
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(DragManagerTest, DragManagerTest6, TestSize.Level0)
432 {
433 CALL_TEST_DEBUG;
434 auto listener = std::make_shared<DragListenerTest>(std::string("Draglistener_Mouse"));
435 int32_t ret = InteractionManager::GetInstance()->AddDraglistener(listener);
436 ASSERT_EQ(ret, RET_OK);
437 }
438
439 /**
440 * @tc.name: DragManagerTest7
441 * @tc.desc: Drag Drawing
442 * @tc.type: FUNC
443 * @tc.require:
444 */
445 HWTEST_F(DragManagerTest, DragManagerTest7, TestSize.Level0)
446 {
447 CALL_TEST_DEBUG;
448 int32_t ret = InteractionManager::GetInstance()->AddSubscriptListener(nullptr);
449 ASSERT_EQ(ret, RET_ERR);
450 }
451
452 /**
453 * @tc.name: DragManagerTest8
454 * @tc.desc: Drag Drawing
455 * @tc.type: FUNC
456 * @tc.require:
457 */
458 HWTEST_F(DragManagerTest, DragManagerTest8, TestSize.Level0)
459 {
460 CALL_TEST_DEBUG;
461 auto listener = std::make_shared<SubscriptListenerTest>("SubscriptListener");
462 int32_t ret = InteractionManager::GetInstance()->AddSubscriptListener(listener);
463 ASSERT_EQ(ret, RET_OK);
464 }
465
466 /**
467 * @tc.name: DragManagerTest9
468 * @tc.desc: Drag Drawing
469 * @tc.type: FUNC
470 * @tc.require:
471 */
472 HWTEST_F(DragManagerTest, DragManagerTest9, TestSize.Level0)
473 {
474 CALL_TEST_DEBUG;
475 auto listener = std::make_shared<SubscriptListenerTest>("SubscriptListener");
476 int32_t ret = InteractionManager::GetInstance()->RemoveSubscriptListener(listener);
477 ASSERT_EQ(ret, RET_OK);
478 }
479
480 /**
481 * @tc.name: DragManagerTest10
482 * @tc.desc: Drag Drawing
483 * @tc.type: FUNC
484 * @tc.require:
485 */
486 HWTEST_F(DragManagerTest, DragManagerTest10, TestSize.Level0)
487 {
488 CALL_TEST_DEBUG;
489 int32_t ret = InteractionManager::GetInstance()->RemoveSubscriptListener(nullptr);
490 ASSERT_EQ(ret, RET_OK);
491 }
492
493 /**
494 * @tc.name: DragManagerTest11
495 * @tc.desc: Drag Drawing
496 * @tc.type: FUNC
497 * @tc.require:
498 */
499 HWTEST_F(DragManagerTest, DragManagerTest11, TestSize.Level0)
500 {
501 CALL_TEST_DEBUG;
502 int32_t ret = InteractionManager::GetInstance()->RemoveSubscriptListener(nullptr);
503 auto listener = std::make_shared<SubscriptListenerTest>("SubscriptListener");
504 ret = InteractionManager::GetInstance()->AddSubscriptListener(listener);
505 ret = InteractionManager::GetInstance()->RemoveSubscriptListener(nullptr);
506 ASSERT_EQ(ret, RET_OK);
507 }
508
509 /**
510 * @tc.name: DragManagerTest12
511 * @tc.desc: Drag Drawing
512 * @tc.type: FUNC
513 * @tc.require:
514 */
515 HWTEST_F(DragManagerTest, DragManagerTest12, TestSize.Level0)
516 {
517 CALL_TEST_DEBUG;
518 int32_t ret = InteractionManager::GetInstance()->UpdateDragStyle(static_cast<DragCursorStyle>(-1));
519 ASSERT_EQ(ret, RET_ERR);
520 }
521
522 /**
523 * @tc.name: DragManagerTest13
524 * @tc.desc: Drag Drawing
525 * @tc.type: FUNC
526 * @tc.require:
527 */
528 HWTEST_F(DragManagerTest, DragManagerTest13, TestSize.Level0)
529 {
530 CALL_TEST_DEBUG;
531 std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(PIXEL_MAP_WIDTH, PIXEL_MAP_HEIGHT);
532 ASSERT_NE(pixelMap, nullptr);
533 ShadowInfo shadowInfo = { pixelMap, 1, 0 };
534 int32_t ret = InteractionManager::GetInstance()->UpdateShadowPic(shadowInfo);
535 ASSERT_EQ(ret, RET_ERR);
536 }
537
538 /**
539 * @tc.name: DragManagerTest14
540 * @tc.desc: Drag Drawing
541 * @tc.type: FUNC
542 * @tc.require:
543 */
544 HWTEST_F(DragManagerTest, DragManagerTest14, TestSize.Level0)
545 {
546 CALL_TEST_DEBUG;
547 std::optional<DragData> dragData = CreateDragData(
548 MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
549 EXPECT_TRUE(dragData);
550 std::promise<bool> promiseFlag;
551 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b0602(const DragNotifyMsg ¬ifyMessage) 552 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
553 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
554 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
555 promiseFlag.set_value(true);
556 };
557 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
558 std::make_shared<TestStartDragListener>(callback));
559 ASSERT_EQ(ret, RET_OK);
560 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
561 std::vector<DragCursorStyle> dragCursorStyles = {DragCursorStyle::DEFAULT,
562 DragCursorStyle::FORBIDDEN, DragCursorStyle::COPY, DragCursorStyle::MOVE};
563 for (const auto& dragCursorStyle : dragCursorStyles) {
564 ret = InteractionManager::GetInstance()->UpdateDragStyle(dragCursorStyle);
565 ASSERT_EQ(ret, RET_OK);
566 }
567 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
568 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
569 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
570 ASSERT_EQ(ret, RET_OK);
571 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
572 std::future_status::timeout);
573 }
574
575 /**
576 * @tc.name: DragManagerTest15
577 * @tc.desc: Drag Drawing
578 * @tc.type: FUNC
579 * @tc.require:
580 */
581 HWTEST_F(DragManagerTest, DragManagerTest15, TestSize.Level0)
582 {
583 CALL_TEST_DEBUG;
584 std::promise<bool> promiseFlag;
585 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b0702(const DragNotifyMsg ¬ifyMessage) 586 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
587 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
588 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
589 promiseFlag.set_value(true);
590 };
591 std::optional<DragData> dragData = CreateDragData(
592 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
593 EXPECT_TRUE(dragData);
594 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
595 std::make_shared<TestStartDragListener>(callback));
596 ASSERT_EQ(ret, RET_OK);
597 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
598 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
599 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
600 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
601 ASSERT_EQ(ret, RET_OK);
602 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
603 std::future_status::timeout);}
604
605 /**
606 * @tc.name: DragManagerTest16
607 * @tc.desc: Drag Drawing
608 * @tc.type: FUNC
609 * @tc.require:
610 */
611 HWTEST_F(DragManagerTest, DragManagerTest16, TestSize.Level0)
612 {
613 CALL_TEST_DEBUG;
614 std::promise<bool> promiseFlag;
615 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b0802(const DragNotifyMsg ¬ifyMessage) 616 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
617 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
618 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
619 promiseFlag.set_value(true);
620 };
621 std::optional<DragData> dragData = CreateDragData(
622 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
623 EXPECT_TRUE(dragData);
624 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
625 std::make_shared<TestStartDragListener>(callback));
626 ASSERT_EQ(ret, RET_OK);
627 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
628 std::string udKey;
629 ret = InteractionManager::GetInstance()->GetUdKey(udKey);
630 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
631 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
632 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
633 ASSERT_EQ(ret, RET_OK);
634 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
635 std::future_status::timeout);}
636
637 /**
638 * @tc.name: DragManagerTest17
639 * @tc.desc: Drag Drawing
640 * @tc.type: FUNC
641 * @tc.require:
642 */
643 HWTEST_F(DragManagerTest, DragManagerTest17, TestSize.Level0)
644 {
645 CALL_TEST_DEBUG;
646 std::promise<bool> promiseFlag;
647 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b0902(const DragNotifyMsg ¬ifyMessage) 648 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
649 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
650 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
651 promiseFlag.set_value(true);
652 };
653 std::optional<DragData> dragData = CreateDragData(
654 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
655 EXPECT_TRUE(dragData);
656 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
657 std::make_shared<TestStartDragListener>(callback));
658 ASSERT_EQ(ret, RET_OK);
659 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
660 ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
661 ASSERT_EQ(ret, RET_OK);
662 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
663 ret = InteractionManager::GetInstance()->SetDragWindowVisible(false);
664 ASSERT_EQ(ret, RET_OK);
665 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
666 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
667 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
668 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
669 ASSERT_EQ(ret, RET_OK);
670 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
671 std::future_status::timeout);
672 }
673
674 /**
675 * @tc.name: DragManagerTest18
676 * @tc.desc: Drag Drawing
677 * @tc.type: FUNC
678 * @tc.require:
679 */
680 HWTEST_F(DragManagerTest, DragManagerTest18, TestSize.Level0)
681 {
682 CALL_TEST_DEBUG;
683 int32_t offsetX = 0;
684 int32_t offsetY = 0;
685 int32_t width = 0;
686 int32_t height = 0;
687 std::promise<bool> promiseFlag;
688 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b0a02(const DragNotifyMsg ¬ifyMessage) 689 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
690 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
691 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
692 promiseFlag.set_value(true);
693 };
694 std::optional<DragData> dragData = CreateDragData(
695 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
696 EXPECT_TRUE(dragData);
697 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
698 std::make_shared<TestStartDragListener>(callback));
699 ASSERT_EQ(ret, RET_OK);
700 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
701 ret = InteractionManager::GetInstance()->GetShadowOffset(offsetX, offsetY, width, height);
702 ASSERT_EQ(ret, RET_OK);
703 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
704 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
705 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
706 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
707 ASSERT_EQ(ret, RET_OK);
708 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
709 std::future_status::timeout);
710 }
711
712 /**
713 * @tc.name: DragManagerTest19
714 * @tc.desc: Drag Drawing
715 * @tc.type: FUNC
716 * @tc.require:
717 */
718 HWTEST_F(DragManagerTest, DragManagerTest19, TestSize.Level0)
719 {
720 CALL_TEST_DEBUG;
721 std::promise<bool> promiseFlag;
722 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b0b02(const DragNotifyMsg ¬ifyMessage) 723 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
724 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
725 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
726 promiseFlag.set_value(true);
727 };
728 std::optional<DragData> dragData = CreateDragData(
729 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
730 EXPECT_TRUE(dragData);
731 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
732 std::make_shared<TestStartDragListener>(callback));
733 ASSERT_EQ(ret, RET_OK);
734 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
735 std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(PIXEL_MAP_WIDTH, PIXEL_MAP_HEIGHT);
736 ASSERT_NE(pixelMap, nullptr);
737 ShadowInfo shadowInfo = { pixelMap, 0, 0 };
738 ret = InteractionManager::GetInstance()->UpdateShadowPic(shadowInfo);
739 ASSERT_EQ(ret, RET_OK);
740 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
741 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
742 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
743 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
744 ASSERT_EQ(ret, RET_OK);
745 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
746 std::future_status::timeout);
747 }
748
749 /**
750 * @tc.name: DragManagerTest20
751 * @tc.desc: Drag Drawing
752 * @tc.type: FUNC
753 * @tc.require:
754 */
755 HWTEST_F(DragManagerTest, DragManagerTest20, TestSize.Level0)
756 {
757 CALL_TEST_DEBUG;
758 std::promise<bool> promiseFlag;
759 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b0c02(const DragNotifyMsg ¬ifyMessage) 760 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
761 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
762 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
763 promiseFlag.set_value(true);
764 };
765 std::optional<DragData> dragData = CreateDragData(
766 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
767 EXPECT_TRUE(dragData);
768 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
769 std::make_shared<TestStartDragListener>(callback));
770 ASSERT_EQ(ret, RET_OK);
771 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
772 DragData replyDragData;
773 ret = InteractionManager::GetInstance()->GetDragData(replyDragData);
774 ASSERT_EQ(ret, RET_OK);
775 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
776 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
777 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
778 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
779 ASSERT_EQ(ret, RET_OK);
780 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
781 std::future_status::timeout);
782 }
783
784 /**
785 * @tc.name: DragManagerTest21
786 * @tc.desc: Drag Drawing
787 * @tc.type: FUNC
788 * @tc.require:
789 */
790 HWTEST_F(DragManagerTest, DragManagerTest21, TestSize.Level0)
791 {
792 CALL_TEST_DEBUG;
793 std::promise<bool> promiseFlag;
794 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b0d02(const DragNotifyMsg ¬ifyMessage) 795 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
796 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
797 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
798 promiseFlag.set_value(true);
799 };
800 std::optional<DragData> dragData = CreateDragData(
801 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
802 EXPECT_TRUE(dragData);
803 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
804 std::make_shared<TestStartDragListener>(callback));
805 ASSERT_EQ(ret, RET_OK);
806 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
807 DragState dragState;
808 ret = InteractionManager::GetInstance()->GetDragState(dragState);
809 ASSERT_EQ(ret, RET_OK);
810 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
811 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
812 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
813 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
814 ASSERT_EQ(ret, RET_OK);
815 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
816 std::future_status::timeout);
817 }
818
819 /**
820 * @tc.name: DragManagerTest22
821 * @tc.desc: Drag Drawing
822 * @tc.type: FUNC
823 * @tc.require:
824 */
825 HWTEST_F(DragManagerTest, DragManagerTest22, TestSize.Level0)
826 {
827 CALL_TEST_DEBUG;
828 std::promise<bool> promiseFlag;
829 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b0e02(const DragNotifyMsg ¬ifyMessage) 830 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
831 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
832 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
833 promiseFlag.set_value(true);
834 };
835 std::optional<DragData> dragData = CreateDragData(
836 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
837 EXPECT_TRUE(dragData);
838 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
839 std::make_shared<TestStartDragListener>(callback));
840 ASSERT_EQ(ret, RET_OK);
841 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
842 DragAction dragAction { DragAction::INVALID };
843 ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
844 ASSERT_EQ(ret, RET_OK);
845 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
846 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
847 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
848 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
849 ASSERT_EQ(ret, RET_OK);
850 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
851 std::future_status::timeout);
852 }
853
854 /**
855 * @tc.name: DragManagerTest23
856 * @tc.desc: Drag Drawing
857 * @tc.type: FUNC
858 * @tc.require:
859 */
860 HWTEST_F(DragManagerTest, DragManagerTest23, TestSize.Level0)
861 {
862 CALL_TEST_DEBUG;
863 std::promise<bool> promiseFlag;
864 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b0f02(const DragNotifyMsg ¬ifyMessage) 865 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
866 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
867 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
868 promiseFlag.set_value(true);
869 };
870 std::optional<DragData> dragData = CreateDragData(
871 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
872 EXPECT_TRUE(dragData);
873 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
874 std::make_shared<TestStartDragListener>(callback));
875 ASSERT_EQ(ret, RET_OK);
876 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
877 std::string extraInfo;
878 ret = InteractionManager::GetInstance()->GetExtraInfo(extraInfo);
879 ASSERT_EQ(ret, RET_OK);
880 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
881 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
882 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
883 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
884 ASSERT_EQ(ret, RET_OK);
885 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
886 std::future_status::timeout);
887 }
888
889 /**
890 * @tc.name: DragManagerTest24
891 * @tc.desc: Drag Drawing
892 * @tc.type: FUNC
893 * @tc.require:
894 */
895 HWTEST_F(DragManagerTest, DragManagerTest24, TestSize.Level0)
896 {
897 CALL_TEST_DEBUG;
898 std::promise<bool> promiseFlag;
899 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b1002(const DragNotifyMsg ¬ifyMessage) 900 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
901 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
902 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
903 promiseFlag.set_value(true);
904 };
905 std::optional<DragData> dragData = CreateDragData(
906 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
907 EXPECT_TRUE(dragData);
908 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
909 std::make_shared<TestStartDragListener>(callback));
910 ASSERT_EQ(ret, RET_OK);
911 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
912 PreviewStyle previewStyleIn;
913 previewStyleIn.types = { PreviewType::FOREGROUND_COLOR };
914 previewStyleIn.foregroundColor = FOREGROUND_COLOR_IN;
915 ret = InteractionManager::GetInstance()->UpdatePreviewStyle(previewStyleIn);
916 ASSERT_EQ(ret, RET_OK);
917 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
918 PreviewStyle previewStyleOut;
919 previewStyleOut.types = { PreviewType::FOREGROUND_COLOR };
920 previewStyleOut.foregroundColor = FOREGROUND_COLOR_OUT;
921 ret = InteractionManager::GetInstance()->UpdatePreviewStyle(previewStyleOut);
922 EXPECT_EQ(ret, RET_OK);
923 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
924 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
925 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
926 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
927 ASSERT_EQ(ret, RET_OK);
928 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
929 std::future_status::timeout);
930 }
931
932 /**
933 * @tc.name: DragManagerTest25
934 * @tc.desc: Drag Drawing
935 * @tc.type: FUNC
936 * @tc.require:
937 */
938 HWTEST_F(DragManagerTest, DragManagerTest25, TestSize.Level0)
939 {
940 CALL_TEST_DEBUG;
941 std::promise<bool> promiseFlag;
942 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b1102(const DragNotifyMsg ¬ifyMessage) 943 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
944 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
945 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
946 promiseFlag.set_value(true);
947 };
948 std::optional<DragData> dragData = CreateDragData(
949 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
950 EXPECT_TRUE(dragData);
951 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
952 std::make_shared<TestStartDragListener>(callback));
953 ASSERT_EQ(ret, RET_OK);
954 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
955 PreviewStyle previewStyleIn;
956 previewStyleIn.types = { PreviewType::FOREGROUND_COLOR };
957 previewStyleIn.foregroundColor = FOREGROUND_COLOR_IN;
958 PreviewAnimation animationIn;
959 AssignToAnimation(animationIn);
960 ret = InteractionManager::GetInstance()->UpdatePreviewStyleWithAnimation(previewStyleIn, animationIn);
961 ASSERT_EQ(ret, RET_OK);
962 PreviewStyle previewStyleOut;
963 previewStyleOut.types = { PreviewType::FOREGROUND_COLOR };
964 previewStyleOut.foregroundColor = FOREGROUND_COLOR_OUT;
965 PreviewAnimation animationOut;
966 AssignToAnimation(animationOut);
967 ret = InteractionManager::GetInstance()->UpdatePreviewStyleWithAnimation(previewStyleOut, animationOut);
968 EXPECT_EQ(ret, RET_OK);
969 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
970 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
971 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
972 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
973 ASSERT_EQ(ret, RET_OK);
974 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
975 std::future_status::timeout);
976 }
977
978 /**
979 * @tc.name: DragManagerTest26
980 * @tc.desc: Drag Drawing
981 * @tc.type: FUNC
982 * @tc.require:
983 */
984 HWTEST_F(DragManagerTest, DragManagerTest26, TestSize.Level0)
985 {
986 CALL_TEST_DEBUG;
987 std::promise<bool> promiseFlag;
988 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b1202(const DragNotifyMsg ¬ifyMessage) 989 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
990 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
991 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
992 promiseFlag.set_value(true);
993 };
994 std::optional<DragData> dragData = CreateDragData(
995 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
996 EXPECT_TRUE(dragData);
997 const std::string udType = "general.message";
998 constexpr int64_t recordSize = 20;
999 std::map<std::string, int64_t> summarys = { { udType, recordSize } };
1000 dragData.value().summarys = summarys;
1001 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1002 std::make_shared<TestStartDragListener>(callback));
1003 ASSERT_EQ(ret, RET_OK);
1004 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1005 std::map<std::string, int64_t> summarysRlt;
1006 ret = InteractionManager::GetInstance()->GetDragSummary(summarysRlt);
1007 ASSERT_EQ(ret, RET_OK);
1008 EXPECT_EQ(summarysRlt, summarys);
1009 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1010 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
1011 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
1012 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1013 ASSERT_EQ(ret, RET_OK);
1014 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1015 std::future_status::timeout);
1016 }
1017
1018 /**
1019 * @tc.name: DragManagerTest27
1020 * @tc.desc: Drag Drawing
1021 * @tc.type: FUNC
1022 * @tc.require:
1023 */
1024 HWTEST_F(DragManagerTest, DragManagerTest27, TestSize.Level0)
1025 {
1026 CALL_TEST_DEBUG;
1027 std::promise<bool> promiseFlag;
1028 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b1302(const DragNotifyMsg ¬ifyMessage) 1029 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
1030 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1031 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1032 promiseFlag.set_value(true);
1033 };
1034 std::optional<DragData> dragData = CreateDragData(
1035 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
1036 EXPECT_TRUE(dragData);
1037 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1038 std::make_shared<TestStartDragListener>(callback));
1039 ASSERT_EQ(ret, RET_OK);
1040 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1041 ret = InteractionManager::GetInstance()->EnterTextEditorArea(true);
1042 ASSERT_EQ(ret, RET_OK);
1043 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1044 ret = InteractionManager::GetInstance()->EnterTextEditorArea(false);
1045 ASSERT_EQ(ret, RET_OK);
1046 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1047 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
1048 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
1049 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1050 ASSERT_EQ(ret, RET_OK);
1051 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1052 std::future_status::timeout);
1053 }
1054
1055 /**
1056 * @tc.name: DragManagerTest28
1057 * @tc.desc: Drag Drawing
1058 * @tc.type: FUNC
1059 * @tc.require:
1060 */
1061 HWTEST_F(DragManagerTest, DragManagerTest28, TestSize.Level0)
1062 {
1063 CALL_TEST_DEBUG;
1064 std::promise<bool> promiseFlag;
1065 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b1402(const DragNotifyMsg ¬ifyMessage) 1066 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
1067 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1068 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1069 promiseFlag.set_value(true);
1070 };
1071 std::optional<DragData> dragData = CreateDragData(
1072 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
1073 EXPECT_TRUE(dragData);
1074 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1075 std::make_shared<TestStartDragListener>(callback));
1076 ASSERT_EQ(ret, RET_OK);
1077 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1078 ret = InteractionManager::GetInstance()->AddPrivilege();
1079 ASSERT_EQ(ret, RET_OK);
1080 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1081 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
1082 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
1083 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1084 ASSERT_EQ(ret, RET_OK);
1085 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1086 std::future_status::timeout);
1087 }
1088
1089 /**
1090 * @tc.name: DragManagerTest29
1091 * @tc.desc: Drag Drawing
1092 * @tc.type: FUNC
1093 * @tc.require:
1094 */
1095 HWTEST_F(DragManagerTest, DragManagerTest29, TestSize.Level0)
1096 {
1097 CALL_TEST_DEBUG;
1098 std::promise<bool> promiseFlag;
1099 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b1502(const DragNotifyMsg ¬ifyMessage) 1100 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
1101 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1102 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1103 promiseFlag.set_value(true);
1104 };
1105 std::optional<DragData> dragData = CreateDragData(
1106 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
1107 EXPECT_TRUE(dragData);
1108 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1109 std::make_shared<TestStartDragListener>(callback));
1110 ASSERT_EQ(ret, RET_OK);
1111 ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1112 std::make_shared<TestStartDragListener>(callback));
1113 ASSERT_EQ(ret, RET_ERR);
1114 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1115 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
1116 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
1117 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1118 ASSERT_EQ(ret, RET_OK);
1119 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1120 std::future_status::timeout);
1121 }
1122
1123 /**
1124 * @tc.name: DragManagerTest30
1125 * @tc.desc: Drag Drawing
1126 * @tc.type: FUNC
1127 * @tc.require:
1128 */
1129 HWTEST_F(DragManagerTest, DragManagerTest30, TestSize.Level0)
1130 {
1131 CALL_TEST_DEBUG;
1132 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
1133 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
1134 int32_t ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1135 ASSERT_EQ(ret, RET_ERR);
1136 }
1137
1138 /**
1139 * @tc.name: DragManagerTest31
1140 * @tc.desc: Drag Drawing
1141 * @tc.type: FUNC
1142 * @tc.require:
1143 */
1144 HWTEST_F(DragManagerTest, DragManagerTest31, TestSize.Level0)
1145 {
1146 CALL_TEST_DEBUG;
1147 int32_t ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1148 ASSERT_EQ(ret, RET_ERR);
1149 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1150 ret = InteractionManager::GetInstance()->SetDragWindowVisible(false);
1151 ASSERT_EQ(ret, RET_ERR);
1152 }
1153
1154 /**
1155 * @tc.name: DragManagerTest32
1156 * @tc.desc: Drag Drawing
1157 * @tc.type: FUNC
1158 * @tc.require:
1159 */
1160 HWTEST_F(DragManagerTest, DragManagerTest32, TestSize.Level0)
1161 {
1162 CALL_TEST_DEBUG;
1163 int32_t ret = -1;
1164 std::vector<DragCursorStyle> dragCursorStyles = {DragCursorStyle::FORBIDDEN,
1165 DragCursorStyle::COPY, DragCursorStyle::MOVE};
1166 for (const auto& dragCursorStyle : dragCursorStyles) {
1167 ret = InteractionManager::GetInstance()->UpdateDragStyle(dragCursorStyle);
1168 ASSERT_EQ(ret, RET_ERR);
1169 }
1170 }
1171
1172 /**
1173 * @tc.name: DragManagerTest33
1174 * @tc.desc: Drag Drawing
1175 * @tc.type: FUNC
1176 * @tc.require:
1177 */
1178 HWTEST_F(DragManagerTest, DragManagerTest33, TestSize.Level0)
1179 {
1180 CALL_TEST_DEBUG;
1181 std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(PIXEL_MAP_WIDTH, PIXEL_MAP_HEIGHT);
1182 ASSERT_NE(pixelMap, nullptr);
1183 ShadowInfo shadowInfo = { pixelMap, 0, 0 };
1184 int32_t ret = InteractionManager::GetInstance()->UpdateShadowPic(shadowInfo);
1185 ASSERT_EQ(ret, RET_ERR);
1186 }
1187
1188 /**
1189 * @tc.name: DragManagerTest34
1190 * @tc.desc: Drag Drawing
1191 * @tc.type: FUNC
1192 * @tc.require:
1193 */
1194 HWTEST_F(DragManagerTest, DragManagerTest34, TestSize.Level0)
1195 {
1196 CALL_TEST_DEBUG;
1197 int32_t pid = InteractionManager::GetInstance()->GetDragTargetPid();
1198 EXPECT_GT(pid, 0);
1199 }
1200
1201 /**
1202 * @tc.name: DragManagerTest35
1203 * @tc.desc: Drag Drawing
1204 * @tc.type: FUNC
1205 * @tc.require:
1206 */
1207 HWTEST_F(DragManagerTest, DragManagerTest35, TestSize.Level0)
1208 {
1209 CALL_TEST_DEBUG;
1210 std::string udKey;
1211 int32_t ret = InteractionManager::GetInstance()->GetUdKey(udKey);
1212 ASSERT_EQ(ret, RET_ERR);
1213 }
1214
1215 /**
1216 * @tc.name: DragManagerTest36
1217 * @tc.desc: Drag Drawing
1218 * @tc.type: FUNC
1219 * @tc.require:
1220 */
1221 HWTEST_F(DragManagerTest, DragManagerTest36, TestSize.Level0)
1222 {
1223 CALL_TEST_DEBUG;
1224 int32_t offsetX = 0;
1225 int32_t offsetY = 0;
1226 int32_t width = 0;
1227 int32_t height = 0;
1228 int32_t ret = InteractionManager::GetInstance()->GetShadowOffset(offsetX, offsetY, width, height);
1229 ASSERT_EQ(ret, RET_ERR);
1230 }
1231
1232 /**
1233 * @tc.name: DragManagerTest37
1234 * @tc.desc: Drag Drawing
1235 * @tc.type: FUNC
1236 * @tc.require:
1237 */
1238 HWTEST_F(DragManagerTest, DragManagerTest37, TestSize.Level0)
1239 {
1240 CALL_TEST_DEBUG;
1241 DragData replyDragData;
1242 int32_t ret = InteractionManager::GetInstance()->GetDragData(replyDragData);
1243 ASSERT_EQ(ret, RET_ERR);
1244 }
1245
1246 /**
1247 * @tc.name: DragManagerTest38
1248 * @tc.desc: Drag Drawing
1249 * @tc.type: FUNC
1250 * @tc.require:
1251 */
1252 HWTEST_F(DragManagerTest, DragManagerTest38, TestSize.Level0)
1253 {
1254 CALL_TEST_DEBUG;
1255 PreviewStyle previewStyleOut;
1256 previewStyleOut.types = { PreviewType::FOREGROUND_COLOR };
1257 previewStyleOut.foregroundColor = FOREGROUND_COLOR_OUT;
1258 int32_t ret = InteractionManager::GetInstance()->UpdatePreviewStyle(previewStyleOut);
1259 ASSERT_EQ(ret, RET_ERR);
1260 PreviewStyle previewStyleIn;
1261 previewStyleIn.types = { PreviewType::FOREGROUND_COLOR };
1262 previewStyleIn.foregroundColor = FOREGROUND_COLOR_IN;
1263 ret = InteractionManager::GetInstance()->UpdatePreviewStyle(previewStyleIn);
1264 ASSERT_EQ(ret, RET_ERR);
1265 }
1266
1267 /**
1268 * @tc.name: DragManagerTest39
1269 * @tc.desc: Drag Drawing
1270 * @tc.type: FUNC
1271 * @tc.require:
1272 */
1273 HWTEST_F(DragManagerTest, DragManagerTest39, TestSize.Level0)
1274 {
1275 CALL_TEST_DEBUG;
1276 PreviewStyle previewStyleIn;
1277 previewStyleIn.types = { PreviewType::FOREGROUND_COLOR };
1278 previewStyleIn.foregroundColor = FOREGROUND_COLOR_IN;
1279 PreviewAnimation animationIn;
1280 AssignToAnimation(animationIn);
1281 int32_t ret = InteractionManager::GetInstance()->UpdatePreviewStyleWithAnimation(previewStyleIn, animationIn);
1282 ASSERT_EQ(ret, RET_ERR);
1283 PreviewStyle previewStyleOut;
1284 previewStyleOut.types = { PreviewType::FOREGROUND_COLOR };
1285 previewStyleOut.foregroundColor = FOREGROUND_COLOR_OUT;
1286 PreviewAnimation animationOut;
1287 AssignToAnimation(animationOut);
1288 ret = InteractionManager::GetInstance()->UpdatePreviewStyleWithAnimation(previewStyleOut, animationOut);
1289 ASSERT_EQ(ret, RET_ERR);
1290 }
1291
1292 /**
1293 * @tc.name: DragManagerTest40
1294 * @tc.desc: Drag Drawing
1295 * @tc.type: FUNC
1296 * @tc.require:
1297 */
1298 HWTEST_F(DragManagerTest, DragManagerTest40, TestSize.Level0)
1299 {
1300 CALL_TEST_DEBUG;
1301 int32_t ret = InteractionManager::GetInstance()->EnterTextEditorArea(true);
1302 ASSERT_EQ(ret, RET_ERR);
1303 ret = InteractionManager::GetInstance()->EnterTextEditorArea(false);
1304 ASSERT_EQ(ret, RET_ERR);
1305 }
1306
1307 /**
1308 * @tc.name: DragManagerTest41
1309 * @tc.desc: Drag Drawing
1310 * @tc.type: FUNC
1311 * @tc.require:
1312 */
1313 HWTEST_F(DragManagerTest, DragManagerTest41, TestSize.Level0)
1314 {
1315 CALL_TEST_DEBUG;
1316 DragAction dragAction { DragAction::INVALID };
1317 int32_t ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
1318 ASSERT_EQ(ret, RET_ERR);
1319 }
1320
1321 /**
1322 * @tc.name: DragManagerTest42
1323 * @tc.desc: Drag Drawing
1324 * @tc.type: FUNC
1325 * @tc.require:
1326 */
1327 HWTEST_F(DragManagerTest, DragManagerTest42, TestSize.Level0)
1328 {
1329 CALL_TEST_DEBUG;
1330 std::string extraInfo;
1331 int32_t ret = InteractionManager::GetInstance()->GetExtraInfo(extraInfo);
1332 ASSERT_EQ(ret, RET_ERR);
1333 }
1334
1335 /**
1336 * @tc.name: DragManagerTest43
1337 * @tc.desc: Drag Drawing
1338 * @tc.type: FUNC
1339 * @tc.require:
1340 */
1341 HWTEST_F(DragManagerTest, DragManagerTest43, TestSize.Level0)
1342 {
1343 CALL_TEST_DEBUG;
1344 int32_t ret = InteractionManager::GetInstance()->AddPrivilege();
1345 ASSERT_EQ(ret, RET_ERR);
1346 }
1347
1348 /**
1349 * @tc.name: DragManagerTest68
1350 * @tc.desc: Drag Drawingx`
1351 * @tc.type: FUNC
1352 * @tc.require:
1353 */
1354 HWTEST_F(DragManagerTest, DragManagerTest68, TestSize.Level0)
1355 {
1356 CALL_TEST_DEBUG;
1357 std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(PIXEL_MAP_WIDTH, PIXEL_MAP_HEIGHT);
1358 ASSERT_NE(pixelMap, nullptr);
1359 ShadowInfo shadowInfo = { pixelMap, 1, 0 };
1360 ShadowInfo otherShadowInfo = {};
1361 EXPECT_TRUE(shadowInfo != otherShadowInfo);
1362 ShadowOffset shadowOffset {};
1363 ShadowOffset otherShadowOffset {};
1364 EXPECT_FALSE(shadowOffset != otherShadowOffset);
1365 DragData dragData {};
1366 DragData otherDragData {};
1367 EXPECT_FALSE(dragData != otherDragData);
1368 PreviewStyle previewStyle {};
1369 PreviewStyle otherPreviewStyle {};
1370 EXPECT_FALSE(previewStyle != otherPreviewStyle);
1371 Data data {};
1372 Data otherData {};
1373 EXPECT_TRUE(data != otherData);
1374 DragItemStyle dragItemStyle = { 1, 1, 0 };
1375 DragItemStyle otherDragItemStyle = {};
1376 DragItemStyle dragItemStyleOne = { 1, 1, 0 };
1377 EXPECT_TRUE(dragItemStyle != otherDragItemStyle);
1378 EXPECT_TRUE(dragItemStyle == dragItemStyleOne);
1379 }
1380
1381 /**
1382 * @tc.name: DragManagerTest69
1383 * @tc.desc: Drag Drawingx`
1384 * @tc.type: FUNC
1385 * @tc.require:
1386 */
1387 HWTEST_F(DragManagerTest, DragManagerTest69, TestSize.Level0)
1388 {
1389 CALL_TEST_DEBUG;
1390 int32_t ret = InteractionManager::GetInstance()->RotateDragWindowSync(nullptr);
1391 EXPECT_EQ(ret, 5);
1392 }
1393
1394 /**
1395 * @tc.name: DragManagerTest70
1396 * @tc.desc: Drag Drawing
1397 * @tc.type: FUNC
1398 * @tc.require:
1399 */
1400 HWTEST_F(DragManagerTest, DragManagerTest70, TestSize.Level0)
1401 {
1402 CALL_TEST_DEBUG;
1403 DragBundleInfo dragBundleInfo;
1404 int32_t ret = InteractionManager::GetInstance()->GetDragBundleInfo(dragBundleInfo);
1405 ASSERT_EQ(ret, RET_ERR);
1406 }
1407
1408 /**
1409 * @tc.name: DragManagerTest71
1410 * @tc.desc: Drag Drawing
1411 * @tc.type: FUNC
1412 * @tc.require:
1413 */
1414 HWTEST_F(DragManagerTest, DragManagerTest71, TestSize.Level0)
1415 {
1416 CALL_TEST_DEBUG;
1417 std::promise<bool> promiseFlag;
1418 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b1602(const DragNotifyMsg ¬ifyMessage) 1419 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
1420 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1421 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1422 promiseFlag.set_value(true);
1423 };
1424 std::optional<DragData> dragData = CreateDragData(
1425 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
1426 EXPECT_TRUE(dragData);
1427 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1428 std::make_shared<TestStartDragListener>(callback));
1429 ASSERT_EQ(ret, RET_OK);
1430 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1431 DragBundleInfo dragBundleInfo;
1432 ret = InteractionManager::GetInstance()->GetDragBundleInfo(dragBundleInfo);
1433 ASSERT_EQ(ret, RET_OK);
1434 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1435 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
1436 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
1437 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1438 ASSERT_EQ(ret, RET_OK);
1439 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1440 std::future_status::timeout);
1441 }
1442
1443 /**
1444 * @tc.name: DragManagerTest72
1445 * @tc.desc: Drag Drawing
1446 * @tc.type: FUNC
1447 * @tc.require:
1448 */
1449 HWTEST_F(DragManagerTest, DragManagerTest72, TestSize.Level0)
1450 {
1451 CALL_TEST_DEBUG;
1452 std::promise<bool> promiseFlag;
1453 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b1702(const DragNotifyMsg ¬ifyMessage) 1454 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
1455 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1456 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1457 promiseFlag.set_value(true);
1458 };
1459 std::optional<DragData> dragData = CreateDragData(
1460 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
1461 EXPECT_TRUE(dragData);
1462 const std::string udType = "general.message";
1463 constexpr int64_t recordSize = 20;
1464 std::map<std::string, int64_t> summarys = { { udType, recordSize } };
1465 dragData.value().detailedSummarys = summarys;
1466
1467 const std::string udType1 = "general1.message";
1468 constexpr int64_t recordSize1 = 30;
1469 std::map<std::string, int64_t> summarys1 = { { udType1, recordSize1 } };
1470 dragData.value().summarys = summarys1;
1471 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1472 std::make_shared<TestStartDragListener>(callback));
1473 ASSERT_EQ(ret, RET_OK);
1474 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1475 std::map<std::string, int64_t> summarysRlt;
1476 ret = InteractionManager::GetInstance()->GetDragSummary(summarysRlt);
1477 ASSERT_EQ(ret, RET_OK);
1478 EXPECT_EQ(summarysRlt.size(), 1);
1479 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1480 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
1481 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
1482 ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1483 ASSERT_EQ(ret, RET_OK);
1484 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1485 std::future_status::timeout);
1486 }
1487
1488 #ifdef OHOS_BUILD_INTERNAL_DROP_ANIMATION
1489 /**
1490 * @tc.name: DragManagerTest73
1491 * @tc.desc: Drag Drawing
1492 * @tc.type: FUNC
1493 * @tc.require:
1494 */
1495 HWTEST_F(DragManagerTest, DragManagerTest73, TestSize.Level0)
1496 {
1497 CALL_TEST_DEBUG;
1498 DragInternalInfo dragInternalInfo;
1499 g_dragMgr.GetDragDrawingInfo(dragInternalInfo);
1500 ASSERT_EQ(dragInternalInfo.rootNode, nullptr);
1501 }
1502
1503 /**
1504 * @tc.name: DragManagerTest74
1505 * @tc.desc: Drag Drawing
1506 * @tc.type: FUNC
1507 * @tc.require:
1508 */
1509 HWTEST_F(DragManagerTest, DragManagerTest74, TestSize.Level0)
1510 {
1511 CALL_TEST_DEBUG;
1512 g_dragMgr.ResetAnimationParameter();
1513 g_dragMgr.ResetDragState();
1514 int32_t ret = g_dragMgr.PerformInternalDropAnimation();
1515 ASSERT_EQ(ret, RET_ERR);
1516 }
1517
1518 /**
1519 * @tc.name: DragManagerTest75
1520 * @tc.desc: Drag Drawing
1521 * @tc.type: FUNC
1522 * @tc.require:
1523 */
1524 HWTEST_F(DragManagerTest, DragManagerTest75, TestSize.Level0)
1525 {
1526 CALL_TEST_DEBUG;
1527 g_dragMgr.ResetAnimationParameter();
1528 g_dragMgr.ResetDragState();
1529 std::string animationInfo = "{\"targetPos\": [100, 100]}";
1530 int32_t ret = InteractionManager::GetInstance()->EnableInternalDropAnimation(animationInfo);
1531 EXPECT_EQ(ret, RET_OK);
1532 ret = g_dragMgr.PerformInternalDropAnimation();
1533 ASSERT_EQ(ret, RET_ERR);
1534 }
1535
1536 /**
1537 * @tc.name: DragManagerTest76
1538 * @tc.desc: Drag Drawing
1539 * @tc.type: FUNC
1540 * @tc.require:
1541 */
1542 HWTEST_F(DragManagerTest, DragManagerTest76, TestSize.Level0)
1543 {
1544 CALL_TEST_DEBUG;
1545 bool hasCustomAnimation = true;
1546 DragData dragData;
1547 dragData.dragNum = 1;
1548 DRAG_DATA_MGR.Init(dragData);
1549 g_dragMgr.enableInternalDropAnimation_ = true;
1550 int32_t ret = g_dragMgr.HandleDragSuccess(hasCustomAnimation);
1551 EXPECT_EQ(ret, RET_OK);
1552 g_dragMgr.enableInternalDropAnimation_ = false;
1553 }
1554
1555 /**
1556 * @tc.name: DragManagerTest77
1557 * @tc.desc: Drag Drawing
1558 * @tc.type: FUNC
1559 * @tc.require:
1560 */
1561 HWTEST_F(DragManagerTest, DragManagerTest77, TestSize.Level0)
1562 {
1563 CALL_TEST_DEBUG;
1564 bool hasCustomAnimation = true;
1565 DragData dragData;
1566 dragData.dragNum = 1;
1567 DRAG_DATA_MGR.Init(dragData);
1568 g_dragMgr.enableInternalDropAnimation_ = true;
1569 int32_t ret = g_dragMgr.HandleDragSuccess(hasCustomAnimation);
1570 EXPECT_EQ(ret, RET_OK);
1571 std::string animationInfo = "{\"targetPos\": [-1, -1]}";
1572 ret = InteractionManager::GetInstance()->EnableInternalDropAnimation(animationInfo);
1573 EXPECT_EQ(ret, RET_OK);
1574 ret = g_dragMgr.HandleDragSuccess(hasCustomAnimation);
1575 EXPECT_EQ(ret, RET_OK);
1576 g_dragMgr.enableInternalDropAnimation_ = false;
1577 }
1578
1579 /**
1580 * @tc.name: DragManagerTest78
1581 * @tc.desc: Drag Drawing
1582 * @tc.type: FUNC
1583 * @tc.require:
1584 */
1585 HWTEST_F(DragManagerTest, DragManagerTest78, TestSize.Level0)
1586 {
1587 CALL_TEST_DEBUG;
1588 bool hasCustomAnimation = true;
1589 DragData dragData;
1590 dragData.dragNum = 0;
1591 DRAG_DATA_MGR.Init(dragData);
1592 g_dragMgr.enableInternalDropAnimation_ = true;
1593 int32_t ret = g_dragMgr.HandleDragSuccess(hasCustomAnimation);
1594 EXPECT_EQ(ret, RET_OK);
1595 g_dragMgr.enableInternalDropAnimation_ = false;
1596 }
1597
1598 /**
1599 * @tc.name: DragManagerTest79
1600 * @tc.desc: Drag Drawing
1601 * @tc.type: FUNC
1602 * @tc.require:
1603 */
1604 HWTEST_F(DragManagerTest, DragManagerTest79, TestSize.Level0)
1605 {
1606 CALL_TEST_DEBUG;
1607 bool hasCustomAnimation = false;
1608 DragData dragData;
1609 dragData.dragNum = 0;
1610 DRAG_DATA_MGR.Init(dragData);
1611 g_dragMgr.enableInternalDropAnimation_ = true;
1612 int32_t ret = g_dragMgr.HandleDragSuccess(hasCustomAnimation);
1613 EXPECT_EQ(ret, RET_ERR);
1614 g_dragMgr.enableInternalDropAnimation_ = false;
1615 }
1616
1617 /**
1618 * @tc.name: DragManagerTest80
1619 * @tc.desc: Drag Drawing
1620 * @tc.type: FUNC
1621 * @tc.require:
1622 */
1623 HWTEST_F(DragManagerTest, DragManagerTest80, TestSize.Level0)
1624 {
1625 CALL_TEST_DEBUG;
1626 DragResult result = DragResult::DRAG_SUCCESS;
1627 bool hasCustomAnimation = false;
1628 DragData dragData;
1629 dragData.dragNum = 1;
1630 DRAG_DATA_MGR.Init(dragData);
1631 g_dragMgr.enableInternalDropAnimation_ = true;
1632 int32_t ret = g_dragMgr.HandleDragResult(result, hasCustomAnimation);
1633 EXPECT_EQ(ret, RET_ERR);
1634 g_dragMgr.enableInternalDropAnimation_ = false;
1635 }
1636
1637 /**
1638 * @tc.name: DragManagerTest81
1639 * @tc.desc: Drag Drawing
1640 * @tc.type: FUNC
1641 * @tc.require:
1642 */
1643 HWTEST_F(DragManagerTest, DragManagerTest81, TestSize.Level0)
1644 {
1645 CALL_TEST_DEBUG;
1646 DragResult result = DragResult::DRAG_SUCCESS;
1647 bool hasCustomAnimation = false;
1648 DragData dragData;
1649 dragData.dragNum = 0;
1650 DRAG_DATA_MGR.Init(dragData);
1651 g_dragMgr.enableInternalDropAnimation_ = true;
1652 int32_t ret = g_dragMgr.HandleDragResult(result, hasCustomAnimation);
1653 EXPECT_EQ(ret, RET_ERR);
1654 g_dragMgr.enableInternalDropAnimation_ = false;
1655 }
1656
1657 /**
1658 * @tc.name: DragManagerTest82
1659 * @tc.desc: Drag Drawing
1660 * @tc.type: FUNC
1661 * @tc.require:
1662 */
1663 HWTEST_F(DragManagerTest, DragManagerTest82, TestSize.Level0)
1664 {
1665 CALL_TEST_DEBUG;
1666 DragResult result = DragResult::DRAG_FAIL;
1667 bool hasCustomAnimation = false;
1668 int32_t ret = g_dragMgr.HandleDragResult(result, hasCustomAnimation);
1669 EXPECT_EQ(ret, RET_OK);
1670 }
1671
1672 /**
1673 * @tc.name: DragManagerTest83
1674 * @tc.desc: Drag Drawing
1675 * @tc.type: FUNC
1676 * @tc.require:
1677 */
1678 HWTEST_F(DragManagerTest, DragManagerTest83, TestSize.Level0)
1679 {
1680 CALL_TEST_DEBUG;
1681 DragResult result = DragResult::DRAG_EXCEPTION;
1682 bool hasCustomAnimation = false;
1683 int32_t ret = g_dragMgr.HandleDragResult(result, hasCustomAnimation);
1684 EXPECT_EQ(ret, RET_OK);
1685 }
1686
1687 /**
1688 * @tc.name: DragManagerTest84
1689 * @tc.desc: Drag Drawing
1690 * @tc.type: FUNC
1691 * @tc.require:
1692 */
1693 HWTEST_F(DragManagerTest, DragManagerTest84, TestSize.Level0)
1694 {
1695 CALL_TEST_DEBUG;
1696 DragResult result = DragResult::DRAG_SUCCESS;
1697 bool hasCustomAnimation = false;
1698 DragData dragData;
1699 dragData.dragNum = 0;
1700 DRAG_DATA_MGR.Init(dragData);
1701 g_dragMgr.enableInternalDropAnimation_ = false;
1702 int32_t ret = g_dragMgr.HandleDragResult(result, hasCustomAnimation);
1703 EXPECT_EQ(ret, RET_OK);
1704 }
1705
1706 /**
1707 * @tc.name: DragManagerTest85
1708 * @tc.desc: Drag Drawing
1709 * @tc.type: FUNC
1710 * @tc.require:
1711 */
1712 HWTEST_F(DragManagerTest, DragManagerTest85, TestSize.Level0)
1713 {
1714 CALL_TEST_DEBUG;
1715 g_dragMgr.dragDrawing_.InitCanvas(100, 100);
1716 ASSERT_NO_FATAL_FAILURE(g_dragMgr.dragDrawing_.RemoveStyleNodeAnimations());
1717 }
1718
1719 /**
1720 * @tc.name: DragManagerTest86
1721 * @tc.desc: Drag Drawing
1722 * @tc.type: FUNC
1723 * @tc.require:
1724 */
1725 HWTEST_F(DragManagerTest, DragManagerTest86, TestSize.Level0)
1726 {
1727 CALL_TEST_DEBUG;
1728 g_dragMgr.dragDrawing_.InitCanvas(100, 100);
1729 g_dragMgr.dragDrawing_.drawStyleScaleModifier_ = std::make_shared<DrawStyleScaleModifier>();
1730 ASSERT_NO_FATAL_FAILURE(g_dragMgr.dragDrawing_.RemoveStyleNodeAnimations());
1731 }
1732
1733 /**
1734 * @tc.name: DragManagerTest87
1735 * @tc.desc: Drag Drawing
1736 * @tc.type: FUNC
1737 * @tc.require:
1738 */
1739 HWTEST_F(DragManagerTest, DragManagerTest87, TestSize.Level0)
1740 {
1741 CALL_TEST_DEBUG;
1742 g_dragMgr.dragDrawing_.InitCanvas(100, 100);
1743 g_dragMgr.dragDrawing_.drawStyleScaleModifier_ = std::make_shared<DrawStyleScaleModifier>();
1744 ASSERT_NO_FATAL_FAILURE(g_dragMgr.dragDrawing_.RemoveStyleNodeAnimations());
1745 }
1746
1747 /**
1748 * @tc.name: DragManagerTest88
1749 * @tc.desc: Drag Drawing
1750 * @tc.type: FUNC
1751 * @tc.require:
1752 */
1753 HWTEST_F(DragManagerTest, DragManagerTest88, TestSize.Level0)
1754 {
1755 CALL_TEST_DEBUG;
1756 std::promise<bool> promiseFlag;
1757 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b1802(const DragNotifyMsg ¬ifyMessage) 1758 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
1759 FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1760 notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1761 promiseFlag.set_value(true);
1762 };
1763 std::optional<DragData> dragData = CreateDragData(
1764 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
1765 EXPECT_TRUE(dragData);
1766 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1767 std::make_shared<TestStartDragListener>(callback));
1768 ASSERT_EQ(ret, RET_OK);
1769 std::string animationInfo = "{\"targetPos\": [200, 1000]}";
1770 ret = InteractionManager::GetInstance()->EnableInternalDropAnimation(animationInfo);
1771 EXPECT_EQ(ret, RET_OK);
1772 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
1773 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
1774 InteractionManager::GetInstance()->StopDrag(dropResult);
1775 std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_INTERNAL_DROP_ANIMATION));
1776 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1777 std::future_status::timeout);
1778 }
1779 #endif // OHOS_BUILD_INTERNAL_DROP_ANIMATION
1780
1781 /**
1782 * @tc.name: DragManagerTest89
1783 * @tc.desc: Drag Drawing
1784 * @tc.type: FUNC
1785 * @tc.require:
1786 */
1787 HWTEST_F(DragManagerTest, DragManagerTest89, TestSize.Level0)
1788 {
1789 CALL_TEST_DEBUG;
1790 std::promise<bool> promiseFlag;
1791 std::future<bool> futureFlag = promiseFlag.get_future();
__anon73fbce6b1902(const DragNotifyMsg ¬ifyMessage) 1792 auto callback = [&promiseFlag](const DragNotifyMsg ¬ifyMessage) {
1793 promiseFlag.set_value(true);
1794 };
1795 std::optional<DragData> dragData = CreateDragData(
1796 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
1797 EXPECT_TRUE(dragData);
1798 dragData.value().summaryFormat = { { "image", { 0, 1 } } };
1799 dragData.value().summaryTotalSize = 100;
1800 int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1801 std::make_shared<TestStartDragListener>(callback));
1802 ASSERT_EQ(ret, RET_OK);
1803 DragSummaryInfo dragSummaryInfo;
1804 ret = InteractionManager::GetInstance()->GetDragSummaryInfo(dragSummaryInfo);
1805 ASSERT_EQ(ret, RET_OK);
1806 ASSERT_EQ(dragSummaryInfo.totalSize, 100);
1807 DragDropResult dropResult { DragResult::DRAG_SUCCESS,
1808 HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
1809 InteractionManager::GetInstance()->StopDrag(dropResult);
1810 EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1811 std::future_status::timeout);
1812 }
1813
1814 /**
1815 * @tc.name: DragManagerTest90
1816 * @tc.desc: Drag Drawing
1817 * @tc.type: FUNC
1818 * @tc.require:
1819 */
1820 HWTEST_F(DragManagerTest, DragManagerTest90, TestSize.Level0)
1821 {
1822 CALL_TEST_DEBUG;
1823 DragSummaryInfo dragSummaryInfo;
1824 int32_t ret = InteractionManager::GetInstance()->GetDragSummaryInfo(dragSummaryInfo);
1825 ASSERT_EQ(ret, RET_ERR);
1826 }
1827
1828 /**
1829 * @tc.name: DragManagerTest91
1830 * @tc.desc: Drag Drawing
1831 * @tc.type: FUNC
1832 * @tc.require:
1833 */
1834 HWTEST_F(DragManagerTest, DragManagerTest91, TestSize.Level0)
1835 {
1836 CALL_TEST_DEBUG;
1837 DragSummaryInfo dragSummaryInfo;
1838 int32_t ret = g_dragMgr.GetDragSummaryInfo(dragSummaryInfo);
1839 ASSERT_EQ(ret, RET_ERR);
1840 }
1841
1842 /**
1843 * @tc.name: DragManagerTest92
1844 * @tc.desc: Drag Drawing
1845 * @tc.type: FUNC
1846 * @tc.require:
1847 */
1848 HWTEST_F(DragManagerTest, DragManagerTest92, TestSize.Level0)
1849 {
1850 CALL_TEST_DEBUG;
1851 g_dragMgr.dragState_ = DragState::START;
1852 DragData dragData;
1853 dragData.summaryFormat = { { "image", { 0, 1 } } };
1854 DRAG_DATA_MGR.Init(dragData);
1855 DragSummaryInfo dragSummaryInfo;
1856 int32_t ret = g_dragMgr.GetDragSummaryInfo(dragSummaryInfo);
1857 ASSERT_EQ(ret, RET_OK);
1858 g_dragMgr.dragState_ = DragState::STOP;
1859 }
1860
1861 /**
1862 * @tc.name: DragManagerTest93
1863 * @tc.desc: Drag Drawing
1864 * @tc.type: FUNC
1865 * @tc.require:
1866 */
1867 HWTEST_F(DragManagerTest, DragManagerTest93, TestSize.Level0)
1868 {
1869 CALL_TEST_DEBUG;
1870 g_dragMgr.dragState_ = DragState::MOTION_DRAGGING;
1871 DragData dragData;
1872 dragData.summaryFormat = { { "image", {} } };
1873 DRAG_DATA_MGR.Init(dragData);
1874 DragSummaryInfo dragSummaryInfo;
1875 int32_t ret = g_dragMgr.GetDragSummaryInfo(dragSummaryInfo);
1876 ASSERT_EQ(ret, RET_OK);
1877 g_dragMgr.dragState_ = DragState::STOP;
1878 }
1879
1880 /**
1881 * @tc.name: DragManagerTest94
1882 * @tc.desc: Drag Drawing
1883 * @tc.type: FUNC
1884 * @tc.require:
1885 */
1886 HWTEST_F(DragManagerTest, DragManagerTest94, TestSize.Level0)
1887 {
1888 CALL_TEST_DEBUG;
1889 DragData dragData;
1890 const std::string udType = "general.message";
1891 constexpr int64_t recordSize = 20;
1892 std::map<std::string, int64_t> summarys = { { udType, recordSize } };
1893 dragData.detailedSummarys = summarys;
1894 dragData.summaryFormat = { { "image", { 0, 1 } } };
1895 ASSERT_NO_FATAL_FAILURE(g_dragMgr.PrintDragData(dragData, ""));
1896 }
1897
1898 /**
1899 * @tc.name: DragManagerTest95
1900 * @tc.desc: Drag Drawing
1901 * @tc.type: FUNC
1902 * @tc.require:
1903 */
1904 HWTEST_F(DragManagerTest, DragManagerTest95, TestSize.Level0)
1905 {
1906 CALL_TEST_DEBUG;
1907 DragData dragData;
1908 const std::string udType = "general.message";
1909 constexpr int64_t recordSize = 20;
1910 std::map<std::string, int64_t> summarys = { { udType, recordSize } };
1911 dragData.detailedSummarys = summarys;
1912 dragData.summaryFormat = { { "image", {} } };
1913 ASSERT_NO_FATAL_FAILURE(g_dragMgr.PrintDragData(dragData, ""));
1914 }
1915
1916 #ifndef OHOS_BUILD_ENABLE_ARKUI_X
1917 /**
1918 * @tc.name: DragManagerTest96
1919 * @tc.desc: Drag Drawing
1920 * @tc.type: FUNC
1921 * @tc.require:
1922 */
1923 HWTEST_F(DragManagerTest, DragManagerTest96, TestSize.Level0)
1924 {
1925 CALL_TEST_DEBUG;
1926 std::string persistLanguage = system::GetParameter("persist.global.language", "");
1927 bool isRTL = g_dragMgr.isRTL_;
1928 system::SetParameter("persist.global.language", "");
1929 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1930 system::SetParameter("persist.global.language", "ch");
1931 g_dragMgr.isRTL_ = true;
1932 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1933 g_dragMgr.isRTL_ = false;
1934 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1935 system::SetParameter("persist.global.language", "ar");
1936 g_dragMgr.isRTL_ = false;
1937 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1938 g_dragMgr.isRTL_ = true;
1939 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1940 system::SetParameter("persist.global.language", "fa");
1941 g_dragMgr.isRTL_ = false;
1942 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1943 g_dragMgr.isRTL_ = true;
1944 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1945 system::SetParameter("persist.global.language", "ur");
1946 g_dragMgr.isRTL_ = false;
1947 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1948 g_dragMgr.isRTL_ = true;
1949 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1950 system::SetParameter("persist.global.language", "he");
1951 g_dragMgr.isRTL_ = false;
1952 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1953 g_dragMgr.isRTL_ = true;
1954 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1955 system::SetParameter("persist.global.language", "ug");
1956 g_dragMgr.isRTL_ = false;
1957 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1958 g_dragMgr.isRTL_ = true;
1959 ASSERT_NO_FATAL_FAILURE(g_dragMgr.UpdateDragStylePositon());
1960 g_dragMgr.isRTL_ = isRTL;
1961 }
1962 #endif // OHOS_BUILD_ENABLE_ARKUI_X
1963
1964 #ifdef OHOS_BUILD_INTERNAL_DROP_ANIMATION
1965 /**
1966 * @tc.name: DragManagerTest97
1967 * @tc.desc: Drag Drawing
1968 * @tc.type: FUNC
1969 * @tc.require:
1970 */
1971 HWTEST_F(DragManagerTest, DragManagerTest97, TestSize.Level0)
1972 {
1973 CALL_TEST_DEBUG;
1974 g_dragMgr.ResetAnimationParameter();
1975 g_dragMgr.ResetDragState();
1976 std::string animationInfo = "{\"targetPos\": [100, 100]}";
1977 int32_t ret = InteractionManager::GetInstance()->EnableInternalDropAnimation(animationInfo);
1978 EXPECT_EQ(ret, RET_OK);
1979 g_dragMgr.context_ = g_context;
1980 ret = g_dragMgr.PerformInternalDropAnimation();
1981 g_dragMgr.context_ = nullptr;
1982 g_dragMgr.internalDropTimerId_ = 0;
1983 ret = g_dragMgr.PerformInternalDropAnimation();
1984 g_dragMgr.context_ = nullptr;
1985 g_dragMgr.internalDropTimerId_ = -1;
1986 ret = g_dragMgr.PerformInternalDropAnimation();
1987 ASSERT_EQ(ret, RET_ERR);
1988 }
1989
1990 /**
1991 * @tc.name: DragManagerTest98
1992 * @tc.desc: Drag Drawing
1993 * @tc.type: FUNC
1994 * @tc.require:
1995 */
1996 HWTEST_F(DragManagerTest, DragManagerTest98, TestSize.Level0)
1997 {
1998 CALL_TEST_DEBUG;
1999 g_dragMgr.context_ = g_context;
2000 g_dragMgr.internalDropTimerId_ = 0;
2001 g_dragMgr.ResetDragState();
2002 g_dragMgr.internalDropTimerId_ = -1;
2003 g_dragMgr.ResetDragState();
2004 g_dragMgr.context_ = nullptr;
2005 g_dragMgr.internalDropTimerId_ = 0;
2006 g_dragMgr.ResetDragState();
2007 g_dragMgr.context_ = nullptr;
2008 g_dragMgr.internalDropTimerId_ = -1;
2009 g_dragMgr.ResetDragState();
2010 std::string animationInfo = "{\"targetPos\": [100, 100]}";
2011 int32_t ret = InteractionManager::GetInstance()->EnableInternalDropAnimation(animationInfo);
2012 EXPECT_EQ(ret, RET_OK);
2013 }
2014 #endif // OHOS_BUILD_INTERNAL_DROP_ANIMATION
2015 } // namespace DeviceStatus
2016 } // namespace Msdp
2017 } // namespace OHOS
2018