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