• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <future>
17 #include <optional>
18 #include <vector>
19 
20 #include <unistd.h>
21 
22 #include <gtest/gtest.h>
23 #include "pointer_event.h"
24 #include "securec.h"
25 
26 #include "devicestatus_define.h"
27 #include "devicestatus_errors.h"
28 #include "interaction_manager.h"
29 
30 #undef LOG_TAG
31 #define LOG_TAG "InteractionDragDrawingTest"
32 
33 namespace OHOS {
34 namespace Msdp {
35 namespace DeviceStatus {
36 using namespace testing::ext;
37 namespace {
38 constexpr uint32_t DEFAULT_ICON_COLOR { 0xFF };
39 constexpr int32_t TIME_WAIT_FOR_OP_MS { 20 };
40 constexpr int32_t PIXEL_MAP_WIDTH { 300 };
41 constexpr int32_t PIXEL_MAP_HEIGHT { 300 };
42 constexpr int32_t MIDDLE_PIXEL_MAP_WIDTH { 400 };
43 constexpr int32_t MIDDLE_PIXEL_MAP_HEIGHT { 400 };
44 constexpr int32_t MAX_PIXEL_MAP_WIDTH { 600 };
45 constexpr int32_t MAX_PIXEL_MAP_HEIGHT { 600 };
46 constexpr int32_t POINTER_ID { 0 };
47 constexpr int32_t DISPLAY_ID { 0 };
48 constexpr int32_t DISPLAY_X { 50 };
49 constexpr int32_t DISPLAY_Y { 50 };
50 constexpr int32_t DRAG_NUM_ONE { 1 };
51 constexpr int32_t SHADOW_NUM_ONE { 1 };
52 constexpr int32_t DRAG_NUM_TWO { 2 };
53 constexpr int32_t SHADOW_NUM_TWO { 2 };
54 constexpr int32_t DRAG_NUM_THREE { 3 };
55 constexpr int32_t SHADOW_NUM_THREE { 3 };
56 constexpr int32_t SHADOW_NUM_TOO_MUCH { 5 };
57 constexpr int32_t DRAG_NUM_MULTIPLE { 10 };
58 constexpr int32_t SHADOW_NUM_MULTIPLE { 10 };
59 constexpr int32_t INT32_BYTE { 4 };
60 constexpr int32_t PROMISE_WAIT_SPAN_MS { 2000 };
61 constexpr int32_t TIME_WAIT_FOR_UPDATE_DRAG_STYLE { 50 };
62 constexpr int32_t TIME_WAIT_FOR_ANIMATION_END { 1000 };
63 constexpr int32_t WINDOW_ID { -1 };
64 constexpr bool HAS_CANCELED_ANIMATION { true };
65 constexpr bool HAS_CUSTOM_ANIMATION { true };
66 constexpr bool DRAG_WINDOW_VISIBLE { true };
67 const std::string UD_KEY { "Unified data key" };
68 const std::string FILTER_INFO { "Undefined filter info" };
69 const std::string EXTRA_INFO { "Undefined extra info" };
70 } // namespace
71 
72 class InteractionDragDrawingTest : public testing::Test {
73 public:
74     void SetUp();
75     void TearDown();
76     static void SetUpTestCase();
77     static std::shared_ptr<Media::PixelMap> CreatePixelMap(int32_t width, int32_t height);
78     static std::optional<DragData> CreateDragData(int32_t sourceType, int32_t pointerId, int32_t dragNum,
79         bool hasCoordinateCorrected, int32_t shadowNum);
80 };
81 
SetUpTestCase()82 void InteractionDragDrawingTest::SetUpTestCase() {}
83 
SetUp()84 void InteractionDragDrawingTest::SetUp() {}
85 
TearDown()86 void InteractionDragDrawingTest::TearDown()
87 {
88     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_OP_MS));
89 }
90 
CreatePixelMap(int32_t width,int32_t height)91 std::shared_ptr<Media::PixelMap> InteractionDragDrawingTest::CreatePixelMap(int32_t width, int32_t height)
92 {
93     CALL_DEBUG_ENTER;
94     if (width <= 0 || width > MAX_PIXEL_MAP_WIDTH || height <= 0 || height > MAX_PIXEL_MAP_HEIGHT) {
95         FI_HILOGE("Size invalid, height:%{public}d, width:%{public}d", height, width);
96         return nullptr;
97     }
98     Media::InitializationOptions opts;
99     opts.size.height = height;
100     opts.size.width = width;
101     opts.pixelFormat = Media::PixelFormat::BGRA_8888;
102     opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
103     opts.scaleMode = Media::ScaleMode::FIT_TARGET_SIZE;
104 
105     int32_t colorLen = width * height;
106     uint32_t *pixelColors = new (std::nothrow) uint32_t[colorLen];
107     CHKPP(pixelColors);
108     int32_t colorByteCount = colorLen * INT32_BYTE;
109     errno_t ret = memset_s(pixelColors, colorByteCount, DEFAULT_ICON_COLOR, colorByteCount);
110     if (ret != EOK) {
111         FI_HILOGE("memset_s failed");
112         delete[] pixelColors;
113         return nullptr;
114     }
115     std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(pixelColors, colorLen, opts);
116     if (pixelMap == nullptr) {
117         FI_HILOGE("Create pixelMap failed");
118         delete[] pixelColors;
119         return nullptr;
120     }
121     delete[] pixelColors;
122     return pixelMap;
123 }
124 
125 class TestStartDragListener : public IStartDragListener {
126 public:
TestStartDragListener(std::function<void (const DragNotifyMsg &)> function)127     explicit TestStartDragListener(std::function<void(const DragNotifyMsg&)> function) : function_(function) { }
OnDragEndMessage(const DragNotifyMsg & msg)128     void OnDragEndMessage(const DragNotifyMsg &msg) override
129     {
130         FI_HILOGD("DisplayX:%{public}d, displayY:%{public}d, targetPid:%{public}d, result:%{public}d",
131             msg.displayX, msg.displayY, msg.targetPid, static_cast<int32_t>(msg.result));
132         if (function_ != nullptr) {
133             function_(msg);
134         }
135         FI_HILOGD("Test OnDragEndMessage");
136     }
137 
OnHideIconMessage()138     void OnHideIconMessage() override
139     {
140         FI_HILOGD("Test OnHideIconMessage");
141     }
142 private:
143     std::function<void(const DragNotifyMsg&)> function_;
144 };
145 
CreateDragData(int32_t sourceType,int32_t pointerId,int32_t dragNum,bool hasCoordinateCorrected,int32_t shadowNum)146 std::optional<DragData> InteractionDragDrawingTest::CreateDragData(int32_t sourceType,
147     int32_t pointerId, int32_t dragNum, bool hasCoordinateCorrected, int32_t shadowNum)
148 {
149     CALL_DEBUG_ENTER;
150     DragData dragData;
151     for (int32_t i = 0; i < shadowNum; i++) {
152         std::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(PIXEL_MAP_WIDTH, PIXEL_MAP_HEIGHT);
153         if (pixelMap == nullptr) {
154             FI_HILOGE("CreatePixelMap failed");
155             return std::nullopt;
156         }
157         dragData.shadowInfos.push_back({ pixelMap, 0, 0 });
158     }
159     dragData.buffer = std::vector<uint8_t>(MAX_BUFFER_SIZE, 0);
160     dragData.udKey = UD_KEY;
161     dragData.extraInfo = FILTER_INFO;
162     dragData.extraInfo = EXTRA_INFO;
163     dragData.sourceType = sourceType;
164     dragData.pointerId = pointerId;
165     dragData.dragNum = dragNum;
166     dragData.displayX = DISPLAY_X;
167     dragData.displayY = DISPLAY_Y;
168     dragData.displayId = DISPLAY_ID;
169     dragData.hasCanceledAnimation = HAS_CANCELED_ANIMATION;
170     dragData.hasCoordinateCorrected = hasCoordinateCorrected;
171     return dragData;
172 }
173 
174 /**
175  * @tc.name: InteractionDragDrawingTest_Mouse_DragNum_One
176  * @tc.desc: Drag Drawing
177  * @tc.type: FUNC
178  * @tc.require:
179  */
180 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_Mouse_DragNum_One, TestSize.Level1)
181 {
182     CALL_TEST_DEBUG;
183     std::optional<DragData> dragData = CreateDragData(
184         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
185     ASSERT_TRUE(dragData);
186     std::promise<bool> promiseFlag;
187     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70202(const DragNotifyMsg &notifyMessage) 188     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
189         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
190             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
191         promiseFlag.set_value(true);
192     };
193     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
194         std::make_shared<TestStartDragListener>(callback));
195     ASSERT_EQ(ret, RET_OK);
196     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
197     ASSERT_EQ(ret, RET_OK);
198     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
199     ASSERT_EQ(ret, RET_OK);
200     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
201     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
202     ASSERT_EQ(ret, RET_OK);
203     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
204     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::FORBIDDEN);
205     ASSERT_EQ(ret, RET_OK);
206     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
207     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
208     ASSERT_EQ(ret, RET_OK);
209     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
210     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
211     ASSERT_EQ(ret, RET_OK);
212     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
213     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
214     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
215     ASSERT_EQ(ret, RET_OK);
216     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
217 }
218 
219 /**
220  * @tc.name: InteractionDragDrawingTest_Mouse_DragNum_Two
221  * @tc.desc: Drag Drawing
222  * @tc.type: FUNC
223  * @tc.require:
224  */
225 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_Mouse_DragNum_Two, TestSize.Level1)
226 {
227     CALL_TEST_DEBUG;
228     std::optional<DragData> dragData = CreateDragData(
229         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_TWO, false, SHADOW_NUM_TWO);
230     ASSERT_TRUE(dragData);
231     std::promise<bool> promiseFlag;
232     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70302(const DragNotifyMsg &notifyMessage) 233     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
234         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
235             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
236         promiseFlag.set_value(true);
237     };
238     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
239         std::make_shared<TestStartDragListener>(callback));
240     ASSERT_EQ(ret, RET_OK);
241     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
242     ASSERT_EQ(ret, RET_OK);
243     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
244     ASSERT_EQ(ret, RET_OK);
245     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
246     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
247     ASSERT_EQ(ret, RET_OK);
248     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
249     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::FORBIDDEN);
250     ASSERT_EQ(ret, RET_OK);
251     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
252     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
253     ASSERT_EQ(ret, RET_OK);
254     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
255     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
256     ASSERT_EQ(ret, RET_OK);
257     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
258     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
259     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
260     ASSERT_EQ(ret, RET_OK);
261     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
262 }
263 
264 /**
265  * @tc.name: InteractionDragDrawingTest_Mouse_DragNum_Three
266  * @tc.desc: Drag Drawing
267  * @tc.type: FUNC
268  * @tc.require:
269  */
270 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_Mouse_DragNum_Three, TestSize.Level1)
271 {
272     CALL_TEST_DEBUG;
273     std::optional<DragData> dragData = CreateDragData(
274         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_THREE, false, SHADOW_NUM_THREE);
275     ASSERT_TRUE(dragData);
276     std::promise<bool> promiseFlag;
277     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70402(const DragNotifyMsg &notifyMessage) 278     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
279         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
280             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
281         promiseFlag.set_value(true);
282     };
283     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
284         std::make_shared<TestStartDragListener>(callback));
285     ASSERT_EQ(ret, RET_OK);
286     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
287     ASSERT_EQ(ret, RET_OK);
288     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
289     ASSERT_EQ(ret, RET_OK);
290     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
291     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
292     ASSERT_EQ(ret, RET_OK);
293     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
294     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::FORBIDDEN);
295     ASSERT_EQ(ret, RET_OK);
296     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
297     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
298     ASSERT_EQ(ret, RET_OK);
299     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
300     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
301     ASSERT_EQ(ret, RET_OK);
302     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
303     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
304     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
305     ASSERT_EQ(ret, RET_OK);
306     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
307 }
308 
309 /**
310  * @tc.name: InteractionDragDrawingTest_Mouse_DragNum_Multiple
311  * @tc.desc: Drag Drawing
312  * @tc.type: FUNC
313  * @tc.require:
314  */
315 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_Mouse_DragNum_Multiple, TestSize.Level1)
316 {
317     CALL_TEST_DEBUG;
318     std::promise<bool> promiseFlag;
319     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70502(const DragNotifyMsg &notifyMessage) 320     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
321         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
322             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
323         promiseFlag.set_value(true);
324     };
325     std::optional<DragData> dragData = CreateDragData(
326         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_MULTIPLE, false, SHADOW_NUM_MULTIPLE);
327     ASSERT_TRUE(dragData);
328     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
329         std::make_shared<TestStartDragListener>(callback));
330     ASSERT_EQ(ret, RET_OK);
331     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
332     ASSERT_EQ(ret, RET_OK);
333     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
334     ASSERT_EQ(ret, RET_OK);
335     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
336     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::FORBIDDEN);
337     ASSERT_EQ(ret, RET_OK);
338     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
339     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
340     ASSERT_EQ(ret, RET_OK);
341     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
342     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
343     ASSERT_EQ(ret, RET_OK);
344     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
345     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
346     ASSERT_EQ(ret, RET_OK);
347     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
348     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
349     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
350     ASSERT_EQ(ret, RET_OK);
351     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
352 }
353 
354 /**
355  * @tc.name: InteractionDragDrawingTest_Touchscreen_DragNum_One
356  * @tc.desc: Drag Drawing
357  * @tc.type: FUNC
358  * @tc.require:
359  */
360 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_Touchscreen_DragNum_One, TestSize.Level1)
361 {
362     CALL_TEST_DEBUG;
363     std::promise<bool> promiseFlag;
364     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70602(const DragNotifyMsg &notifyMessage) 365     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
366         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, target:%{public}d, result:%{public}d",
367             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.targetPid, notifyMessage.result);
368         promiseFlag.set_value(true);
369     };
370     std::optional<DragData> dragData = CreateDragData(
371         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
372     ASSERT_TRUE(dragData);
373     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
374         std::make_shared<TestStartDragListener>(callback));
375     ASSERT_EQ(ret, RET_OK);
376     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
377     ASSERT_EQ(ret, RET_OK);
378     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
379     ASSERT_EQ(ret, RET_OK);
380     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
381     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
382     ASSERT_EQ(ret, RET_OK);
383     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
384     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
385     ASSERT_EQ(ret, RET_OK);
386     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
387     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::FORBIDDEN);
388     ASSERT_EQ(ret, RET_OK);
389     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
390     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
391     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
392     ASSERT_EQ(ret, RET_OK);
393     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
394 }
395 
396 /**
397  * @tc.name: InteractionDragDrawingTest_Touchscreen_DragNum_Two
398  * @tc.desc: Drag Drawing
399  * @tc.type: FUNC
400  * @tc.require:
401  */
402 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_Touchscreen_DragNum_Two, TestSize.Level1)
403 {
404     CALL_TEST_DEBUG;
405     std::promise<bool> promiseFlag;
406     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70702(const DragNotifyMsg &notifyMessage) 407     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
408         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, target:%{public}d, result:%{public}d",
409             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.targetPid, notifyMessage.result);
410         promiseFlag.set_value(true);
411     };
412     std::optional<DragData> dragData = CreateDragData(
413         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_TWO, false, SHADOW_NUM_TWO);
414     ASSERT_TRUE(dragData);
415     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
416         std::make_shared<TestStartDragListener>(callback));
417     ASSERT_EQ(ret, RET_OK);
418     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
419     ASSERT_EQ(ret, RET_OK);
420     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
421     ASSERT_EQ(ret, RET_OK);
422     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
423     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
424     ASSERT_EQ(ret, RET_OK);
425     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
426     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
427     ASSERT_EQ(ret, RET_OK);
428     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
429     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::FORBIDDEN);
430     ASSERT_EQ(ret, RET_OK);
431     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
432     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
433     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
434     ASSERT_EQ(ret, RET_OK);
435     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
436 }
437 
438 /**
439  * @tc.name: InteractionDragDrawingTest_Touchscreen_DragNum_Three
440  * @tc.desc: Drag Drawing
441  * @tc.type: FUNC
442  * @tc.require:
443  */
444 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_Touchscreen_DragNum_Three, TestSize.Level1)
445 {
446     CALL_TEST_DEBUG;
447     std::promise<bool> promiseFlag;
448     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70802(const DragNotifyMsg &notifyMessage) 449     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
450         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, target:%{public}d, result:%{public}d",
451             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.targetPid, notifyMessage.result);
452         promiseFlag.set_value(true);
453     };
454     std::optional<DragData> dragData = CreateDragData(
455         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_THREE, false, SHADOW_NUM_THREE);
456     ASSERT_TRUE(dragData);
457     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
458         std::make_shared<TestStartDragListener>(callback));
459     ASSERT_EQ(ret, RET_OK);
460     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
461     ASSERT_EQ(ret, RET_OK);
462     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
463     ASSERT_EQ(ret, RET_OK);
464     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
465     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
466     ASSERT_EQ(ret, RET_OK);
467     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
468     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
469     ASSERT_EQ(ret, RET_OK);
470     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
471     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::FORBIDDEN);
472     ASSERT_EQ(ret, RET_OK);
473     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
474     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
475     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
476     ASSERT_EQ(ret, RET_OK);
477     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
478 }
479 
480 /**
481  * @tc.name: InteractionDragDrawingTest_Touchscreen_DragNum_Multiple
482  * @tc.desc: Drag Drawing
483  * @tc.type: FUNC
484  * @tc.require:
485  */
486 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_Touchscreen_DragNum_Multiple, TestSize.Level1)
487 {
488     CALL_TEST_DEBUG;
489     std::optional<DragData> dragData = CreateDragData(
490         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_MULTIPLE, false, SHADOW_NUM_MULTIPLE);
491     ASSERT_TRUE(dragData);
492     std::promise<bool> promiseFlag;
493     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70902(const DragNotifyMsg &notifyMessage) 494     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
495         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
496             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
497         promiseFlag.set_value(true);
498     };
499     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
500         std::make_shared<TestStartDragListener>(callback));
501     ASSERT_EQ(ret, RET_OK);
502     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
503     ASSERT_EQ(ret, RET_OK);
504     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
505     ASSERT_EQ(ret, RET_OK);
506     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
507     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::DEFAULT);
508     ASSERT_EQ(ret, RET_OK);
509     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
510     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::FORBIDDEN);
511     ASSERT_EQ(ret, RET_OK);
512     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
513     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
514     ASSERT_EQ(ret, RET_OK);
515     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
516     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
517     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
518     ASSERT_EQ(ret, RET_OK);
519     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
520 }
521 
522 /**
523  * @tc.name: InteractionDragDrawingTest_UpdateShadowPic
524  * @tc.desc: Drag Drawing
525  * @tc.type: FUNC
526  * @tc.require:
527  */
528 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_UpdateShadowPic, TestSize.Level1)
529 {
530     CALL_TEST_DEBUG;
531     std::promise<bool> promiseFlag;
532     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70a02(const DragNotifyMsg &notifyMessage) 533     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
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_MOUSE, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
540     ASSERT_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::shared_ptr<Media::PixelMap> pixelMap = CreatePixelMap(MIDDLE_PIXEL_MAP_WIDTH, MIDDLE_PIXEL_MAP_HEIGHT);
545     ASSERT_NE(pixelMap, nullptr);
546     ShadowInfo shadowInfo = { pixelMap, 0, 0 };
547     ret = InteractionManager::GetInstance()->UpdateShadowPic(shadowInfo);
548     ASSERT_EQ(ret, RET_OK);
549     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
550     ASSERT_EQ(ret, RET_OK);
551     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
552     ASSERT_EQ(ret, RET_OK);
553     DragDropResult dropResult { DragResult::DRAG_FAIL, HAS_CUSTOM_ANIMATION, WINDOW_ID };
554     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
555     ASSERT_EQ(ret, RET_OK);
556     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
557     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_ANIMATION_END));
558 }
559 
560 /**
561  * @tc.name: InteractionDragDrawingTest_AddSelectedPixelMap_001
562  * @tc.desc: Drag Drawing
563  * @tc.type: FUNC
564  * @tc.require:
565  */
566 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_AddSelectedPixelMap_001, TestSize.Level1)
567 {
568     CALL_TEST_DEBUG;
569     std::promise<bool> promiseFlag;
570     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70b02(const DragNotifyMsg &notifyMessage) 571     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
572         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
573             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
574         promiseFlag.set_value(true);
575     };
576     std::optional<DragData> dragData = CreateDragData(
577         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
578     ASSERT_TRUE(dragData);
579     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
580         std::make_shared<TestStartDragListener>(callback));
581     ASSERT_EQ(ret, RET_OK);
582     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
583     ASSERT_EQ(ret, RET_OK);
584     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
585     ASSERT_EQ(ret, RET_OK);
586     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
587     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
588     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
589     ASSERT_EQ(ret, RET_OK);
590     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
591 }
592 
593 /**
594  * @tc.name: InteractionDragDrawingTest_AddSelectedPixelMap_002
595  * @tc.desc: Drag Drawing
596  * @tc.type: FUNC
597  * @tc.require:
598  */
599 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_AddSelectedPixelMap_002, TestSize.Level1)
600 {
601     CALL_TEST_DEBUG;
602     std::promise<bool> promiseFlag;
603     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70c02(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_MOUSE, POINTER_ID, DRAG_NUM_TWO, false, SHADOW_NUM_TWO);
611     ASSERT_TRUE(dragData);
612     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
613         std::make_shared<TestStartDragListener>(callback));
614     ASSERT_EQ(ret, RET_OK);
615     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
616     ASSERT_EQ(ret, RET_OK);
617     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
618     ASSERT_EQ(ret, RET_OK);
619     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
620     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
621     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
622     ASSERT_EQ(ret, RET_OK);
623     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
624 }
625 
626 /**
627  * @tc.name: InteractionDragDrawingTest_AddSelectedPixelMap_003
628  * @tc.desc: Drag Drawing
629  * @tc.type: FUNC
630  * @tc.require:
631  */
632 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_AddSelectedPixelMap_003, TestSize.Level1)
633 {
634     CALL_TEST_DEBUG;
635     std::promise<bool> promiseFlag;
636     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70d02(const DragNotifyMsg &notifyMessage) 637     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
638         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
639             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
640         promiseFlag.set_value(true);
641     };
642     std::optional<DragData> dragData = CreateDragData(
643         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_THREE, false, SHADOW_NUM_THREE);
644     ASSERT_TRUE(dragData);
645     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
646         std::make_shared<TestStartDragListener>(callback));
647     ASSERT_EQ(ret, RET_OK);
648     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
649     ASSERT_EQ(ret, RET_OK);
650     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
651     ASSERT_EQ(ret, RET_OK);
652     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
653     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
654     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
655     ASSERT_EQ(ret, RET_OK);
656     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
657 }
658 
659 /**
660  * @tc.name: InteractionDragDrawingTest_AddSelectedPixelMap_004
661  * @tc.desc: Drag Drawing
662  * @tc.type: FUNC
663  * @tc.require:
664  */
665 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_AddSelectedPixelMap_004, TestSize.Level1)
666 {
667     CALL_TEST_DEBUG;
668     std::promise<bool> promiseFlag;
669     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70e02(const DragNotifyMsg &notifyMessage) 670     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
671         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
672             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
673         promiseFlag.set_value(true);
674     };
675     std::optional<DragData> dragData = CreateDragData(
676         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_THREE, false, SHADOW_NUM_THREE);
677     ASSERT_TRUE(dragData);
678     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
679         std::make_shared<TestStartDragListener>(callback));
680     ASSERT_EQ(ret, RET_OK);
681     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
682     ASSERT_EQ(ret, RET_OK);
683     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
684     ASSERT_EQ(ret, RET_OK);
685     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
686     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
687     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
688     ASSERT_EQ(ret, RET_OK);
689     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
690 }
691 
692 /**
693  * @tc.name: InteractionDragDrawingTest_AddSelectedPixelMap_005
694  * @tc.desc: Drag Drawing
695  * @tc.type: FUNC
696  * @tc.require:
697  */
698 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_AddSelectedPixelMap_005, TestSize.Level1)
699 {
700     CALL_TEST_DEBUG;
701     std::optional<DragData> dragData = CreateDragData(
702         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_THREE, false, SHADOW_NUM_THREE);
703     ASSERT_TRUE(dragData);
704     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(), nullptr);
705     ASSERT_EQ(ret, RET_ERR);
706     DragDropResult dropResult { DragResult::DRAG_FAIL, HAS_CUSTOM_ANIMATION, WINDOW_ID };
707     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
708     ASSERT_EQ(ret, RET_ERR);
709 }
710 
711 /**
712  * @tc.name: InteractionDragDrawingTest_AddSelectedPixelMap_006
713  * @tc.desc: Drag Drawing
714  * @tc.type: FUNC
715  * @tc.require:
716  */
717 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_AddSelectedPixelMap_006, TestSize.Level1)
718 {
719     CALL_TEST_DEBUG;
720     std::promise<bool> promiseFlag;
721     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d70f02(const DragNotifyMsg &notifyMessage) 722     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
723         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
724             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
725         promiseFlag.set_value(true);
726     };
727     std::optional<DragData> dragData = CreateDragData(
728         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
729     ASSERT_TRUE(dragData);
730     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
731         std::make_shared<TestStartDragListener>(callback));
732     ASSERT_EQ(ret, RET_OK);
733     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
734     ASSERT_EQ(ret, RET_OK);
735     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
736     ASSERT_EQ(ret, RET_OK);
737     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
738     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
739     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
740     ASSERT_EQ(ret, RET_OK);
741     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
742 }
743 
744 /**
745  * @tc.name: InteractionDragDrawingTest_AddSelectedPixelMap_007
746  * @tc.desc: Drag Drawing
747  * @tc.type: FUNC
748  * @tc.require:
749  */
750 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_AddSelectedPixelMap_007, TestSize.Level1)
751 {
752     CALL_TEST_DEBUG;
753     std::promise<bool> promiseFlag;
754     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71002(const DragNotifyMsg &notifyMessage) 755     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
756         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
757             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
758         promiseFlag.set_value(true);
759     };
760     std::optional<DragData> dragData = CreateDragData(
761         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_TWO, false, SHADOW_NUM_TWO);
762     ASSERT_TRUE(dragData);
763     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
764         std::make_shared<TestStartDragListener>(callback));
765     ASSERT_EQ(ret, RET_OK);
766     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
767     ASSERT_EQ(ret, RET_OK);
768     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
769     ASSERT_EQ(ret, RET_OK);
770     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
771     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
772     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
773     ASSERT_EQ(ret, RET_OK);
774     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
775 }
776 
777 /**
778  * @tc.name: InteractionDragDrawingTest_AddSelectedPixelMap_008
779  * @tc.desc: Drag Drawing
780  * @tc.type: FUNC
781  * @tc.require:
782  */
783 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_AddSelectedPixelMap_008, TestSize.Level1)
784 {
785     CALL_TEST_DEBUG;
786     std::promise<bool> promiseFlag;
787     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71102(const DragNotifyMsg &notifyMessage) 788     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
789         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
790             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
791         promiseFlag.set_value(true);
792     };
793     std::optional<DragData> dragData = CreateDragData(
794         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_THREE, false, SHADOW_NUM_THREE);
795     ASSERT_TRUE(dragData);
796     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
797         std::make_shared<TestStartDragListener>(callback));
798     ASSERT_EQ(ret, RET_OK);
799     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
800     ASSERT_EQ(ret, RET_OK);
801     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
802     ASSERT_EQ(ret, RET_OK);
803     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
804     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
805     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
806     ASSERT_EQ(ret, RET_OK);
807     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
808 }
809 
810 /**
811  * @tc.name: InteractionDragDrawingTest_AddSelectedPixelMap_009
812  * @tc.desc: Drag Drawing
813  * @tc.type: FUNC
814  * @tc.require:
815  */
816 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_AddSelectedPixelMap_009, TestSize.Level1)
817 {
818     CALL_TEST_DEBUG;
819     std::promise<bool> promiseFlag;
820     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71202(const DragNotifyMsg &notifyMessage) 821     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
822         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
823             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
824         promiseFlag.set_value(true);
825     };
826     std::optional<DragData> dragData = CreateDragData(
827         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_THREE, false, SHADOW_NUM_THREE);
828     ASSERT_TRUE(dragData);
829     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
830         std::make_shared<TestStartDragListener>(callback));
831     ASSERT_EQ(ret, RET_OK);
832     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
833     ASSERT_EQ(ret, RET_OK);
834     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::MOVE);
835     ASSERT_EQ(ret, RET_OK);
836     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
837     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
838     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
839     ASSERT_EQ(ret, RET_OK);
840     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
841 }
842 
843 /**
844  * @tc.name: InteractionDragDrawingTest_AddSelectedPixelMap_010
845  * @tc.desc: Drag Drawing
846  * @tc.type: FUNC
847  * @tc.require:
848  */
849 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_AddSelectedPixelMap_010, TestSize.Level1)
850 {
851     CALL_TEST_DEBUG;
852     std::optional<DragData> dragData = CreateDragData(
853         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_THREE, false, SHADOW_NUM_THREE);
854     ASSERT_TRUE(dragData);
855     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(), nullptr);
856     ASSERT_EQ(ret, RET_ERR);
857     DragDropResult dropResult { DragResult::DRAG_FAIL, HAS_CUSTOM_ANIMATION, WINDOW_ID };
858     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
859     ASSERT_EQ(ret, RET_ERR);
860 }
861 
862 /**
863  * @tc.name: InteractionDragDrawingTest_Mouse_Animation
864  * @tc.desc: Drag Drawing
865  * @tc.type: FUNC
866  * @tc.require:
867  */
868 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_Mouse_Animation, TestSize.Level1)
869 {
870     CALL_TEST_DEBUG;
871     std::promise<bool> promiseFlag;
872     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71302(const DragNotifyMsg &notifyMessage) 873     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
874         FI_HILOGD("result:%{public}d, target:%{public}d, displayX:%{public}d, displayY:%{public}d",
875             notifyMessage.result, notifyMessage.targetPid, notifyMessage.displayX, notifyMessage.displayY);
876         promiseFlag.set_value(true);
877     };
878     std::optional<DragData> dragData = CreateDragData(
879         MMI::PointerEvent::SOURCE_TYPE_MOUSE, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
880     ASSERT_TRUE(dragData);
881     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
882         std::make_shared<TestStartDragListener>(callback));
883     ASSERT_EQ(ret, RET_OK);
884     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
885     ASSERT_EQ(ret, RET_OK);
886     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
887     ASSERT_EQ(ret, RET_OK);
888     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
889     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
890     ASSERT_EQ(ret, RET_OK);
891     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
892     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_ANIMATION_END));
893 }
894 
895 /**
896  * @tc.name: InteractionDragDrawingTest_Touchscreen_Animation
897  * @tc.desc: Drag Drawing
898  * @tc.type: FUNC
899  * @tc.require:
900  */
901 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_Touchscreen_Animation, TestSize.Level1)
902 {
903     CALL_TEST_DEBUG;
904     std::promise<bool> promiseFlag;
905     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71402(const DragNotifyMsg &notifyMessage) 906     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
907         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, target:%{public}d, result:%{public}d",
908             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.targetPid, notifyMessage.result);
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     ASSERT_TRUE(dragData);
914     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
915         std::make_shared<TestStartDragListener>(callback));
916     ASSERT_EQ(ret, RET_OK);
917     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
918     ASSERT_EQ(ret, RET_OK);
919     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
920     ASSERT_EQ(ret, RET_OK);
921     DragDropResult dropResult { DragResult::DRAG_FAIL, HAS_CUSTOM_ANIMATION, WINDOW_ID };
922     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
923     ASSERT_EQ(ret, RET_OK);
924     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
925 }
926 
927 /**
928  * @tc.name: InteractionDragDrawingTest_Multiple_Shadow
929  * @tc.desc: Drag Drawing
930  * @tc.type: FUNC
931  * @tc.require:
932  */
933 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_ONE_Shadow, TestSize.Level1)
934 {
935     CALL_TEST_DEBUG;
936     std::promise<bool> promiseFlag;
937     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71502(const DragNotifyMsg &notifyMessage) 938     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
939         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
940             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
941         promiseFlag.set_value(true);
942     };
943     std::optional<DragData> dragData = CreateDragData(
944         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
945     ASSERT_TRUE(dragData);
946     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
947         std::make_shared<TestStartDragListener>(callback));
948     ASSERT_EQ(ret, RET_OK);
949     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
950     ASSERT_EQ(ret, RET_OK);
951     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
952     ASSERT_EQ(ret, RET_OK);
953     DragDropResult dropResult { DragResult::DRAG_FAIL, HAS_CUSTOM_ANIMATION, WINDOW_ID };
954     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
955     ASSERT_EQ(ret, RET_OK);
956     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
957 }
958 
959 /**
960  * @tc.name: InteractionDragDrawingTest_Multiple_Shadow
961  * @tc.desc: Drag Drawing
962  * @tc.type: FUNC
963  * @tc.require:
964  */
965 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_Multiple_Shadow, TestSize.Level1)
966 {
967     CALL_TEST_DEBUG;
968     std::promise<bool> promiseFlag;
969     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71602(const DragNotifyMsg &notifyMessage) 970     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
971         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
972             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
973         promiseFlag.set_value(true);
974     };
975     std::optional<DragData> dragData = CreateDragData(
976         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_THREE);
977     ASSERT_TRUE(dragData);
978     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
979         std::make_shared<TestStartDragListener>(callback));
980     ASSERT_EQ(ret, RET_OK);
981     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
982     ASSERT_EQ(ret, RET_OK);
983     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
984     ASSERT_EQ(ret, RET_OK);
985     DragDropResult dropResult { DragResult::DRAG_FAIL, HAS_CUSTOM_ANIMATION, WINDOW_ID };
986     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
987     ASSERT_EQ(ret, RET_OK);
988     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
989 }
990 
991 /**
992  * @tc.name: InteractionDragDrawingTest_Multiple_Shadow
993  * @tc.desc: Drag Drawing
994  * @tc.type: FUNC
995  * @tc.require:
996  */
997 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_Too_Much_Shadow, TestSize.Level1)
998 {
999     CALL_TEST_DEBUG;
1000     std::promise<bool> promiseFlag;
1001     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71702(const DragNotifyMsg &notifyMessage) 1002     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
1003         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1004             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1005         promiseFlag.set_value(true);
1006     };
1007     std::optional<DragData> dragData = CreateDragData(
1008         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_TOO_MUCH);
1009     ASSERT_TRUE(dragData);
1010     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1011         std::make_shared<TestStartDragListener>(callback));
1012     ASSERT_EQ(ret, RET_OK);
1013     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
1014     ASSERT_EQ(ret, RET_OK);
1015     ret = InteractionManager::GetInstance()->UpdateDragStyle(DragCursorStyle::COPY);
1016     ASSERT_EQ(ret, RET_OK);
1017     DragDropResult dropResult { DragResult::DRAG_FAIL, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1018     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1019     ASSERT_EQ(ret, RET_OK);
1020     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1021 }
1022 
1023 /**
1024  * @tc.name: EnterTextEditorArea001
1025  * @tc.desc: normal test for pixelMap 8dp bit movement effect
1026  * @tc.type: FUNC
1027  * @tc.require:
1028  */
1029 HWTEST_F(InteractionDragDrawingTest, EnterTextEditorArea001, TestSize.Level1)
1030 {
1031     CALL_TEST_DEBUG;
1032     std::promise<bool> promiseFlag;
1033     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71802(const DragNotifyMsg &notifyMessage) 1034     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
1035         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1036             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1037         promiseFlag.set_value(true);
1038     };
1039     std::optional<DragData> dragData = CreateDragData(
1040         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
1041     ASSERT_TRUE(dragData);
1042     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1043         std::make_shared<TestStartDragListener>(callback));
1044     ASSERT_EQ(ret, RET_OK);
1045     ret = InteractionManager::GetInstance()->EnterTextEditorArea(true);
1046     EXPECT_EQ(ret, RET_OK);
1047     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_ANIMATION_END));
1048     ret = InteractionManager::GetInstance()->EnterTextEditorArea(false);
1049     EXPECT_EQ(ret, RET_OK);
1050     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1051     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1052     ASSERT_EQ(ret, RET_OK);
1053     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1054 }
1055 
1056 /**
1057  * @tc.name: EnterTextEditorArea002
1058  * @tc.desc: abnormal test for pixelMap 8dp bit movement effect
1059  * @tc.type: FUNC
1060  * @tc.require:
1061  */
1062 HWTEST_F(InteractionDragDrawingTest, EnterTextEditorArea002, TestSize.Level1)
1063 {
1064     CALL_TEST_DEBUG;
1065     std::promise<bool> promiseFlag;
1066     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71902(const DragNotifyMsg &notifyMessage) 1067     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
1068         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d, target:%{public}d",
1069             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result, notifyMessage.targetPid);
1070         promiseFlag.set_value(true);
1071     };
1072     std::optional<DragData> dragData = CreateDragData(
1073         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, false, SHADOW_NUM_ONE);
1074     ASSERT_TRUE(dragData);
1075     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1076         std::make_shared<TestStartDragListener>(callback));
1077     ASSERT_EQ(ret, RET_OK);
1078     ret = InteractionManager::GetInstance()->EnterTextEditorArea(false);
1079     EXPECT_EQ(ret, RET_ERR);
1080     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1081     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1082     ASSERT_EQ(ret, RET_OK);
1083     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1084 }
1085 
1086 /**
1087  * @tc.name: EnterTextEditorArea003
1088  * @tc.desc: abnormal test for pixelMap 8dp bit movement effect
1089  * @tc.type: FUNC
1090  * @tc.require:
1091  */
1092 HWTEST_F(InteractionDragDrawingTest, EnterTextEditorArea003, TestSize.Level1)
1093 {
1094     CALL_TEST_DEBUG;
1095     std::optional<DragData> dragData = CreateDragData(
1096         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_ONE, true, SHADOW_NUM_ONE);
1097     ASSERT_TRUE(dragData);
1098     int32_t ret = InteractionManager::GetInstance()->EnterTextEditorArea(true);
1099     EXPECT_EQ(ret, RET_ERR);
1100 }
1101 
1102 /**
1103  * @tc.name: InteractionDragDrawingTest_DragOpacity001
1104  * @tc.desc: Abnormal transparency test for drag and drop backboard
1105  * @tc.type: FUNC
1106  * @tc.require:
1107  */
1108 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_DragOpacity001, TestSize.Level1)
1109 {
1110     CALL_TEST_DEBUG;
1111     std::optional<DragData> dragData = CreateDragData(
1112         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_MULTIPLE, false, SHADOW_NUM_ONE);
1113     ASSERT_TRUE(dragData);
1114     dragData->filterInfo = " { \"dip_opacity\": nullptr } ";
1115     std::promise<bool> promiseFlag;
1116     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71a02(const DragNotifyMsg &notifyMessage) 1117     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
1118         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
1119             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
1120         promiseFlag.set_value(true);
1121     };
1122     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1123         std::make_shared<TestStartDragListener>(callback));
1124     ASSERT_EQ(ret, RET_OK);
1125     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
1126     ASSERT_EQ(ret, RET_OK);
1127     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
1128     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1129     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1130     ASSERT_EQ(ret, RET_OK);
1131     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1132 }
1133 
1134 /**
1135  * @tc.name: InteractionDragDrawingTest_DragOpacity002
1136  * @tc.desc: Abnormal transparency test for drag and drop backboard
1137  * @tc.type: FUNC
1138  * @tc.require:
1139  */
1140 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_DragOpacity002, TestSize.Level1)
1141 {
1142     CALL_TEST_DEBUG;
1143     std::optional<DragData> dragData = CreateDragData(
1144         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_MULTIPLE, false, SHADOW_NUM_ONE);
1145     ASSERT_TRUE(dragData);
1146     dragData->filterInfo = " { \"dip_opacity\": 3.0 } ";
1147     std::promise<bool> promiseFlag;
1148     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71b02(const DragNotifyMsg &notifyMessage) 1149     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
1150         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
1151             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
1152         promiseFlag.set_value(true);
1153     };
1154     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1155         std::make_shared<TestStartDragListener>(callback));
1156     ASSERT_EQ(ret, RET_OK);
1157     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
1158     ASSERT_EQ(ret, RET_OK);
1159     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
1160     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1161     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1162     ASSERT_EQ(ret, RET_OK);
1163     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1164 }
1165 
1166 /**
1167  * @tc.name: InteractionDragDrawingTest_DragOpacity003
1168  * @tc.desc: Normal transparency test for drag and drop backboard
1169  * @tc.type: FUNC
1170  * @tc.require:
1171  */
1172 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_DragOpacity003, TestSize.Level1)
1173 {
1174     CALL_TEST_DEBUG;
1175     std::optional<DragData> dragData = CreateDragData(
1176         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_MULTIPLE, false, SHADOW_NUM_ONE);
1177     ASSERT_TRUE(dragData);
1178     dragData->filterInfo = " { \"dip_opacity\": 0.60 } ";
1179     std::promise<bool> promiseFlag;
1180     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71c02(const DragNotifyMsg &notifyMessage) 1181     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
1182         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
1183             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
1184         promiseFlag.set_value(true);
1185     };
1186     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1187         std::make_shared<TestStartDragListener>(callback));
1188     ASSERT_EQ(ret, RET_OK);
1189     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
1190     ASSERT_EQ(ret, RET_OK);
1191     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
1192     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1193     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1194     ASSERT_EQ(ret, RET_OK);
1195     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1196 }
1197 
1198 /**
1199  * @tc.name: InteractionDragDrawingTest_DragCornerRadius001
1200  * @tc.desc: Abnormal rounded corner test for drag and drop backboard
1201  * @tc.type: FUNC
1202  * @tc.require:
1203  */
1204 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_DragCornerRadius001, TestSize.Level1)
1205 {
1206     CALL_TEST_DEBUG;
1207     std::optional<DragData> dragData = CreateDragData(
1208         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_MULTIPLE, false, SHADOW_NUM_ONE);
1209     ASSERT_TRUE(dragData);
1210     dragData->filterInfo = " { \"dip_scale\": 0.0, \"drag_corner_radius1\": 30.0, \"drag_corner_radius2\": 30.0, \
1211         \"drag_corner_radius3\": 30.0, \"drag_corner_radius4\": 30.0} ";
1212     std::promise<bool> promiseFlag;
1213     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71d02(const DragNotifyMsg &notifyMessage) 1214     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
1215         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
1216             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
1217         promiseFlag.set_value(true);
1218     };
1219     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1220         std::make_shared<TestStartDragListener>(callback));
1221     ASSERT_EQ(ret, RET_OK);
1222     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
1223     ASSERT_EQ(ret, RET_OK);
1224     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
1225     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1226     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1227     ASSERT_EQ(ret, RET_OK);
1228     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1229 }
1230 
1231 /**
1232  * @tc.name: InteractionDragDrawingTest_DragCornerRadius002
1233  * @tc.desc: Abnormal rounded corner test for drag and drop backboard
1234  * @tc.type: FUNC
1235  * @tc.require:
1236  */
1237 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_DragCornerRadius002, TestSize.Level1)
1238 {
1239     CALL_TEST_DEBUG;
1240     std::optional<DragData> dragData = CreateDragData(
1241         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_MULTIPLE, false, SHADOW_NUM_ONE);
1242     ASSERT_TRUE(dragData);
1243     dragData->filterInfo = " { \"dip_scale\": 3.5, \"drag_corner_radius1\": 0.0, \"drag_corner_radius2\": 0.0 , \
1244         \"drag_corner_radius3\": 0.0, \"drag_corner_radius4\": 0.0} ";
1245     std::promise<bool> promiseFlag;
1246     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71e02(const DragNotifyMsg &notifyMessage) 1247     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
1248         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
1249             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
1250         promiseFlag.set_value(true);
1251     };
1252     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1253         std::make_shared<TestStartDragListener>(callback));
1254     ASSERT_EQ(ret, RET_OK);
1255     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
1256     ASSERT_EQ(ret, RET_OK);
1257     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
1258     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1259     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1260     ASSERT_EQ(ret, RET_OK);
1261     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1262 }
1263 
1264 /**
1265  * @tc.name: InteractionDragDrawingTest_DragCornerRadius003
1266  * @tc.desc: Normal testing of dragging the rounded corners of the backboard
1267  * @tc.type: FUNC
1268  * @tc.require:
1269  */
1270 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_DragCornerRadius003, TestSize.Level1)
1271 {
1272     CALL_TEST_DEBUG;
1273     std::optional<DragData> dragData = CreateDragData(
1274         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_MULTIPLE, false, SHADOW_NUM_ONE);
1275     ASSERT_TRUE(dragData);
1276     dragData->filterInfo = " { \"dip_scale\": 3.5, \"drag_corner_radius1\": 30.0, \"drag_corner_radius2\":30.0, \
1277         \"drag_corner_radius3\": 30.0, \"drag_corner_radius4\": 30.0} ";
1278     std::promise<bool> promiseFlag;
1279     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d71f02(const DragNotifyMsg &notifyMessage) 1280     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
1281         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
1282             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
1283         promiseFlag.set_value(true);
1284     };
1285     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1286         std::make_shared<TestStartDragListener>(callback));
1287     ASSERT_EQ(ret, RET_OK);
1288     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
1289     ASSERT_EQ(ret, RET_OK);
1290     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
1291     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1292     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1293     ASSERT_EQ(ret, RET_OK);
1294     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1295 }
1296 
1297 /**
1298  * @tc.name: InteractionDragDrawingTest_DragCornerRadius004
1299  * @tc.desc: Normal testing of dragging the rounded corners of the backboard
1300  * @tc.type: FUNC
1301  * @tc.require:
1302  */
1303 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_DragCornerRadius004, TestSize.Level1)
1304 {
1305     CALL_TEST_DEBUG;
1306     std::optional<DragData> dragData = CreateDragData(
1307         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_MULTIPLE, false, SHADOW_NUM_ONE);
1308     ASSERT_TRUE(dragData);
1309     dragData->filterInfo = " { \"dip_scale\": 3.5, \"drag_corner_radius1\": 30.0, \"drag_corner_radius2\":80.0, \
1310         \"drag_corner_radius3\": 50.0, \"drag_corner_radius4\": 20.0} ";
1311     std::promise<bool> promiseFlag;
1312     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d72002(const DragNotifyMsg &notifyMessage) 1313     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
1314         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
1315             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
1316         promiseFlag.set_value(true);
1317     };
1318     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1319         std::make_shared<TestStartDragListener>(callback));
1320     ASSERT_EQ(ret, RET_OK);
1321     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
1322     ASSERT_EQ(ret, RET_OK);
1323     std::this_thread::sleep_for(std::chrono::milliseconds(TIME_WAIT_FOR_UPDATE_DRAG_STYLE));
1324     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1325     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1326     ASSERT_EQ(ret, RET_OK);
1327     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1328 }
1329 
1330 /**
1331  * @tc.name: InteractionDragDrawingTest_RotateDragWindowSync
1332  * @tc.desc: Rotate and drag the window to Synchronize
1333  * @tc.type: FUNC
1334  * @tc.require:
1335  */
1336 HWTEST_F(InteractionDragDrawingTest, InteractionDragDrawingTest_RotateDragWindowSync, TestSize.Level1)
1337 {
1338     CALL_TEST_DEBUG;
1339     std::optional<DragData> dragData = CreateDragData(
1340         MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, POINTER_ID, DRAG_NUM_MULTIPLE, false, SHADOW_NUM_ONE);
1341     ASSERT_TRUE(dragData);
1342     std::promise<bool> promiseFlag;
1343     std::future<bool> futureFlag = promiseFlag.get_future();
__anon16b5f8d72102(const DragNotifyMsg &notifyMessage) 1344     auto callback = [&promiseFlag](const DragNotifyMsg &notifyMessage) {
1345         FI_HILOGD("displayX:%{public}d, displayY:%{public}d, result:%{public}d",
1346             notifyMessage.displayX, notifyMessage.displayY, notifyMessage.result);
1347         promiseFlag.set_value(true);
1348     };
1349     int32_t ret = InteractionManager::GetInstance()->StartDrag(dragData.value(),
1350         std::make_shared<TestStartDragListener>(callback));
1351     ASSERT_EQ(ret, RET_OK);
1352     ret = InteractionManager::GetInstance()->SetDragWindowVisible(DRAG_WINDOW_VISIBLE);
1353     ASSERT_EQ(ret, RET_OK);
1354     const std::shared_ptr<Rosen::RSTransaction>& rsTransaction { nullptr };
1355     InteractionManager::GetInstance()->RotateDragWindowSync(rsTransaction);
1356     DragDropResult dropResult { DragResult::DRAG_SUCCESS, HAS_CUSTOM_ANIMATION, WINDOW_ID };
1357     ret = InteractionManager::GetInstance()->StopDrag(dropResult);
1358     ASSERT_EQ(ret, RET_OK);
1359     ASSERT_TRUE(futureFlag.wait_for(std::chrono::milliseconds(PROMISE_WAIT_SPAN_MS)) != std::future_status::timeout);
1360 }
1361 } // namespace DeviceStatus
1362 } // namespace Msdp
1363 } // namespace OHOS