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 #define BUFF_SIZE 100
16 #include <future>
17 #include "pointer_event.h"
18 #include "securec.h"
19 #include "message_parcel.h"
20 
21 #include "drag_manager_test.h"
22 #include "drag_params.h"
23 #include "devicestatus_errors.h"
24 #include "interaction_manager.h"
25 #include "stationary_data.h"
26 
27 namespace OHOS {
28 namespace Msdp {
29 namespace DeviceStatus {
30 using namespace testing::ext;
31 namespace {
32 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
33 constexpr uint32_t DEFAULT_ICON_COLOR { 0xFF };
34 constexpr int32_t PIXEL_MAP_HEIGHT { 3 };
35 constexpr int32_t PIXEL_MAP_WIDTH { 3 };
36 constexpr int32_t MAX_PIXEL_MAP_WIDTH { 600 };
37 constexpr int32_t MAX_PIXEL_MAP_HEIGHT { 600 };
38 constexpr int32_t POINTER_ID { 0 };
39 constexpr int32_t DISPLAY_X { 50 };
40 constexpr int32_t DISPLAY_ID { 0 };
41 constexpr int32_t DISPLAY_Y { 50 };
42 constexpr int32_t DRAG_NUM_ONE { 1 };
43 constexpr int32_t INT32_BYTE { 4 };
44 constexpr int32_t PROMISE_WAIT_SPAN_MS { 2000 };
45 constexpr int32_t FOREGROUND_COLOR_IN { 0x33FF0000 };
46 constexpr int32_t FOREGROUND_COLOR_OUT { 0x00000000 };
47 int32_t g_shadowinfo_x { 0 };
48 int32_t g_shadowinfo_y { 0 };
49 constexpr int32_t WINDOW_ID { -1 };
50 constexpr int32_t ANIMATION_DURATION { 500 };
51 const std::string CURVE_NAME { "cubic-bezier" };
52 constexpr bool HAS_CUSTOM_ANIMATION { true };
53 constexpr int32_t TARGET_MAIN_WINDOW { 0 };
54 constexpr bool HAS_CANCELED_ANIMATION { true };
55 const std::string UD_KEY { "Unified data key" };
56 const std::string FILTER_INFO { "Undefined filter info" };
57 const std::string EXTRA_INFO { "Undefined extra info" };
58 constexpr int32_t SHADOW_NUM_ONE { 1 };
59 } // namespace
60 
SetUpTestCase()61 void DragManagerTest::SetUpTestCase() {}
62 
SetUp()63 void DragManagerTest::SetUp() {
64 }
65 
TearDown()66 void DragManagerTest::TearDown()
67 {
68     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
69 }
70 
CreatePixelMap(int32_t width,int32_t height)71 std::shared_ptr<Media::PixelMap> DragManagerTest::CreatePixelMap(int32_t width, int32_t height)
72 {
73     CALL_DEBUG_ENTER;
74     if (width <= 0 || width > MAX_PIXEL_MAP_WIDTH || height <= 0 || height > MAX_PIXEL_MAP_HEIGHT) {
75         FI_HILOGE("invalid, height:%{public}d, width:%{public}d", height, width);
76         return nullptr;
77     }
78     Media::InitializationOptions opts;
79     opts.size.width = width;
80     opts.size.height = height;
81     opts.pixelFormat = Media::PixelFormat::BGRA_8888;
82     opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
83     opts.scaleMode = Media::ScaleMode::FIT_TARGET_SIZE;
84 
85     int32_t colorLen = width * height;
86     uint32_t *pixelColors = new (std::nothrow) uint32_t[BUFF_SIZE];
87     CHKPP(pixelColors);
88     int32_t colorByteCount = colorLen * INT32_BYTE;
89     errno_t ret = memset_s(pixelColors, BUFF_SIZE, DEFAULT_ICON_COLOR, colorByteCount);
90     if (ret != EOK) {
91         FI_HILOGE("memset_s failed");
92         delete[] pixelColors;
93         return nullptr;
94     }
95     std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(pixelColors, colorLen, opts);
96     if (pixelMap == nullptr) {
97         FI_HILOGE("Create pixelMap failed");
98         delete[] pixelColors;
99         return nullptr;
100     }
101     delete[] pixelColors;
102     return pixelMap;
103 }
104 
CreateDragData(int32_t sourceType,int32_t pointerId,int32_t dragNum,bool hasCoordinateCorrected,int32_t shadowNum)105 std::optional<DragData> DragManagerTest::CreateDragData(int32_t sourceType,
106     int32_t pointerId, int32_t dragNum, bool hasCoordinateCorrected, int32_t shadowNum)
107 {
108     CALL_DEBUG_ENTER;
109     DragData dragData;
110     for (int32_t i = 0; i < shadowNum; i++) {
111         std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(PIXEL_MAP_WIDTH, PIXEL_MAP_HEIGHT);
112         if (pixelMap == nullptr) {
113             FI_HILOGE("pixelMap nullptr");
114             return std::nullopt;
115         }
116         dragData.shadowInfos.push_back({ pixelMap, g_shadowinfo_x, g_shadowinfo_y });
117     }
118     dragData.buffer = std::vector<uint8_t>(MAX_BUFFER_SIZE, 0);
119     dragData.extraInfo = FILTER_INFO;
120     dragData.udKey = UD_KEY;
121     dragData.sourceType = sourceType;
122     dragData.extraInfo = EXTRA_INFO;
123     dragData.displayId = DISPLAY_ID;
124     dragData.pointerId = pointerId;
125     dragData.dragNum = dragNum;
126     dragData.displayX = DISPLAY_X;
127     dragData.displayY = DISPLAY_Y;
128     dragData.hasCoordinateCorrected = hasCoordinateCorrected;
129     dragData.hasCanceledAnimation = HAS_CANCELED_ANIMATION;
130     return dragData;
131 }
132 
133 class TestStartDragListener : public IStartDragListener {
134 public:
TestStartDragListener(std::function<void (const DragNotifyMsg &)> function)135     explicit TestStartDragListener(std::function<void(const DragNotifyMsg&)> function) : function_(function) { }
OnDragEndMessage(const DragNotifyMsg & msg)136     void OnDragEndMessage(const DragNotifyMsg &msg) override
137     {
138         FI_HILOGD("DisplayX:%{public}d, displayY:%{public}d, targetPid:%{public}d, result:%{public}d",
139             msg.displayX, msg.displayY, msg.targetPid, static_cast<int32_t>(msg.result));
140         if (function_ != nullptr) {
141             function_(msg);
142         }
143         FI_HILOGD("Test OnDragEndMessage");
144     }
145 
OnHideIconMessage()146     void OnHideIconMessage() override
147     {
148         FI_HILOGD("Test OnHideIconMessage");
149     }
150 private:
151     std::function<void(const DragNotifyMsg&)> function_;
152 };
153 
154 class DragListenerTest : public IDragListener {
155 public:
DragListenerTest()156     DragListenerTest() {}
DragListenerTest(const std::string & name)157     explicit DragListenerTest(const std::string& name) : moduleName_(name) {}
OnDragMessage(DragState state)158     void OnDragMessage(DragState state) override
159     {
160         if (moduleName_.empty()) {
161             moduleName_ = std::string("DragListenerTest");
162         }
163         FI_HILOGD("%{public}s, state:%{public}s", moduleName_.c_str(), PrintDragMessage(state).c_str());
164     }
165 private:
PrintDragMessage(DragState state)166     std::string PrintDragMessage(DragState state)
167     {
168         std::string type = "unknow";
169         const std::map<DragState, std::string> stateType = {
170             { DragState::ERROR, "error"},
171             { DragState::START, "start"},
172             { DragState::STOP, "stop"},
173             { DragState::CANCEL, "cancel"}
174         };
175         auto item = stateType.find(state);
176         if (item != stateType.end()) {
177             type = item->second;
178         }
179         return type;
180     }
181 private:
182     std::string moduleName_;
183 };
184 
185 class SubscriptListenerTest : public ISubscriptListener {
186 public:
SubscriptListenerTest()187     SubscriptListenerTest() {}
SubscriptListenerTest(const std::string & name)188     explicit SubscriptListenerTest(const std::string& name) : moduleName_(name) {}
OnMessage(DragCursorStyle style)189     void OnMessage(DragCursorStyle style) override
190     {
191         SetDragSyle(style);
192         if (moduleName_.empty()) {
193             moduleName_ = std::string("SubscriptListenerTest");
194         }
195         FI_HILOGD("subscriptListener, %{public}s, state:%{public}s",
196             moduleName_.c_str(), PrintStyleMessage(style).c_str());
197     }
198 
GetDragStyle()199     DragCursorStyle GetDragStyle()
200     {
201         return dragStyle_;
202     }
203 
204 private:
SetDragSyle(DragCursorStyle style)205     void SetDragSyle(DragCursorStyle style)
206     {
207         dragStyle_ = style;
208     }
209 
PrintStyleMessage(DragCursorStyle style)210     std::string PrintStyleMessage(DragCursorStyle style)
211     {
212         std::string type = "unknow";
213         const std::map<DragCursorStyle, std::string> cursorStyles = {
214             { DragCursorStyle::DEFAULT, "default"},
215             { DragCursorStyle::FORBIDDEN, "forbidden"},
216             { DragCursorStyle::COPY, "copy"},
217             { DragCursorStyle::MOVE, "move"}
218         };
219         auto item = cursorStyles.find(style);
220         if (item != cursorStyles.end()) {
221             type = item->second;
222         }
223         return type;
224     }
225 
226 private:
227     DragCursorStyle dragStyle_ { DragCursorStyle::DEFAULT };
228     std::string moduleName_;
229 };
230 
AssignToAnimation(PreviewAnimation & animation)231 void DragManagerTest::AssignToAnimation(PreviewAnimation &animation)
232 {
233     animation.duration = ANIMATION_DURATION;
234     animation.curveName = CURVE_NAME;
235     animation.curve = { 0.33, 0, 0.67, 1 };
236 }
237 
238 /**
239  * @tc.name: DragManagerTest1
240  * @tc.desc: Drag Drawing
241  * @tc.type: FUNC
242  * @tc.require:
243  */
244 HWTEST_F(DragManagerTest, DragManagerTest1, TestSize.Level0)
245 {
246     CALL_TEST_DEBUG;
247     std::optional<DragData> dragData = CreateDragData(
248         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
249     EXPECT_TRUE(dragData);
250     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(), nullptr);
251     ASSERT_EQ(ret, RET_ERR);
252 }
253 
254 /**
255  * @tc.name: DragManagerTest2
256  * @tc.desc: Drag Drawing
257  * @tc.type: FUNC
258  * @tc.require:
259  */
260 HWTEST_F(DragManagerTest, DragManagerTest2, TestSize.Level0)
261 {
262     CALL_TEST_DEBUG;
263     std::promise<bool> promiseFlag;
__anoneac400010202(const DragNotifyMsg &notifyMessage) 264     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
265         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
266             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
267         promiseFlag.set_value(true);
268     };
269     std::optional<DragData> dragData = CreateDragData(
270         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_ONE, false, 0);
271     EXPECT_TRUE(dragData);
272     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
273         std::make_shared<TestStartDragListener>(callback));
274     ASSERT_EQ(ret, ERR_INVALID_VALUE);
275 }
276 
277 /**
278  * @tc.name: DragManagerTest3
279  * @tc.desc: Drag Drawing
280  * @tc.type: FUNC
281  * @tc.require:
282  */
283 HWTEST_F(DragManagerTest, DragManagerTest3, TestSize.Level0)
284 {
285     CALL_TEST_DEBUG;
286     std::promise<bool> promiseFlag;
287     g_shadowinfo_x = 2;
__anoneac400010302(const DragNotifyMsg &notifyMessage) 288     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
289         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
290             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
291         promiseFlag.set_value(true);
292     };
293     std::optional<DragData> dragData = CreateDragData(
294         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
295     EXPECT_TRUE(dragData);
296     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
297         std::make_shared<TestStartDragListener>(callback));
298     ASSERT_EQ(ret, RET_ERR);
299 }
300 
301 /**
302  * @tc.name: DragManagerTest4
303  * @tc.desc: Drag Drawing
304  * @tc.type: FUNC
305  * @tc.require:
306  */
307 HWTEST_F(DragManagerTest, DragManagerTest4, TestSize.Level0)
308 {
309     CALL_TEST_DEBUG;
310     g_shadowinfo_x = 0;
311     std::promise<bool> promiseFlag;
__anoneac400010402(const DragNotifyMsg &notifyMessage) 312     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
313         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
314             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
315         promiseFlag.set_value(true);
316     };
317     std::optional<DragData> dragData = CreateDragData(
318         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, -1, false, SHADOW_NUM_ONE);
319     EXPECT_TRUE(dragData);
320     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
321         std::make_shared<TestStartDragListener>(callback));
322     ASSERT_EQ(ret, RET_ERR);
323 }
324 
325 /**
326  * @tc.name: DragManagerTest5
327  * @tc.desc: Drag Drawing
328  * @tc.type: FUNC
329  * @tc.require:
330  */
331 HWTEST_F(DragManagerTest, DragManagerTest5, TestSize.Level0)
332 {
333     CALL_TEST_DEBUG;
334     int32_t ret = InteractionManager::GetInstance()->AddDraglistener(nullptr);
335     ASSERT_EQ(ret, RET_ERR);
336     ret = InteractionManager::GetInstance()->RemoveDraglistener(nullptr);
337     ASSERT_EQ(ret, RET_OK);
338 }
339 
340 /**
341  * @tc.name: DragManagerTest6
342  * @tc.desc: Drag Drawing
343  * @tc.type: FUNC
344  * @tc.require:
345  */
346 HWTEST_F(DragManagerTest, DragManagerTest6, TestSize.Level0)
347 {
348     CALL_TEST_DEBUG;
349     auto listener = std::make_shared<DragListenerTest>(std::string("Draglistener_Mouse"));
350     int32_t ret = InteractionManager::GetInstance()->AddDraglistener(listener);
351     ASSERT_EQ(ret, RET_OK);
352 }
353 
354 /**
355  * @tc.name: DragManagerTest7
356  * @tc.desc: Drag Drawing
357  * @tc.type: FUNC
358  * @tc.require:
359  */
360 HWTEST_F(DragManagerTest, DragManagerTest7, TestSize.Level0)
361 {
362     CALL_TEST_DEBUG;
363     int32_t ret = InteractionManager::GetInstance()->AddSubscriptListener(nullptr);
364     ASSERT_EQ(ret, RET_ERR);
365 }
366 
367 /**
368  * @tc.name: DragManagerTest8
369  * @tc.desc: Drag Drawing
370  * @tc.type: FUNC
371  * @tc.require:
372  */
373 HWTEST_F(DragManagerTest, DragManagerTest8, TestSize.Level0)
374 {
375     CALL_TEST_DEBUG;
376     auto listener = std::make_shared<SubscriptListenerTest>("SubscriptListener");
377     int32_t ret = InteractionManager::GetInstance()->AddSubscriptListener(listener);
378     ASSERT_EQ(ret, RET_OK);
379 }
380 
381 /**
382  * @tc.name: DragManagerTest9
383  * @tc.desc: Drag Drawing
384  * @tc.type: FUNC
385  * @tc.require:
386  */
387 HWTEST_F(DragManagerTest, DragManagerTest9, TestSize.Level0)
388 {
389     CALL_TEST_DEBUG;
390     auto listener = std::make_shared<SubscriptListenerTest>("SubscriptListener");
391     int32_t ret = InteractionManager::GetInstance()->RemoveSubscriptListener(listener);
392     ASSERT_EQ(ret, RET_OK);
393 }
394 
395 /**
396  * @tc.name: DragManagerTest10
397  * @tc.desc: Drag Drawing
398  * @tc.type: FUNC
399  * @tc.require:
400  */
401 HWTEST_F(DragManagerTest, DragManagerTest10, TestSize.Level0)
402 {
403     CALL_TEST_DEBUG;
404     int32_t ret = InteractionManager::GetInstance()->RemoveSubscriptListener(nullptr);
405     ASSERT_EQ(ret, RET_OK);
406 }
407 
408 /**
409  * @tc.name: DragManagerTest11
410  * @tc.desc: Drag Drawing
411  * @tc.type: FUNC
412  * @tc.require:
413  */
414 HWTEST_F(DragManagerTest, DragManagerTest11, TestSize.Level0)
415 {
416     CALL_TEST_DEBUG;
417     int32_t ret = InteractionManager::GetInstance()->RemoveSubscriptListener(nullptr);
418     auto listener = std::make_shared<SubscriptListenerTest>("SubscriptListener");
419     ret = InteractionManager::GetInstance()->AddSubscriptListener(listener);
420     ret = InteractionManager::GetInstance()->RemoveSubscriptListener(nullptr);
421     ASSERT_EQ(ret, RET_OK);
422 }
423 
424 /**
425  * @tc.name: DragManagerTest12
426  * @tc.desc: Drag Drawing
427  * @tc.type: FUNC
428  * @tc.require:
429  */
430 HWTEST_F(DragManagerTest, DragManagerTest12, TestSize.Level0)
431 {
432     CALL_TEST_DEBUG;
433     int32_t ret = InteractionManager::GetInstance()->UpdateDragStyle(static_cast<DragCursorStyle>(-1));
434     ASSERT_EQ(ret, RET_ERR);
435 }
436 
437 /**
438  * @tc.name: DragManagerTest13
439  * @tc.desc: Drag Drawing
440  * @tc.type: FUNC
441  * @tc.require:
442  */
443 HWTEST_F(DragManagerTest, DragManagerTest13, TestSize.Level0)
444 {
445     CALL_TEST_DEBUG;
446     std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(PIXEL_MAP_WIDTH, PIXEL_MAP_HEIGHT);
447     ASSERT_NE(pixelMap, nullptr);
448     ShadowInfo shadowInfo = { pixelMap, 1, 0 };
449     int32_t ret = InteractionManager::GetInstance()->UpdateShadowPic(shadowInfo);
450     ASSERT_EQ(ret, RET_ERR);
451 }
452 
453 /**
454  * @tc.name: DragManagerTest14
455  * @tc.desc: Drag Drawing
456  * @tc.type: FUNC
457  * @tc.require:
458  */
459 HWTEST_F(DragManagerTest, DragManagerTest14, TestSize.Level0)
460 {
461     CALL_TEST_DEBUG;
462     std::optional<DragData> dragData = CreateDragData(
463         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
464     EXPECT_TRUE(dragData);
465     std::promise<bool> promiseFlag;
466     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400010502(const DragNotifyMsg &notifyMessage) 467     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
468         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
469             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
470         promiseFlag.set_value(true);
471     };
472     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
473         std::make_shared<TestStartDragListener>(callback));
474     ASSERT_EQ(ret, RET_OK);
475     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
476     std::vector<DragCursorStyle> dragCursorStyles = {DragCursorStyle::DEFAULT,
477         DragCursorStyle::FORBIDDEN, DragCursorStyle::COPY, DragCursorStyle::MOVE};
478     for (const auto& dragCursorStyle : dragCursorStyles) {
479         ret = InteractionManager::GetInstance()->UpdateDragStyle(dragCursorStyle);
480         ASSERT_EQ(ret, RET_OK);
481     }
482     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
483         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
484     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
485     ASSERT_EQ(ret, RET_OK);
486     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
487         std::future_status::timeout);
488 }
489 
490 /**
491  * @tc.name: DragManagerTest15
492  * @tc.desc: Drag Drawing
493  * @tc.type: FUNC
494  * @tc.require:
495  */
496 HWTEST_F(DragManagerTest, DragManagerTest15, TestSize.Level0)
497 {
498     CALL_TEST_DEBUG;
499     std::promise<bool> promiseFlag;
500     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400010602(const DragNotifyMsg &notifyMessage) 501     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
502         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
503             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
504         promiseFlag.set_value(true);
505     };
506     std::optional<DragData> dragData = CreateDragData(
507         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
508     EXPECT_TRUE(dragData);
509     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
510         std::make_shared<TestStartDragListener>(callback));
511     ASSERT_EQ(ret, RET_OK);
512     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
513     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
514         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
515     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
516     ASSERT_EQ(ret, RET_OK);
517     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
518         std::future_status::timeout);}
519 
520 /**
521  * @tc.name: DragManagerTest16
522  * @tc.desc: Drag Drawing
523  * @tc.type: FUNC
524  * @tc.require:
525  */
526 HWTEST_F(DragManagerTest, DragManagerTest16, TestSize.Level0)
527 {
528     CALL_TEST_DEBUG;
529     std::promise<bool> promiseFlag;
530     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400010702(const DragNotifyMsg &notifyMessage) 531     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
532         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
533             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
534         promiseFlag.set_value(true);
535     };
536     std::optional<DragData> dragData = CreateDragData(
537         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
538     EXPECT_TRUE(dragData);
539     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
540         std::make_shared<TestStartDragListener>(callback));
541     ASSERT_EQ(ret, RET_OK);
542     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
543     std::string udKey;
544     ret = InteractionManager::GetInstance()->GetUdKey(udKey);
545     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
546         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
547     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
548     ASSERT_EQ(ret, RET_OK);
549     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
550         std::future_status::timeout);}
551 
552 /**
553  * @tc.name: DragManagerTest17
554  * @tc.desc: Drag Drawing
555  * @tc.type: FUNC
556  * @tc.require:
557  */
558 HWTEST_F(DragManagerTest, DragManagerTest17, TestSize.Level0)
559 {
560     CALL_TEST_DEBUG;
561     std::promise<bool> promiseFlag;
562     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400010802(const DragNotifyMsg &notifyMessage) 563     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
564         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
565             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
566         promiseFlag.set_value(true);
567     };
568     std::optional<DragData> dragData = CreateDragData(
569         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
570     EXPECT_TRUE(dragData);
571     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
572         std::make_shared<TestStartDragListener>(callback));
573     ASSERT_EQ(ret, RET_OK);
574     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
575     ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
576     ASSERT_EQ(ret, RET_OK);
577     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
578     ret = InteractionManager::GetInstance()->SetDragWindowVisible(false);
579     ASSERT_EQ(ret, RET_OK);
580     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
581     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
582         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
583     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
584     ASSERT_EQ(ret, RET_OK);
585     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
586         std::future_status::timeout);
587 }
588 
589 /**
590  * @tc.name: DragManagerTest18
591  * @tc.desc: Drag Drawing
592  * @tc.type: FUNC
593  * @tc.require:
594  */
595 HWTEST_F(DragManagerTest, DragManagerTest18, TestSize.Level0)
596 {
597     CALL_TEST_DEBUG;
598     int32_t offsetX = 0;
599     int32_t offsetY = 0;
600     int32_t width = 0;
601     int32_t height = 0;
602     std::promise<bool> promiseFlag;
603     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400010902(const DragNotifyMsg &notifyMessage) 604     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
605         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
606             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
607         promiseFlag.set_value(true);
608     };
609     std::optional<DragData> dragData = CreateDragData(
610         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
611     EXPECT_TRUE(dragData);
612     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
613         std::make_shared<TestStartDragListener>(callback));
614     ASSERT_EQ(ret, RET_OK);
615     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
616     ret = InteractionManager::GetInstance()->GetShadowOffset(offsetX, offsetY, width, height);
617     ASSERT_EQ(ret, RET_OK);
618     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
619     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
620         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
621     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
622     ASSERT_EQ(ret, RET_OK);
623     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
624         std::future_status::timeout);
625 }
626 
627 /**
628  * @tc.name: DragManagerTest19
629  * @tc.desc: Drag Drawing
630  * @tc.type: FUNC
631  * @tc.require:
632  */
633 HWTEST_F(DragManagerTest, DragManagerTest19, TestSize.Level0)
634 {
635     CALL_TEST_DEBUG;
636     std::promise<bool> promiseFlag;
637     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400010a02(const DragNotifyMsg &notifyMessage) 638     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
639         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
640             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
641         promiseFlag.set_value(true);
642     };
643     std::optional<DragData> dragData = CreateDragData(
644         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
645     EXPECT_TRUE(dragData);
646     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
647         std::make_shared<TestStartDragListener>(callback));
648     ASSERT_EQ(ret, RET_OK);
649     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
650     std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(PIXEL_MAP_WIDTH, PIXEL_MAP_HEIGHT);
651     ASSERT_NE(pixelMap, nullptr);
652     ShadowInfo shadowInfo = { pixelMap, 0, 0 };
653     ret = InteractionManager::GetInstance()->UpdateShadowPic(shadowInfo);
654     ASSERT_EQ(ret, RET_OK);
655     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
656     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
657         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
658     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
659     ASSERT_EQ(ret, RET_OK);
660     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
661         std::future_status::timeout);
662 }
663 
664 /**
665  * @tc.name: DragManagerTest20
666  * @tc.desc: Drag Drawing
667  * @tc.type: FUNC
668  * @tc.require:
669  */
670 HWTEST_F(DragManagerTest, DragManagerTest20, TestSize.Level0)
671 {
672     CALL_TEST_DEBUG;
673     std::promise<bool> promiseFlag;
674     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400010b02(const DragNotifyMsg &notifyMessage) 675     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
676         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
677             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
678         promiseFlag.set_value(true);
679     };
680     std::optional<DragData> dragData = CreateDragData(
681         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
682     EXPECT_TRUE(dragData);
683     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
684         std::make_shared<TestStartDragListener>(callback));
685     ASSERT_EQ(ret, RET_OK);
686     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
687     DragData replyDragData;
688     ret = InteractionManager::GetInstance()->GetDragData(replyDragData);
689     ASSERT_EQ(ret, RET_OK);
690     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
691     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
692         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
693     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
694     ASSERT_EQ(ret, RET_OK);
695     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
696         std::future_status::timeout);
697 }
698 
699 /**
700  * @tc.name: DragManagerTest21
701  * @tc.desc: Drag Drawing
702  * @tc.type: FUNC
703  * @tc.require:
704  */
705 HWTEST_F(DragManagerTest, DragManagerTest21, TestSize.Level0)
706 {
707     CALL_TEST_DEBUG;
708     std::promise<bool> promiseFlag;
709     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400010c02(const DragNotifyMsg &notifyMessage) 710     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
711         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
712             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
713         promiseFlag.set_value(true);
714     };
715     std::optional<DragData> dragData = CreateDragData(
716         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
717     EXPECT_TRUE(dragData);
718     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
719         std::make_shared<TestStartDragListener>(callback));
720     ASSERT_EQ(ret, RET_OK);
721     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
722     DragState dragState;
723     ret = InteractionManager::GetInstance()->GetDragState(dragState);
724     ASSERT_EQ(ret, RET_OK);
725     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
726     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
727         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
728     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
729     ASSERT_EQ(ret, RET_OK);
730     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
731         std::future_status::timeout);
732 }
733 
734 /**
735  * @tc.name: DragManagerTest22
736  * @tc.desc: Drag Drawing
737  * @tc.type: FUNC
738  * @tc.require:
739  */
740 HWTEST_F(DragManagerTest, DragManagerTest22, TestSize.Level0)
741 {
742     CALL_TEST_DEBUG;
743     std::promise<bool> promiseFlag;
744     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400010d02(const DragNotifyMsg &notifyMessage) 745     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
746         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
747             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
748         promiseFlag.set_value(true);
749     };
750     std::optional<DragData> dragData = CreateDragData(
751         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
752     EXPECT_TRUE(dragData);
753     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
754         std::make_shared<TestStartDragListener>(callback));
755     ASSERT_EQ(ret, RET_OK);
756     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
757     DragAction dragAction { DragAction::INVALID };
758     ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
759     ASSERT_EQ(ret, RET_OK);
760     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
761     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
762         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
763     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
764     ASSERT_EQ(ret, RET_OK);
765     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
766         std::future_status::timeout);
767 }
768 
769 /**
770  * @tc.name: DragManagerTest23
771  * @tc.desc: Drag Drawing
772  * @tc.type: FUNC
773  * @tc.require:
774  */
775 HWTEST_F(DragManagerTest, DragManagerTest23, TestSize.Level0)
776 {
777     CALL_TEST_DEBUG;
778     std::promise<bool> promiseFlag;
779     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400010e02(const DragNotifyMsg &notifyMessage) 780     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
781         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
782             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
783         promiseFlag.set_value(true);
784     };
785     std::optional<DragData> dragData = CreateDragData(
786         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
787     EXPECT_TRUE(dragData);
788     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
789         std::make_shared<TestStartDragListener>(callback));
790     ASSERT_EQ(ret, RET_OK);
791     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
792     std::string extraInfo;
793     ret = InteractionManager::GetInstance()->GetExtraInfo(extraInfo);
794     ASSERT_EQ(ret, RET_OK);
795     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
796     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
797         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
798     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
799     ASSERT_EQ(ret, RET_OK);
800     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
801         std::future_status::timeout);
802 }
803 
804 /**
805  * @tc.name: DragManagerTest24
806  * @tc.desc: Drag Drawing
807  * @tc.type: FUNC
808  * @tc.require:
809  */
810 HWTEST_F(DragManagerTest, DragManagerTest24, TestSize.Level0)
811 {
812     CALL_TEST_DEBUG;
813     std::promise<bool> promiseFlag;
814     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400010f02(const DragNotifyMsg &notifyMessage) 815     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
816         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
817             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
818         promiseFlag.set_value(true);
819     };
820     std::optional<DragData> dragData = CreateDragData(
821         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
822     EXPECT_TRUE(dragData);
823     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
824         std::make_shared<TestStartDragListener>(callback));
825     ASSERT_EQ(ret, RET_OK);
826     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
827     PreviewStyle previewStyleIn;
828     previewStyleIn.types = { PreviewType::FOREGROUND_COLOR };
829     previewStyleIn.foregroundColor = FOREGROUND_COLOR_IN;
830     ret = InteractionManager::GetInstance()->UpdatePreviewStyle(previewStyleIn);
831     ASSERT_EQ(ret, RET_OK);
832     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
833     PreviewStyle previewStyleOut;
834     previewStyleOut.types = { PreviewType::FOREGROUND_COLOR };
835     previewStyleOut.foregroundColor = FOREGROUND_COLOR_OUT;
836     ret = InteractionManager::GetInstance()->UpdatePreviewStyle(previewStyleOut);
837     EXPECT_EQ(ret, RET_OK);
838     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
839     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
840         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
841     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
842     ASSERT_EQ(ret, RET_OK);
843     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
844         std::future_status::timeout);
845 }
846 
847 /**
848  * @tc.name: DragManagerTest25
849  * @tc.desc: Drag Drawing
850  * @tc.type: FUNC
851  * @tc.require:
852  */
853 HWTEST_F(DragManagerTest, DragManagerTest25, TestSize.Level0)
854 {
855     CALL_TEST_DEBUG;
856     std::promise<bool> promiseFlag;
857     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400011002(const DragNotifyMsg &notifyMessage) 858     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
859         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
860             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
861         promiseFlag.set_value(true);
862     };
863     std::optional<DragData> dragData = CreateDragData(
864         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
865     EXPECT_TRUE(dragData);
866     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
867         std::make_shared<TestStartDragListener>(callback));
868     ASSERT_EQ(ret, RET_OK);
869     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
870     PreviewStyle previewStyleIn;
871     previewStyleIn.types = { PreviewType::FOREGROUND_COLOR };
872     previewStyleIn.foregroundColor = FOREGROUND_COLOR_IN;
873     PreviewAnimation animationIn;
874     AssignToAnimation(animationIn);
875     ret = InteractionManager::GetInstance()->UpdatePreviewStyleWithAnimation(previewStyleIn, animationIn);
876     ASSERT_EQ(ret, RET_OK);
877     PreviewStyle previewStyleOut;
878     previewStyleOut.types = { PreviewType::FOREGROUND_COLOR };
879     previewStyleOut.foregroundColor = FOREGROUND_COLOR_OUT;
880     PreviewAnimation animationOut;
881     AssignToAnimation(animationOut);
882     ret = InteractionManager::GetInstance()->UpdatePreviewStyleWithAnimation(previewStyleOut, animationOut);
883     EXPECT_EQ(ret, RET_OK);
884     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
885     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
886         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
887     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
888     ASSERT_EQ(ret, RET_OK);
889     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
890         std::future_status::timeout);
891 }
892 
893 /**
894  * @tc.name: DragManagerTest26
895  * @tc.desc: Drag Drawing
896  * @tc.type: FUNC
897  * @tc.require:
898  */
899 HWTEST_F(DragManagerTest, DragManagerTest26, TestSize.Level0)
900 {
901     CALL_TEST_DEBUG;
902     std::promise<bool> promiseFlag;
903     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400011102(const DragNotifyMsg &notifyMessage) 904     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
905         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
906             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
907         promiseFlag.set_value(true);
908     };
909     std::optional<DragData> dragData = CreateDragData(
910         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
911     EXPECT_TRUE(dragData);
912     const std::string udType = "general.message";
913     constexpr int64_t recordSize = 20;
914     std::map<std::string, int64_t> summarys = { { udType, recordSize } };
915     dragData.value().summarys = summarys;
916     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
917         std::make_shared<TestStartDragListener>(callback));
918     ASSERT_EQ(ret, RET_OK);
919     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
920     summarys.clear();
921     ret = InteractionManager::GetInstance()->GetDragSummary(summarys);
922     ASSERT_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: DragManagerTest27
934  * @tc.desc: Drag Drawing
935  * @tc.type: FUNC
936  * @tc.require:
937  */
938 HWTEST_F(DragManagerTest, DragManagerTest27, TestSize.Level0)
939 {
940     CALL_TEST_DEBUG;
941     std::promise<bool> promiseFlag;
942     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400011202(const DragNotifyMsg &notifyMessage) 943     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
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     ret = InteractionManager::GetInstance()->EnterTextEditorArea(true);
956     ASSERT_EQ(ret, RET_OK);
957     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
958     ret = InteractionManager::GetInstance()->EnterTextEditorArea(false);
959     ASSERT_EQ(ret, RET_OK);
960     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
961     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
962         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
963     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
964     ASSERT_EQ(ret, RET_OK);
965     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
966         std::future_status::timeout);
967 }
968 
969 /**
970  * @tc.name: DragManagerTest28
971  * @tc.desc: Drag Drawing
972  * @tc.type: FUNC
973  * @tc.require:
974  */
975 HWTEST_F(DragManagerTest, DragManagerTest28, TestSize.Level0)
976 {
977     CALL_TEST_DEBUG;
978     std::promise<bool> promiseFlag;
979     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400011302(const DragNotifyMsg &notifyMessage) 980     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
981         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
982             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
983         promiseFlag.set_value(true);
984     };
985     std::optional<DragData> dragData = CreateDragData(
986         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
987     EXPECT_TRUE(dragData);
988     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
989         std::make_shared<TestStartDragListener>(callback));
990     ASSERT_EQ(ret, RET_OK);
991     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
992     ret = InteractionManager::GetInstance()->AddPrivilege();
993     ASSERT_EQ(ret, RET_OK);
994     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
995     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
996         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
997     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
998     ASSERT_EQ(ret, RET_OK);
999     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1000         std::future_status::timeout);
1001 }
1002 
1003 /**
1004  * @tc.name: DragManagerTest29
1005  * @tc.desc: Drag Drawing
1006  * @tc.type: FUNC
1007  * @tc.require:
1008  */
1009 HWTEST_F(DragManagerTest, DragManagerTest29, TestSize.Level0)
1010 {
1011     CALL_TEST_DEBUG;
1012     std::promise<bool> promiseFlag;
1013     std::future<bool> futureFlag = promiseFlag.get_future();
__anoneac400011402(const DragNotifyMsg &notifyMessage) 1014     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
1015         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1016             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1017         promiseFlag.set_value(true);
1018     };
1019     std::optional<DragData> dragData = CreateDragData(
1020         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
1021     EXPECT_TRUE(dragData);
1022     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1023         std::make_shared<TestStartDragListener>(callback));
1024     ASSERT_EQ(ret, RET_OK);
1025     ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1026         std::make_shared<TestStartDragListener>(callback));
1027     ASSERT_EQ(ret, RET_ERR);
1028     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1029     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
1030         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
1031     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1032     ASSERT_EQ(ret, RET_OK);
1033     EXPECT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) !=
1034         std::future_status::timeout);
1035 }
1036 
1037 /**
1038  * @tc.name: DragManagerTest30
1039  * @tc.desc: Drag Drawing
1040  * @tc.type: FUNC
1041  * @tc.require:
1042  */
1043 HWTEST_F(DragManagerTest, DragManagerTest30, TestSize.Level0)
1044 {
1045     CALL_TEST_DEBUG;
1046     DragDropResult dropResult { DragResult::DRAG_SUCCESS,
1047         HAS_CUSTOM_ANIMATION, TARGET_MAIN_WINDOW };
1048     int32_t ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1049     ASSERT_EQ(ret, RET_ERR);
1050 }
1051 
1052 /**
1053  * @tc.name: DragManagerTest31
1054  * @tc.desc: Drag Drawing
1055  * @tc.type: FUNC
1056  * @tc.require:
1057  */
1058 HWTEST_F(DragManagerTest, DragManagerTest31, TestSize.Level0)
1059 {
1060     CALL_TEST_DEBUG;
1061     int32_t ret = InteractionManager::GetInstance()->SetDragWindowVisible(true);
1062     ASSERT_EQ(ret, RET_ERR);
1063     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
1064     ret = InteractionManager::GetInstance()->SetDragWindowVisible(false);
1065     ASSERT_EQ(ret, RET_ERR);
1066 }
1067 
1068 /**
1069  * @tc.name: DragManagerTest32
1070  * @tc.desc: Drag Drawing
1071  * @tc.type: FUNC
1072  * @tc.require:
1073  */
1074 HWTEST_F(DragManagerTest, DragManagerTest32, TestSize.Level0)
1075 {
1076     CALL_TEST_DEBUG;
1077     int32_t ret = -1;
1078     std::vector<DragCursorStyle> dragCursorStyles = {DragCursorStyle::FORBIDDEN,
1079         DragCursorStyle::COPY, DragCursorStyle::MOVE};
1080     for (const auto& dragCursorStyle : dragCursorStyles) {
1081         ret = InteractionManager::GetInstance()->UpdateDragStyle(dragCursorStyle);
1082         ASSERT_EQ(ret, RET_ERR);
1083     }
1084 }
1085 
1086 /**
1087  * @tc.name: DragManagerTest33
1088  * @tc.desc: Drag Drawing
1089  * @tc.type: FUNC
1090  * @tc.require:
1091  */
1092 HWTEST_F(DragManagerTest, DragManagerTest33, TestSize.Level0)
1093 {
1094     CALL_TEST_DEBUG;
1095     std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(PIXEL_MAP_WIDTH, PIXEL_MAP_HEIGHT);
1096     ASSERT_NE(pixelMap, nullptr);
1097     ShadowInfo shadowInfo = { pixelMap, 0, 0 };
1098     int32_t ret = InteractionManager::GetInstance()->UpdateShadowPic(shadowInfo);
1099     ASSERT_EQ(ret, RET_ERR);
1100 }
1101 
1102 /**
1103  * @tc.name: DragManagerTest34
1104  * @tc.desc: Drag Drawing
1105  * @tc.type: FUNC
1106  * @tc.require:
1107  */
1108 HWTEST_F(DragManagerTest, DragManagerTest34, TestSize.Level0)
1109 {
1110     CALL_TEST_DEBUG;
1111     int32_t pid = InteractionManager::GetInstance()->GetDragTargetPid();
1112     EXPECT_GT(pid, 0);
1113 }
1114 
1115 /**
1116  * @tc.name: DragManagerTest35
1117  * @tc.desc: Drag Drawing
1118  * @tc.type: FUNC
1119  * @tc.require:
1120  */
1121 HWTEST_F(DragManagerTest, DragManagerTest35, TestSize.Level0)
1122 {
1123     CALL_TEST_DEBUG;
1124     std::string udKey;
1125     int32_t ret = InteractionManager::GetInstance()->GetUdKey(udKey);
1126     ASSERT_EQ(ret, RET_ERR);
1127 }
1128 
1129 /**
1130  * @tc.name: DragManagerTest36
1131  * @tc.desc: Drag Drawing
1132  * @tc.type: FUNC
1133  * @tc.require:
1134  */
1135 HWTEST_F(DragManagerTest, DragManagerTest36, TestSize.Level0)
1136 {
1137     CALL_TEST_DEBUG;
1138     int32_t offsetX = 0;
1139     int32_t offsetY = 0;
1140     int32_t width = 0;
1141     int32_t height = 0;
1142     int32_t ret = InteractionManager::GetInstance()->GetShadowOffset(offsetX, offsetY, width, height);
1143     ASSERT_EQ(ret, RET_ERR);
1144 }
1145 
1146 /**
1147  * @tc.name: DragManagerTest37
1148  * @tc.desc: Drag Drawing
1149  * @tc.type: FUNC
1150  * @tc.require:
1151  */
1152 HWTEST_F(DragManagerTest, DragManagerTest37, TestSize.Level0)
1153 {
1154     CALL_TEST_DEBUG;
1155     DragData replyDragData;
1156     int32_t ret = InteractionManager::GetInstance()->GetDragData(replyDragData);
1157     ASSERT_EQ(ret, RET_ERR);
1158 }
1159 
1160 /**
1161  * @tc.name: DragManagerTest38
1162  * @tc.desc: Drag Drawing
1163  * @tc.type: FUNC
1164  * @tc.require:
1165  */
1166 HWTEST_F(DragManagerTest, DragManagerTest38, TestSize.Level0)
1167 {
1168     CALL_TEST_DEBUG;
1169     PreviewStyle previewStyleOut;
1170     previewStyleOut.types = { PreviewType::FOREGROUND_COLOR };
1171     previewStyleOut.foregroundColor = FOREGROUND_COLOR_OUT;
1172     int32_t ret = InteractionManager::GetInstance()->UpdatePreviewStyle(previewStyleOut);
1173     ASSERT_EQ(ret, RET_ERR);
1174     PreviewStyle previewStyleIn;
1175     previewStyleIn.types = { PreviewType::FOREGROUND_COLOR };
1176     previewStyleIn.foregroundColor = FOREGROUND_COLOR_IN;
1177     ret = InteractionManager::GetInstance()->UpdatePreviewStyle(previewStyleIn);
1178     ASSERT_EQ(ret, RET_ERR);
1179 }
1180 
1181 /**
1182  * @tc.name: DragManagerTest39
1183  * @tc.desc: Drag Drawing
1184  * @tc.type: FUNC
1185  * @tc.require:
1186  */
1187 HWTEST_F(DragManagerTest, DragManagerTest39, TestSize.Level0)
1188 {
1189     CALL_TEST_DEBUG;
1190     PreviewStyle previewStyleIn;
1191     previewStyleIn.types = { PreviewType::FOREGROUND_COLOR };
1192     previewStyleIn.foregroundColor = FOREGROUND_COLOR_IN;
1193     PreviewAnimation animationIn;
1194     AssignToAnimation(animationIn);
1195     int32_t ret = InteractionManager::GetInstance()->UpdatePreviewStyleWithAnimation(previewStyleIn, animationIn);
1196     ASSERT_EQ(ret, RET_ERR);
1197     PreviewStyle previewStyleOut;
1198     previewStyleOut.types = { PreviewType::FOREGROUND_COLOR };
1199     previewStyleOut.foregroundColor = FOREGROUND_COLOR_OUT;
1200     PreviewAnimation animationOut;
1201     AssignToAnimation(animationOut);
1202     ret = InteractionManager::GetInstance()->UpdatePreviewStyleWithAnimation(previewStyleOut, animationOut);
1203     ASSERT_EQ(ret, RET_ERR);
1204 }
1205 
1206 /**
1207  * @tc.name: DragManagerTest40
1208  * @tc.desc: Drag Drawing
1209  * @tc.type: FUNC
1210  * @tc.require:
1211  */
1212 HWTEST_F(DragManagerTest, DragManagerTest40, TestSize.Level0)
1213 {
1214     CALL_TEST_DEBUG;
1215     int32_t ret = InteractionManager::GetInstance()->EnterTextEditorArea(true);
1216     ASSERT_EQ(ret, RET_ERR);
1217     ret = InteractionManager::GetInstance()->EnterTextEditorArea(false);
1218     ASSERT_EQ(ret, RET_ERR);
1219 }
1220 
1221 /**
1222  * @tc.name: DragManagerTest41
1223  * @tc.desc: Drag Drawing
1224  * @tc.type: FUNC
1225  * @tc.require:
1226  */
1227 HWTEST_F(DragManagerTest, DragManagerTest41, TestSize.Level0)
1228 {
1229     CALL_TEST_DEBUG;
1230     DragAction dragAction { DragAction::INVALID };
1231     int32_t ret = InteractionManager::GetInstance()->GetDragAction(dragAction);
1232     ASSERT_EQ(ret, RET_ERR);
1233 }
1234 
1235 /**
1236  * @tc.name: DragManagerTest42
1237  * @tc.desc: Drag Drawing
1238  * @tc.type: FUNC
1239  * @tc.require:
1240  */
1241 HWTEST_F(DragManagerTest, DragManagerTest42, TestSize.Level0)
1242 {
1243     CALL_TEST_DEBUG;
1244     std::string extraInfo;
1245     int32_t ret = InteractionManager::GetInstance()->GetExtraInfo(extraInfo);
1246     ASSERT_EQ(ret, RET_ERR);
1247 }
1248 
1249 /**
1250  * @tc.name: DragManagerTest43
1251  * @tc.desc: Drag Drawing
1252  * @tc.type: FUNC
1253  * @tc.require:
1254  */
1255 HWTEST_F(DragManagerTest, DragManagerTest43, TestSize.Level0)
1256 {
1257     CALL_TEST_DEBUG;
1258     int32_t ret = InteractionManager::GetInstance()->AddPrivilege();
1259     ASSERT_EQ(ret, RET_ERR);
1260 }
1261 
1262 /**
1263  * @tc.name: DragManagerTest44
1264  * @tc.desc: Drag Drawing
1265  * @tc.type: FUNC
1266  * @tc.require:
1267  */
1268 HWTEST_F(DragManagerTest, DragManagerTest44, TestSize.Level0)
1269 {
1270     CALL_TEST_DEBUG;
1271     MessageParcel data;
1272     StopDragParam param {};
1273     bool ret = param.Unmarshalling(data);
1274     EXPECT_FALSE(ret);
1275 }
1276 
1277 /**
1278  * @tc.name: DragManagerTest45
1279  * @tc.desc: Drag Drawing
1280  * @tc.type: FUNC
1281  * @tc.require:
1282  */
1283 HWTEST_F(DragManagerTest, DragManagerTest45, TestSize.Level0)
1284 {
1285     CALL_TEST_DEBUG;
1286     MessageParcel data;
1287     SetDragWindowVisibleParam param {};
1288     bool ret = param.Unmarshalling(data);
1289     EXPECT_FALSE(ret);
1290 }
1291 
1292 /**
1293  * @tc.name: DragManagerTest46
1294  * @tc.desc: Drag Drawing
1295  * @tc.type: FUNC
1296  * @tc.require:
1297  */
1298 HWTEST_F(DragManagerTest, DragManagerTest46, TestSize.Level0)
1299 {
1300     CALL_TEST_DEBUG;
1301     int32_t pid = InteractionManager::GetInstance()->GetDragTargetPid();
1302     MessageParcel data;
1303     GetDragTargetPidReply targetPidReply { pid };
1304     bool ret = targetPidReply.Marshalling(data);
1305     EXPECT_TRUE(ret);
1306 }
1307 
1308 /**
1309  * @tc.name: DragManagerTest47
1310  * @tc.desc: Drag Drawing
1311  * @tc.type: FUNC
1312  * @tc.require:
1313  */
1314 HWTEST_F(DragManagerTest, DragManagerTest47, TestSize.Level0)
1315 {
1316     CALL_TEST_DEBUG;
1317     int32_t pid = InteractionManager::GetInstance()->GetDragTargetPid();
1318     MessageParcel data;
1319     GetDragTargetPidReply targetPidReply { pid };
1320     bool ret = targetPidReply.Marshalling(data);
1321     EXPECT_TRUE(ret);
1322 }
1323 
1324 /**
1325  * @tc.name: DragManagerTest48
1326  * @tc.desc: Drag Drawing
1327  * @tc.type: FUNC
1328  * @tc.require:
1329  */
1330 HWTEST_F(DragManagerTest, DragManagerTest48, TestSize.Level0)
1331 {
1332     CALL_TEST_DEBUG;
1333     std::string udKey;
1334     MessageParcel data;
1335     GetUdKeyReply udKeyReply { std::move(udKey) };
1336     bool ret = udKeyReply.Marshalling(data);
1337     EXPECT_TRUE(ret);
1338 }
1339 
1340 /**
1341  * @tc.name: DragManagerTest49
1342  * @tc.desc: Drag Drawing
1343  * @tc.type: FUNC
1344  * @tc.require:
1345  */
1346 HWTEST_F(DragManagerTest, DragManagerTest49, TestSize.Level0)
1347 {
1348     CALL_TEST_DEBUG;
1349     ShadowOffset shadowOffset {};
1350     MessageParcel data;
1351     GetShadowOffsetReply shadowOffsetReply { shadowOffset };
1352     bool ret = shadowOffsetReply.Marshalling(data);
1353     EXPECT_TRUE(ret);
1354 }
1355 
1356 /**
1357  * @tc.name: DragManagerTest50
1358  * @tc.desc: Drag Drawing
1359  * @tc.type: FUNC
1360  * @tc.require:
1361  */
1362 HWTEST_F(DragManagerTest, DragManagerTest50, TestSize.Level0)
1363 {
1364     CALL_TEST_DEBUG;
1365     UpdatePreviewAnimationParam param {};
1366     MessageParcel data;
1367     bool ret = param.Unmarshalling(data);
1368     EXPECT_FALSE(ret);
1369 }
1370 
1371 /**
1372  * @tc.name: DragManagerTest51
1373  * @tc.desc: Drag Drawing
1374  * @tc.type: FUNC
1375  * @tc.require:
1376  */
1377 HWTEST_F(DragManagerTest, DragManagerTest51, TestSize.Level0)
1378 {
1379     CALL_TEST_DEBUG;
1380     std::map<std::string, int64_t> summaries;
1381     GetDragSummaryReply summaryReply { std::move(summaries) };
1382     MessageParcel data;
1383     bool ret = summaryReply.Marshalling(data);
1384     EXPECT_TRUE(ret);
1385 }
1386 
1387 /**
1388  * @tc.name: DragManagerTest52
1389  * @tc.desc: Drag Drawing
1390  * @tc.type: FUNC
1391  * @tc.require:
1392  */
1393 HWTEST_F(DragManagerTest, DragManagerTest52, TestSize.Level0)
1394 {
1395     CALL_TEST_DEBUG;
1396     DragState dragState {};
1397     GetDragStateReply dragStateReply { dragState };
1398     MessageParcel data;
1399     bool ret = dragStateReply.Marshalling(data);
1400     EXPECT_TRUE(ret);
1401 }
1402 
1403 /**
1404  * @tc.name: DragManagerTest53
1405  * @tc.desc: Drag Drawing
1406  * @tc.type: FUNC
1407  * @tc.require:
1408  */
1409 HWTEST_F(DragManagerTest, DragManagerTest53, TestSize.Level0)
1410 {
1411     CALL_TEST_DEBUG;
1412     DragAction dragAction {};
1413     GetDragActionReply dragActionReply { dragAction };
1414     MessageParcel data;
1415     bool ret = dragActionReply.Marshalling(data);
1416     EXPECT_TRUE(ret);
1417 }
1418 
1419 /**
1420  * @tc.name: DragManagerTest54
1421  * @tc.desc: Drag Drawing
1422  * @tc.type: FUNC
1423  * @tc.require:
1424  */
1425 HWTEST_F(DragManagerTest, DragManagerTest54, TestSize.Level0)
1426 {
1427     CALL_TEST_DEBUG;
1428     std::string extraInfo;
1429     GetExtraInfoReply extraInfoReply { std::move(extraInfo) };
1430     MessageParcel data;
1431     bool ret = extraInfoReply.Marshalling(data);
1432     EXPECT_TRUE(ret);
1433 }
1434 
1435 /**
1436  * @tc.name: DragManagerTest55
1437  * @tc.desc: Drag Drawing
1438  * @tc.type: FUNC
1439  * @tc.require:
1440  */
1441 HWTEST_F(DragManagerTest, DragManagerTest55, TestSize.Level0)
1442 {
1443     CALL_TEST_DEBUG;
1444     std::string extraInfo;
1445     GetExtraInfoReply extraInfoReply { std::move(extraInfo) };
1446     MessageParcel data;
1447     bool ret = extraInfoReply.Marshalling(data);
1448     EXPECT_TRUE(ret);
1449 }
1450 
1451 /**
1452  * @tc.name: DragManagerTest56
1453  * @tc.desc: Drag Drawing
1454  * @tc.type: FUNC
1455  * @tc.require:
1456  */
1457 HWTEST_F(DragManagerTest, DragManagerTest56, TestSize.Level0)
1458 {
1459     CALL_TEST_DEBUG;
1460     std::string extraInfo;
1461     UpdateDragStyleParam param;
1462     MessageParcel data;
1463     bool ret = param.Marshalling(data);
1464     EXPECT_TRUE(ret);
1465 }
1466 
1467 /**
1468  * @tc.name: DragManagerTest57
1469  * @tc.desc: Drag Drawing
1470  * @tc.type: FUNC
1471  * @tc.require:
1472  */
1473 HWTEST_F(DragManagerTest, DragManagerTest57, TestSize.Level0)
1474 {
1475     CALL_TEST_DEBUG;
1476     std::string extraInfo;
1477     UpdateDragStyleParam param;
1478     MessageParcel data;
1479     bool ret = param.Unmarshalling(data);
1480     EXPECT_FALSE(ret);
1481 }
1482 
1483 /**
1484  * @tc.name: DragManagerTest58
1485  * @tc.desc: Drag Drawing
1486  * @tc.type: FUNCdSession
1487  * @tc.require:
1488  */
1489 HWTEST_F(DragManagerTest, DragManagerTest58, TestSize.Level0)
1490 {
1491     CALL_TEST_DEBUG;
1492     std::string extraInfo;
1493     UpdateShadowPicParam param;
1494     MessageParcel data;
1495     bool ret = param.Unmarshalling(data);
1496     EXPECT_FALSE(ret);
1497 }
1498 
1499 /**
1500  * @tc.name: DragManagerTest59
1501  * @tc.desc: Drag Drawing
1502  * @tc.type: FUNC
1503  * @tc.require:
1504  */
1505 HWTEST_F(DragManagerTest, DragManagerTest59, TestSize.Level0)
1506 {
1507     CALL_TEST_DEBUG;
1508     std::string extraInfo;
1509     UpdateShadowPicParam param;
1510     MessageParcel data;
1511     bool ret = param.Marshalling(data);
1512     EXPECT_FALSE(ret);
1513 }
1514 
1515 /**
1516  * @tc.name: DragManagerTest60
1517  * @tc.desc: Drag Drawing
1518  * @tc.type: FUNC
1519  * @tc.require:
1520  */
1521 HWTEST_F(DragManagerTest, DragManagerTest60, TestSize.Level0)
1522 {
1523     CALL_TEST_DEBUG;
1524     std::string extraInfo;
1525     UpdatePreviewStyleParam param;
1526     MessageParcel data;
1527     bool ret = param.Marshalling(data);
1528     EXPECT_TRUE(ret);
1529 }
1530 
1531 /**
1532  * @tc.name: DragManagerTest61
1533  * @tc.desc: Drag Drawingx`
1534  * @tc.type: FUNC
1535  * @tc.require:
1536  */
1537 HWTEST_F(DragManagerTest, DragManagerTest61, TestSize.Level0)
1538 {
1539     CALL_TEST_DEBUG;
1540     std::string extraInfo;
1541     UpdatePreviewStyleParam param;
1542     MessageParcel data;
1543     bool ret = param.Unmarshalling(data);
1544     EXPECT_FALSE(ret);
1545 }
1546 
1547 /**
1548  * @tc.name: DragManagerTest62
1549  * @tc.desc: Drag Drawingx`
1550  * @tc.type: FUNC
1551  * @tc.require:
1552  */
1553 HWTEST_F(DragManagerTest, DragManagerTest62, TestSize.Level0)
1554 {
1555     CALL_TEST_DEBUG;
1556     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1557     StopDragParam param { dropResult };
1558     MessageParcel data;
1559     bool ret = param.Marshalling(data);
1560     EXPECT_TRUE(ret);
1561     ret = param.Unmarshalling(data);
1562     EXPECT_TRUE(ret);
1563 }
1564 
1565 /**
1566  * @tc.name: DragManagerTest63
1567  * @tc.desc: Drag Drawingx`
1568  * @tc.type: FUNC
1569  * @tc.require:
1570  */
1571 HWTEST_F(DragManagerTest, DragManagerTest63, TestSize.Level0)
1572 {
1573     CALL_TEST_DEBUG;
1574     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION,
1575         WINDOW_ID, static_cast<DragBehavior>(-2)};
1576     StopDragParam param { dropResult };
1577     MessageParcel data;
1578     bool ret = param.Marshalling(data);
1579     EXPECT_TRUE(ret);
1580     ret = param.Unmarshalling(data);
1581     EXPECT_FALSE(ret);
1582 }
1583 
1584 /**
1585  * @tc.name: DragManagerTest64
1586  * @tc.desc: Drag Drawingx`
1587  * @tc.type: FUNC
1588  * @tc.require:
1589  */
1590 HWTEST_F(DragManagerTest, DragManagerTest64, TestSize.Level0)
1591 {
1592     CALL_TEST_DEBUG;
1593     MessageParcel data;
1594     SetDragWindowVisibleParam param { true, true };
1595     bool ret = param.Marshalling(data);
1596     EXPECT_TRUE(ret);
1597     ret = param.Unmarshalling(data);
1598     EXPECT_TRUE(ret);
1599 }
1600 
1601 /**
1602  * @tc.name: DragManagerTest65
1603  * @tc.desc: Drag Drawingx`
1604  * @tc.type: FUNC
1605  * @tc.require:
1606  */
1607 HWTEST_F(DragManagerTest, DragManagerTest65, TestSize.Level0)
1608 {
1609     CALL_TEST_DEBUG;
1610     MessageParcel data;
1611     UpdateDragStyleParam param { DragCursorStyle::DEFAULT, -1 };
1612     bool ret = param.Marshalling(data);
1613     EXPECT_TRUE(ret);
1614     ret = param.Unmarshalling(data);
1615     EXPECT_TRUE(ret);
1616 }
1617 
1618 /**
1619  * @tc.name: DragManagerTest66
1620  * @tc.desc: Drag Drawingx`
1621  * @tc.type: FUNC
1622  * @tc.require:
1623  */
1624 HWTEST_F(DragManagerTest, DragManagerTest66, TestSize.Level0)
1625 {
1626     CALL_TEST_DEBUG;
1627     std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(PIXEL_MAP_WIDTH, PIXEL_MAP_HEIGHT);
1628     ASSERT_NE(pixelMap, nullptr);
1629     ShadowInfo shadowInfo = { pixelMap, 0, 0 };
1630     std::string extraInfo;
1631     UpdateShadowPicParam param { shadowInfo };
1632     MessageParcel data;
1633     bool ret = param.Marshalling(data);
1634     EXPECT_TRUE(ret);
1635     ret = param.Unmarshalling(data);
1636     EXPECT_TRUE(ret);
1637 }
1638 
1639 /**
1640  * @tc.name: DragManagerTest67
1641  * @tc.desc: Drag Drawingx`
1642  * @tc.type: FUNC
1643  * @tc.require:
1644  */
1645 HWTEST_F(DragManagerTest, DragManagerTest67, TestSize.Level0)
1646 {
1647     CALL_TEST_DEBUG;
1648     MessageParcel data;
1649     DragData dragData {};
1650     StartDragParam param { dragData };
1651     bool ret = param.Marshalling(data);
1652     EXPECT_FALSE(ret);
1653     ret = param.Unmarshalling(data);
1654     EXPECT_FALSE(ret);
1655 }
1656 
1657 /**
1658  * @tc.name: DragManagerTest68
1659  * @tc.desc: Drag Drawingx`
1660  * @tc.type: FUNC
1661  * @tc.require:
1662  */
1663 HWTEST_F(DragManagerTest, DragManagerTest68, TestSize.Level0)
1664 {
1665     CALL_TEST_DEBUG;
1666     std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(PIXEL_MAP_WIDTH, PIXEL_MAP_HEIGHT);
1667     ASSERT_NE(pixelMap, nullptr);
1668     ShadowInfo shadowInfo = { pixelMap, 1, 0 };
1669     ShadowInfo otherShadowInfo = {};
1670     EXPECT_TRUE(shadowInfo != otherShadowInfo);
1671     ShadowOffset shadowOffset {};
1672     ShadowOffset otherShadowOffset {};
1673     EXPECT_FALSE(shadowOffset != otherShadowOffset);
1674     DragData dragData {};
1675     DragData otherDragData {};
1676     EXPECT_FALSE(dragData != otherDragData);
1677     PreviewStyle previewStyle {};
1678     PreviewStyle otherPreviewStyle {};
1679     EXPECT_FALSE(previewStyle != otherPreviewStyle);
1680     Data data {};
1681     Data otherData {};
1682     EXPECT_TRUE(data != otherData);
1683     DragItemStyle dragItemStyle = { 1, 1, 0 };
1684     DragItemStyle otherDragItemStyle = {};
1685     DragItemStyle dragItemStyleOne = { 1, 1, 0 };
1686     EXPECT_TRUE(dragItemStyle != otherDragItemStyle);
1687     EXPECT_TRUE(dragItemStyle == dragItemStyleOne);
1688 }
1689 
1690 /**
1691  * @tc.name: DragManagerTest69
1692  * @tc.desc: Drag Drawingx`
1693  * @tc.type: FUNC
1694  * @tc.require:
1695  */
1696 HWTEST_F(DragManagerTest, DragManagerTest69, TestSize.Level0)
1697 {
1698     CALL_TEST_DEBUG;
1699     int32_t ret = InteractionManager::GetInstance()->RotateDragWindowSync(nullptr);
1700     EXPECT_EQ(ret, RET_ERR);
1701 }
1702 } // namespace DeviceStatus
1703 } // namespace Msdp
1704 } // namespace OHOS
1705