1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <optional>
17
18 #include "gtest/gtest.h"
19
20 #include "test/mock/base/mock_drag_window.h"
21 #include "test/mock/core/common/mock_container.h"
22 #include "test/mock/core/common/mock_interaction_interface.h"
23 #include "test/mock/core/pipeline/mock_pipeline_context.h"
24
25 #include "base/image/pixel_map.h"
26 #include "base/memory/ace_type.h"
27 #include "base/memory/referenced.h"
28 #include "base/subwindow/subwindow_manager.h"
29 #include "core/common/interaction/interaction_interface.h"
30 #include "core/components/common/layout/grid_system_manager.h"
31 #include "core/components_ng/base/frame_node.h"
32 #include "core/components_ng/base/geometry_node.h"
33 #include "core/components_ng/base/ui_node.h"
34 #include "core/components_ng/event/event_hub.h"
35 #include "core/components_ng/manager/drag_drop/drag_drop_func_wrapper.h"
36 #include "core/components_ng/manager/drag_drop/drag_drop_manager.h"
37 #include "core/components_ng/manager/drag_drop/drag_drop_proxy.h"
38
39 using namespace testing;
40 using namespace testing::ext;
41 namespace OHOS::Ace::NG {
42 namespace {
43 RefPtr<DragWindow> MOCK_DRAG_WINDOW;
44 constexpr float DEFAULT_OPACITY = 0.95f;
45 constexpr float PARA_OPACITY_VALUE_1 = 0.3f;
46 constexpr float PARA_OPACITY_VALUE_2 = 0.0f;
47 constexpr float PARA_OPACITY_VALUE_3 = 0.5f;
48 constexpr float PARA_OPACITY_VALUE_4 = 0.7f;
49 constexpr float PARA_OPACITY_VALUE_5 = 1.0f;
50 constexpr float PARA_OPACITY_VALUE_6 = 10.0f;
51 constexpr float PARA_OPACITY_VALUE_7 = 50.0f;
52 constexpr float PARA_OPACITY_VALUE_8 = -50.0f;
53
54 constexpr float PARA_OPACITY_VALUE_9 = 0.1f;
55 constexpr float PARA_OPACITY_VALUE_10 = 0.2f;
56 constexpr float PARA_OPACITY_VALUE_11 = 0.4f;
57 constexpr float PARA_OPACITY_VALUE_12 = 0.6f;
58 constexpr float PARA_OPACITY_VALUE_13 = 0.8f;
59 constexpr float PARA_OPACITY_VALUE_14 = 0.9f;
60 constexpr float PARA_OPACITY_VALUE_15 = 1.1f;
61 constexpr float PARA_OPACITY_VALUE_16 = 1.2f;
62 constexpr float PARA_OPACITY_VALUE_17 = 1.3f;
63 constexpr float PARA_OPACITY_VALUE_18 = 1.4f;
64 constexpr float PARA_OPACITY_VALUE_19 = 1.5f;
65 constexpr float PARA_OPACITY_VALUE_20 = 1.6f;
66 constexpr float PARA_OPACITY_VALUE_21 = 1.7f;
67 constexpr float PARA_OPACITY_VALUE_22 = 1.8f;
68 constexpr float PARA_OPACITY_VALUE_23 = 1.9f;
69 constexpr float PARA_OPACITY_VALUE_24 = 2.0f;
70 constexpr float PARA_OPACITY_VALUE_25 = 2.1f;
71 constexpr float PARA_OPACITY_VALUE_26 = 2.2f;
72 constexpr float PARA_OPACITY_VALUE_27 = 2.3f;
73 constexpr float PARA_OPACITY_VALUE_28 = 2.4f;
74 constexpr float PARA_OPACITY_VALUE_29 = 2.5f;
75 constexpr float PARA_OPACITY_VALUE_30 = 2.6f;
76 constexpr float PARA_OPACITY_VALUE_31 = 2.7f;
77 constexpr float PARA_OPACITY_VALUE_32 = 2.8f;
78 constexpr float PARA_OPACITY_VALUE_33 = 2.9f;
79 constexpr float PARA_OPACITY_VALUE_34 = 3.0f;
80 constexpr float PARA_OPACITY_VALUE_35 = 3.1f;
81 constexpr float PARA_OPACITY_VALUE_36 = 3.2f;
82 constexpr float PARA_OPACITY_VALUE_37 = 3.3f;
83 constexpr float PARA_OPACITY_VALUE_38 = 3.4f;
84 constexpr float PARA_OPACITY_VALUE_39 = 3.5f;
85 constexpr float PARA_OPACITY_VALUE_40 = 3.6f;
86 constexpr float PARA_OPACITY_VALUE_41 = 3.7f;
87 constexpr float PARA_OPACITY_VALUE_42 = 3.8f;
88 constexpr float PARA_OPACITY_VALUE_43 = 3.9f;
89 constexpr float PARA_OPACITY_VALUE_44 = 4.0f;
90 constexpr float PARA_OPACITY_VALUE_45 = 4.1f;
91 constexpr float PARA_OPACITY_VALUE_46 = 4.2f;
92 constexpr float PARA_OPACITY_VALUE_47 = 4.3f;
93 constexpr float PARA_OPACITY_VALUE_48 = 4.4f;
94 constexpr float PARA_OPACITY_VALUE_49 = 4.5f;
95 constexpr float PARA_OPACITY_VALUE_50 = 4.6f;
96 constexpr float PARA_OPACITY_VALUE_51 = 4.7f;
97 constexpr float PARA_OPACITY_VALUE_52 = 4.8f;
98 constexpr float PARA_OPACITY_VALUE_53 = 4.9f;
99 constexpr float PARA_OPACITY_VALUE_54 = 5.0f;
100
101 constexpr float MIN_OPACITY { 0.0f };
102 constexpr float MAX_OPACITY { 1.0f };
103 } // namespace
104
105 class DragDropFuncWrapperTestNg : public testing::Test {
106 public:
107 static void SetUpTestCase();
108 static void TearDownTestCase();
109 };
110
SetUpTestCase()111 void DragDropFuncWrapperTestNg::SetUpTestCase()
112 {
113 MockPipelineContext::SetUp();
114 MockContainer::SetUp();
115 MOCK_DRAG_WINDOW = DragWindow::CreateDragWindow("", 0, 0, 0, 0);
116 }
117
TearDownTestCase()118 void DragDropFuncWrapperTestNg::TearDownTestCase()
119 {
120 MockPipelineContext::TearDown();
121 MockContainer::TearDown();
122 MOCK_DRAG_WINDOW = nullptr;
123 }
124
125 /**
126 * @tc.name: DragDropFuncWrapperTest001
127 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
128 * @tc.type: FUNC
129 * @tc.author:
130 */
131 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest001, TestSize.Level1)
132 {
133 /**
134 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.3f
135 */
__anonb21908c00202(WeakPtr<NG::FrameNode> frameNode) 136 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
137 auto node = frameNode.Upgrade();
138 CHECK_NULL_VOID(node);
139 if ((PARA_OPACITY_VALUE_1 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_1 > MIN_OPACITY)) {
140 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_1);
141 } else {
142 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
143 }
144 };
145
146 /**
147 * @tc.steps: step2. construct a DragPreviewOption object
148 */
149 NG::DragPreviewOption option;
150
151 /**
152 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
153 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.3f.
154 */
155 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
156 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_1);
157 }
158
159 /**
160 * @tc.name: DragDropFuncWrapperTest002
161 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
162 * @tc.type: FUNC
163 * @tc.author:
164 */
165 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest002, TestSize.Level1)
166 {
167 /**
168 * @tc.steps: step1. construct a lambda function, don't set drag preview opacity
169 */
__anonb21908c00302(WeakPtr<NG::FrameNode> frameNode) 170 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {};
171
172 /**
173 * @tc.steps: step2. construct a DragPreviewOption object
174 */
175 NG::DragPreviewOption option;
176
177 /**
178 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
179 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
180 */
181 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
182 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
183 }
184
185 /**
186 * @tc.name: DragDropFuncWrapperTest003
187 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
188 * @tc.type: FUNC
189 * @tc.author:
190 */
191 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest003, TestSize.Level1)
192 {
193 /**
194 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.0f
195 */
__anonb21908c00402(WeakPtr<NG::FrameNode> frameNode) 196 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
197 auto node = frameNode.Upgrade();
198 CHECK_NULL_VOID(node);
199 if ((PARA_OPACITY_VALUE_2 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_2 > MIN_OPACITY)) {
200 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_2);
201 } else {
202 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
203 }
204 };
205
206 /**
207 * @tc.steps: step2. construct a DragPreviewOption object
208 */
209 NG::DragPreviewOption option;
210
211 /**
212 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
213 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
214 */
215 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
216 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
217 }
218
219 /**
220 * @tc.name: DragDropFuncWrapperTest004
221 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
222 * @tc.type: FUNC
223 * @tc.author:
224 */
225 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest004, TestSize.Level1)
226 {
227 /**
228 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.5f
229 */
__anonb21908c00502(WeakPtr<NG::FrameNode> frameNode) 230 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
231 auto node = frameNode.Upgrade();
232 CHECK_NULL_VOID(node);
233 if ((PARA_OPACITY_VALUE_3 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_3 > MIN_OPACITY)) {
234 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_3);
235 } else {
236 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
237 }
238 };
239
240 /**
241 * @tc.steps: step2. construct a DragPreviewOption object
242 */
243 NG::DragPreviewOption option;
244
245 /**
246 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
247 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.5f.
248 */
249 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
250 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_3);
251 }
252
253 /**
254 * @tc.name: DragDropFuncWrapperTest005
255 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
256 * @tc.type: FUNC
257 * @tc.author:
258 */
259 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest005, TestSize.Level1)
260 {
261 /**
262 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.7f
263 */
__anonb21908c00602(WeakPtr<NG::FrameNode> frameNode) 264 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
265 auto node = frameNode.Upgrade();
266 CHECK_NULL_VOID(node);
267 if ((PARA_OPACITY_VALUE_4 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_4 > MIN_OPACITY)) {
268 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_4);
269 } else {
270 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
271 }
272 };
273
274 /**
275 * @tc.steps: step2. construct a DragPreviewOption object
276 */
277 NG::DragPreviewOption option;
278
279 /**
280 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
281 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.7f.
282 */
283 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
284 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_4);
285 }
286
287 /**
288 * @tc.name: DragDropFuncWrapperTest006
289 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
290 * @tc.type: FUNC
291 * @tc.author:
292 */
293 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest006, TestSize.Level1)
294 {
295 /**
296 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.0f
297 */
__anonb21908c00702(WeakPtr<NG::FrameNode> frameNode) 298 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
299 auto node = frameNode.Upgrade();
300 CHECK_NULL_VOID(node);
301 if ((PARA_OPACITY_VALUE_5 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_5 > MIN_OPACITY)) {
302 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_5);
303 } else {
304 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
305 }
306 };
307
308 /**
309 * @tc.steps: step2. construct a DragPreviewOption object
310 */
311 NG::DragPreviewOption option;
312
313 /**
314 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
315 * @tc.expected: step3. opacity in DragPreviewOption is equal to 1.0f.
316 */
317 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
318 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_5);
319 }
320
321 /**
322 * @tc.name: DragDropFuncWrapperTest007
323 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
324 * @tc.type: FUNC
325 * @tc.author:
326 */
327 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest007, TestSize.Level1)
328 {
329 /**
330 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 10.0f
331 */
__anonb21908c00802(WeakPtr<NG::FrameNode> frameNode) 332 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
333 auto node = frameNode.Upgrade();
334 CHECK_NULL_VOID(node);
335 if ((PARA_OPACITY_VALUE_6 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_6 > MIN_OPACITY)) {
336 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_6);
337 } else {
338 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
339 }
340 };
341
342 /**
343 * @tc.steps: step2. construct a DragPreviewOption object
344 */
345 NG::DragPreviewOption option;
346
347 /**
348 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
349 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
350 */
351 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
352 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
353 }
354
355 /**
356 * @tc.name: DragDropFuncWrapperTest008
357 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
358 * @tc.type: FUNC
359 * @tc.author:
360 */
361 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest008, TestSize.Level1)
362 {
363 /**
364 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 50.0f
365 */
__anonb21908c00902(WeakPtr<NG::FrameNode> frameNode) 366 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
367 auto node = frameNode.Upgrade();
368 CHECK_NULL_VOID(node);
369 if ((PARA_OPACITY_VALUE_7 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_7 > MIN_OPACITY)) {
370 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_7);
371 } else {
372 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
373 }
374 };
375
376 /**
377 * @tc.steps: step2. construct a DragPreviewOption object
378 */
379 NG::DragPreviewOption option;
380
381 /**
382 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
383 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
384 */
385 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
386 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
387 }
388
389 /**
390 * @tc.name: DragDropFuncWrapperTest009
391 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
392 * @tc.type: FUNC
393 * @tc.author:
394 */
395 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest009, TestSize.Level1)
396 {
397 /**
398 * @tc.steps: step1. construct a lambda function, set drag preview opacity is -50.0f
399 */
__anonb21908c00a02(WeakPtr<NG::FrameNode> frameNode) 400 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
401 auto node = frameNode.Upgrade();
402 CHECK_NULL_VOID(node);
403 if ((PARA_OPACITY_VALUE_8 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_8 > MIN_OPACITY)) {
404 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_8);
405 } else {
406 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
407 }
408 };
409
410 /**
411 * @tc.steps: step2. construct a DragPreviewOption object
412 */
413 NG::DragPreviewOption option;
414
415 /**
416 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
417 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
418 */
419 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
420 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
421 }
422
423 /**
424 * @tc.name: DragDropFuncWrapperTest010
425 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
426 * @tc.type: FUNC
427 * @tc.author:
428 */
429 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest010, TestSize.Level1)
430 {
431 /**
432 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.1f
433 */
__anonb21908c00b02(WeakPtr<NG::FrameNode> frameNode) 434 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
435 auto node = frameNode.Upgrade();
436 CHECK_NULL_VOID(node);
437 if ((PARA_OPACITY_VALUE_9 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_9 > MIN_OPACITY)) {
438 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_9);
439 } else {
440 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
441 }
442 };
443
444 /**
445 * @tc.steps: step2. construct a DragPreviewOption object
446 */
447 NG::DragPreviewOption option;
448
449 /**
450 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
451 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.1f.
452 */
453 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
454 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_9);
455 }
456
457 /**
458 * @tc.name: DragDropFuncWrapperTest011
459 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
460 * @tc.type: FUNC
461 * @tc.author:
462 */
463 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest011, TestSize.Level1)
464 {
465 /**
466 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.2f
467 */
__anonb21908c00c02(WeakPtr<NG::FrameNode> frameNode) 468 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
469 auto node = frameNode.Upgrade();
470 CHECK_NULL_VOID(node);
471 if ((PARA_OPACITY_VALUE_10 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_10 > MIN_OPACITY)) {
472 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_10);
473 } else {
474 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
475 }
476 };
477
478 /**
479 * @tc.steps: step2. construct a DragPreviewOption object
480 */
481 NG::DragPreviewOption option;
482
483 /**
484 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
485 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.2f.
486 */
487 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
488 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_10);
489 }
490
491 /**
492 * @tc.name: DragDropFuncWrapperTest012
493 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
494 * @tc.type: FUNC
495 * @tc.author:
496 */
497 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest012, TestSize.Level1)
498 {
499 /**
500 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.4f
501 */
__anonb21908c00d02(WeakPtr<NG::FrameNode> frameNode) 502 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
503 auto node = frameNode.Upgrade();
504 CHECK_NULL_VOID(node);
505 if ((PARA_OPACITY_VALUE_11 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_11 > MIN_OPACITY)) {
506 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_11);
507 } else {
508 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
509 }
510 };
511
512 /**
513 * @tc.steps: step2. construct a DragPreviewOption object
514 */
515 NG::DragPreviewOption option;
516
517 /**
518 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
519 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.4f.
520 */
521 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
522 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_11);
523 }
524
525 /**
526 * @tc.name: DragDropFuncWrapperTest013
527 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
528 * @tc.type: FUNC
529 * @tc.author:
530 */
531 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest013, TestSize.Level1)
532 {
533 /**
534 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.6f
535 */
__anonb21908c00e02(WeakPtr<NG::FrameNode> frameNode) 536 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
537 auto node = frameNode.Upgrade();
538 CHECK_NULL_VOID(node);
539 if ((PARA_OPACITY_VALUE_12 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_12 > MIN_OPACITY)) {
540 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_12);
541 } else {
542 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
543 }
544 };
545
546 /**
547 * @tc.steps: step2. construct a DragPreviewOption object
548 */
549 NG::DragPreviewOption option;
550
551 /**
552 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
553 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.6f.
554 */
555 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
556 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_12);
557 }
558
559 /**
560 * @tc.name: DragDropFuncWrapperTest014
561 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
562 * @tc.type: FUNC
563 * @tc.author:
564 */
565 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest014, TestSize.Level1)
566 {
567 /**
568 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.8f
569 */
__anonb21908c00f02(WeakPtr<NG::FrameNode> frameNode) 570 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
571 auto node = frameNode.Upgrade();
572 CHECK_NULL_VOID(node);
573 if ((PARA_OPACITY_VALUE_13 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_13 > MIN_OPACITY)) {
574 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_13);
575 } else {
576 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
577 }
578 };
579
580 /**
581 * @tc.steps: step2. construct a DragPreviewOption object
582 */
583 NG::DragPreviewOption option;
584
585 /**
586 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
587 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.8f.
588 */
589 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
590 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_13);
591 }
592
593 /**
594 * @tc.name: DragDropFuncWrapperTest015
595 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
596 * @tc.type: FUNC
597 * @tc.author:
598 */
599 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest015, TestSize.Level1)
600 {
601 /**
602 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 0.9f
603 */
__anonb21908c01002(WeakPtr<NG::FrameNode> frameNode) 604 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
605 auto node = frameNode.Upgrade();
606 CHECK_NULL_VOID(node);
607 if ((PARA_OPACITY_VALUE_14 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_14 > MIN_OPACITY)) {
608 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_14);
609 } else {
610 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
611 }
612 };
613
614 /**
615 * @tc.steps: step2. construct a DragPreviewOption object
616 */
617 NG::DragPreviewOption option;
618
619 /**
620 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
621 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.9f.
622 */
623 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
624 EXPECT_EQ(option.options.opacity, PARA_OPACITY_VALUE_14);
625 }
626
627 /**
628 * @tc.name: DragDropFuncWrapperTest016
629 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
630 * @tc.type: FUNC
631 * @tc.author:
632 */
633 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest016, TestSize.Level1)
634 {
635 /**
636 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.1f
637 */
__anonb21908c01102(WeakPtr<NG::FrameNode> frameNode) 638 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
639 auto node = frameNode.Upgrade();
640 CHECK_NULL_VOID(node);
641 if ((PARA_OPACITY_VALUE_15 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_15 > MIN_OPACITY)) {
642 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_15);
643 } else {
644 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
645 }
646 };
647
648 /**
649 * @tc.steps: step2. construct a DragPreviewOption object
650 */
651 NG::DragPreviewOption option;
652
653 /**
654 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
655 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
656 */
657 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
658 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
659 }
660
661 /**
662 * @tc.name: DragDropFuncWrapperTest017
663 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
664 * @tc.type: FUNC
665 * @tc.author:
666 */
667 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest017, TestSize.Level1)
668 {
669 /**
670 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.2f
671 */
__anonb21908c01202(WeakPtr<NG::FrameNode> frameNode) 672 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
673 auto node = frameNode.Upgrade();
674 CHECK_NULL_VOID(node);
675 if ((PARA_OPACITY_VALUE_16 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_16 > MIN_OPACITY)) {
676 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_16);
677 } else {
678 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
679 }
680 };
681
682 /**
683 * @tc.steps: step2. construct a DragPreviewOption object
684 */
685 NG::DragPreviewOption option;
686
687 /**
688 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
689 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
690 */
691 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
692 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
693 }
694
695 /**
696 * @tc.name: DragDropFuncWrapperTest018
697 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
698 * @tc.type: FUNC
699 * @tc.author:
700 */
701 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest018, TestSize.Level1)
702 {
703 /**
704 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.3f
705 */
__anonb21908c01302(WeakPtr<NG::FrameNode> frameNode) 706 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
707 auto node = frameNode.Upgrade();
708 CHECK_NULL_VOID(node);
709 if ((PARA_OPACITY_VALUE_17 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_17 > MIN_OPACITY)) {
710 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_17);
711 } else {
712 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
713 }
714 };
715
716 /**
717 * @tc.steps: step2. construct a DragPreviewOption object
718 */
719 NG::DragPreviewOption option;
720
721 /**
722 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
723 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
724 */
725 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
726 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
727 }
728
729 /**
730 * @tc.name: DragDropFuncWrapperTest019
731 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
732 * @tc.type: FUNC
733 * @tc.author:
734 */
735 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest019, TestSize.Level1)
736 {
737 /**
738 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.4f
739 */
__anonb21908c01402(WeakPtr<NG::FrameNode> frameNode) 740 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
741 auto node = frameNode.Upgrade();
742 CHECK_NULL_VOID(node);
743 if ((PARA_OPACITY_VALUE_18 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_18 > MIN_OPACITY)) {
744 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_18);
745 } else {
746 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
747 }
748 };
749
750 /**
751 * @tc.steps: step2. construct a DragPreviewOption object
752 */
753 NG::DragPreviewOption option;
754
755 /**
756 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
757 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
758 */
759 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
760 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
761 }
762
763 /**
764 * @tc.name: DragDropFuncWrapperTest020
765 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
766 * @tc.type: FUNC
767 * @tc.author:
768 */
769 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest020, TestSize.Level1)
770 {
771 /**
772 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.5f
773 */
__anonb21908c01502(WeakPtr<NG::FrameNode> frameNode) 774 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
775 auto node = frameNode.Upgrade();
776 CHECK_NULL_VOID(node);
777 if ((PARA_OPACITY_VALUE_19 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_19 > MIN_OPACITY)) {
778 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_19);
779 } else {
780 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
781 }
782 };
783
784 /**
785 * @tc.steps: step2. construct a DragPreviewOption object
786 */
787 NG::DragPreviewOption option;
788
789 /**
790 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
791 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
792 */
793 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
794 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
795 }
796
797 /**
798 * @tc.name: DragDropFuncWrapperTest021
799 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
800 * @tc.type: FUNC
801 * @tc.author:
802 */
803 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest021, TestSize.Level1)
804 {
805 /**
806 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.6f
807 */
__anonb21908c01602(WeakPtr<NG::FrameNode> frameNode) 808 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
809 auto node = frameNode.Upgrade();
810 CHECK_NULL_VOID(node);
811 if ((PARA_OPACITY_VALUE_20 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_20 > MIN_OPACITY)) {
812 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_20);
813 } else {
814 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
815 }
816 };
817
818 /**
819 * @tc.steps: step2. construct a DragPreviewOption object
820 */
821 NG::DragPreviewOption option;
822
823 /**
824 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
825 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
826 */
827 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
828 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
829 }
830
831 /**
832 * @tc.name: DragDropFuncWrapperTest022
833 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
834 * @tc.type: FUNC
835 * @tc.author:
836 */
837 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest022, TestSize.Level1)
838 {
839 /**
840 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.7f
841 */
__anonb21908c01702(WeakPtr<NG::FrameNode> frameNode) 842 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
843 auto node = frameNode.Upgrade();
844 CHECK_NULL_VOID(node);
845 if ((PARA_OPACITY_VALUE_21 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_21 > MIN_OPACITY)) {
846 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_21);
847 } else {
848 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
849 }
850 };
851
852 /**
853 * @tc.steps: step2. construct a DragPreviewOption object
854 */
855 NG::DragPreviewOption option;
856
857 /**
858 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
859 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
860 */
861 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
862 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
863 }
864
865 /**
866 * @tc.name: DragDropFuncWrapperTest023
867 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
868 * @tc.type: FUNC
869 * @tc.author:
870 */
871 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest023, TestSize.Level1)
872 {
873 /**
874 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.8f
875 */
__anonb21908c01802(WeakPtr<NG::FrameNode> frameNode) 876 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
877 auto node = frameNode.Upgrade();
878 CHECK_NULL_VOID(node);
879 if ((PARA_OPACITY_VALUE_22 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_22 > MIN_OPACITY)) {
880 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_22);
881 } else {
882 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
883 }
884 };
885
886 /**
887 * @tc.steps: step2. construct a DragPreviewOption object
888 */
889 NG::DragPreviewOption option;
890
891 /**
892 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
893 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
894 */
895 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
896 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
897 }
898
899 /**
900 * @tc.name: DragDropFuncWrapperTest024
901 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
902 * @tc.type: FUNC
903 * @tc.author:
904 */
905 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest024, TestSize.Level1)
906 {
907 /**
908 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 1.9f
909 */
__anonb21908c01902(WeakPtr<NG::FrameNode> frameNode) 910 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
911 auto node = frameNode.Upgrade();
912 CHECK_NULL_VOID(node);
913 if ((PARA_OPACITY_VALUE_23 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_23 > MIN_OPACITY)) {
914 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_23);
915 } else {
916 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
917 }
918 };
919
920 /**
921 * @tc.steps: step2. construct a DragPreviewOption object
922 */
923 NG::DragPreviewOption option;
924
925 /**
926 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
927 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
928 */
929 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
930 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
931 }
932
933 /**
934 * @tc.name: DragDropFuncWrapperTest025
935 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
936 * @tc.type: FUNC
937 * @tc.author:
938 */
939 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest025, TestSize.Level1)
940 {
941 /**
942 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.0f
943 */
__anonb21908c01a02(WeakPtr<NG::FrameNode> frameNode) 944 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
945 auto node = frameNode.Upgrade();
946 CHECK_NULL_VOID(node);
947 if ((PARA_OPACITY_VALUE_24 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_24 > MIN_OPACITY)) {
948 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_24);
949 } else {
950 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
951 }
952 };
953
954 /**
955 * @tc.steps: step2. construct a DragPreviewOption object
956 */
957 NG::DragPreviewOption option;
958
959 /**
960 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
961 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
962 */
963 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
964 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
965 }
966
967 /**
968 * @tc.name: DragDropFuncWrapperTest026
969 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
970 * @tc.type: FUNC
971 * @tc.author:
972 */
973 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest026, TestSize.Level1)
974 {
975 /**
976 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.1f
977 */
__anonb21908c01b02(WeakPtr<NG::FrameNode> frameNode) 978 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
979 auto node = frameNode.Upgrade();
980 CHECK_NULL_VOID(node);
981 if ((PARA_OPACITY_VALUE_25 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_25 > MIN_OPACITY)) {
982 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_25);
983 } else {
984 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
985 }
986 };
987
988 /**
989 * @tc.steps: step2. construct a DragPreviewOption object
990 */
991 NG::DragPreviewOption option;
992
993 /**
994 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
995 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
996 */
997 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
998 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
999 }
1000
1001 /**
1002 * @tc.name: DragDropFuncWrapperTest027
1003 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1004 * @tc.type: FUNC
1005 * @tc.author:
1006 */
1007 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest027, TestSize.Level1)
1008 {
1009 /**
1010 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.2f
1011 */
__anonb21908c01c02(WeakPtr<NG::FrameNode> frameNode) 1012 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1013 auto node = frameNode.Upgrade();
1014 CHECK_NULL_VOID(node);
1015 if ((PARA_OPACITY_VALUE_26 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_26 > MIN_OPACITY)) {
1016 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_26);
1017 } else {
1018 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1019 }
1020 };
1021
1022 /**
1023 * @tc.steps: step2. construct a DragPreviewOption object
1024 */
1025 NG::DragPreviewOption option;
1026
1027 /**
1028 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1029 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1030 */
1031 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1032 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1033 }
1034
1035 /**
1036 * @tc.name: DragDropFuncWrapperTest028
1037 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1038 * @tc.type: FUNC
1039 * @tc.author:
1040 */
1041 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest028, TestSize.Level1)
1042 {
1043 /**
1044 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.3f
1045 */
__anonb21908c01d02(WeakPtr<NG::FrameNode> frameNode) 1046 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1047 auto node = frameNode.Upgrade();
1048 CHECK_NULL_VOID(node);
1049 if ((PARA_OPACITY_VALUE_27 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_27 > MIN_OPACITY)) {
1050 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_27);
1051 } else {
1052 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1053 }
1054 };
1055
1056 /**
1057 * @tc.steps: step2. construct a DragPreviewOption object
1058 */
1059 NG::DragPreviewOption option;
1060
1061 /**
1062 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1063 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1064 */
1065 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1066 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1067 }
1068
1069 /**
1070 * @tc.name: DragDropFuncWrapperTest029
1071 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1072 * @tc.type: FUNC
1073 * @tc.author:
1074 */
1075 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest029, TestSize.Level1)
1076 {
1077 /**
1078 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.4f
1079 */
__anonb21908c01e02(WeakPtr<NG::FrameNode> frameNode) 1080 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1081 auto node = frameNode.Upgrade();
1082 CHECK_NULL_VOID(node);
1083 if ((PARA_OPACITY_VALUE_28 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_28 > MIN_OPACITY)) {
1084 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_28);
1085 } else {
1086 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1087 }
1088 };
1089
1090 /**
1091 * @tc.steps: step2. construct a DragPreviewOption object
1092 */
1093 NG::DragPreviewOption option;
1094
1095 /**
1096 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1097 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1098 */
1099 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1100 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1101 }
1102
1103 /**
1104 * @tc.name: DragDropFuncWrapperTest030
1105 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1106 * @tc.type: FUNC
1107 * @tc.author:
1108 */
1109 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest030, TestSize.Level1)
1110 {
1111 /**
1112 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.5f
1113 */
__anonb21908c01f02(WeakPtr<NG::FrameNode> frameNode) 1114 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1115 auto node = frameNode.Upgrade();
1116 CHECK_NULL_VOID(node);
1117 if ((PARA_OPACITY_VALUE_29 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_29 > MIN_OPACITY)) {
1118 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_29);
1119 } else {
1120 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1121 }
1122 };
1123
1124 /**
1125 * @tc.steps: step2. construct a DragPreviewOption object
1126 */
1127 NG::DragPreviewOption option;
1128
1129 /**
1130 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1131 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1132 */
1133 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1134 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1135 }
1136
1137 /**
1138 * @tc.name: DragDropFuncWrapperTest031
1139 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1140 * @tc.type: FUNC
1141 * @tc.author:
1142 */
1143 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest031, TestSize.Level1)
1144 {
1145 /**
1146 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.6f
1147 */
__anonb21908c02002(WeakPtr<NG::FrameNode> frameNode) 1148 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1149 auto node = frameNode.Upgrade();
1150 CHECK_NULL_VOID(node);
1151 if ((PARA_OPACITY_VALUE_30 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_30 > MIN_OPACITY)) {
1152 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_30);
1153 } else {
1154 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1155 }
1156 };
1157
1158 /**
1159 * @tc.steps: step2. construct a DragPreviewOption object
1160 */
1161 NG::DragPreviewOption option;
1162
1163 /**
1164 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1165 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1166 */
1167 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1168 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1169 }
1170
1171 /**
1172 * @tc.name: DragDropFuncWrapperTest032
1173 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1174 * @tc.type: FUNC
1175 * @tc.author:
1176 */
1177 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest032, TestSize.Level1)
1178 {
1179 /**
1180 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.7f
1181 */
__anonb21908c02102(WeakPtr<NG::FrameNode> frameNode) 1182 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1183 auto node = frameNode.Upgrade();
1184 CHECK_NULL_VOID(node);
1185 if ((PARA_OPACITY_VALUE_31 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_31 > MIN_OPACITY)) {
1186 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_31);
1187 } else {
1188 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1189 }
1190 };
1191
1192 /**
1193 * @tc.steps: step2. construct a DragPreviewOption object
1194 */
1195 NG::DragPreviewOption option;
1196
1197 /**
1198 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1199 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1200 */
1201 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1202 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1203 }
1204
1205 /**
1206 * @tc.name: DragDropFuncWrapperTest033
1207 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1208 * @tc.type: FUNC
1209 * @tc.author:
1210 */
1211 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest033, TestSize.Level1)
1212 {
1213 /**
1214 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.8f
1215 */
__anonb21908c02202(WeakPtr<NG::FrameNode> frameNode) 1216 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1217 auto node = frameNode.Upgrade();
1218 CHECK_NULL_VOID(node);
1219 if ((PARA_OPACITY_VALUE_32 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_32 > MIN_OPACITY)) {
1220 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_32);
1221 } else {
1222 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1223 }
1224 };
1225
1226 /**
1227 * @tc.steps: step2. construct a DragPreviewOption object
1228 */
1229 NG::DragPreviewOption option;
1230
1231 /**
1232 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1233 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1234 */
1235 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1236 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1237 }
1238
1239 /**
1240 * @tc.name: DragDropFuncWrapperTest034
1241 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1242 * @tc.type: FUNC
1243 * @tc.author:
1244 */
1245 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest034, TestSize.Level1)
1246 {
1247 /**
1248 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 2.9f
1249 */
__anonb21908c02302(WeakPtr<NG::FrameNode> frameNode) 1250 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1251 auto node = frameNode.Upgrade();
1252 CHECK_NULL_VOID(node);
1253 if ((PARA_OPACITY_VALUE_33 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_33 > MIN_OPACITY)) {
1254 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_33);
1255 } else {
1256 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1257 }
1258 };
1259
1260 /**
1261 * @tc.steps: step2. construct a DragPreviewOption object
1262 */
1263 NG::DragPreviewOption option;
1264
1265 /**
1266 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1267 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1268 */
1269 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1270 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1271 }
1272
1273 /**
1274 * @tc.name: DragDropFuncWrapperTest035
1275 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1276 * @tc.type: FUNC
1277 * @tc.author:
1278 */
1279 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest035, TestSize.Level1)
1280 {
1281 /**
1282 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.0f
1283 */
__anonb21908c02402(WeakPtr<NG::FrameNode> frameNode) 1284 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1285 auto node = frameNode.Upgrade();
1286 CHECK_NULL_VOID(node);
1287 if ((PARA_OPACITY_VALUE_34 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_34 > MIN_OPACITY)) {
1288 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_34);
1289 } else {
1290 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1291 }
1292 };
1293
1294 /**
1295 * @tc.steps: step2. construct a DragPreviewOption object
1296 */
1297 NG::DragPreviewOption option;
1298
1299 /**
1300 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1301 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1302 */
1303 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1304 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1305 }
1306
1307 /**
1308 * @tc.name: DragDropFuncWrapperTest036
1309 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1310 * @tc.type: FUNC
1311 * @tc.author:
1312 */
1313 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest036, TestSize.Level1)
1314 {
1315 /**
1316 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.1f
1317 */
__anonb21908c02502(WeakPtr<NG::FrameNode> frameNode) 1318 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1319 auto node = frameNode.Upgrade();
1320 CHECK_NULL_VOID(node);
1321 if ((PARA_OPACITY_VALUE_35 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_35 > MIN_OPACITY)) {
1322 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_35);
1323 } else {
1324 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1325 }
1326 };
1327
1328 /**
1329 * @tc.steps: step2. construct a DragPreviewOption object
1330 */
1331 NG::DragPreviewOption option;
1332
1333 /**
1334 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1335 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1336 */
1337 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1338 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1339 }
1340
1341 /**
1342 * @tc.name: DragDropFuncWrapperTest037
1343 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1344 * @tc.type: FUNC
1345 * @tc.author:
1346 */
1347 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest037, TestSize.Level1)
1348 {
1349 /**
1350 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.2f
1351 */
__anonb21908c02602(WeakPtr<NG::FrameNode> frameNode) 1352 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1353 auto node = frameNode.Upgrade();
1354 CHECK_NULL_VOID(node);
1355 if ((PARA_OPACITY_VALUE_36 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_36 > MIN_OPACITY)) {
1356 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_36);
1357 } else {
1358 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1359 }
1360 };
1361
1362 /**
1363 * @tc.steps: step2. construct a DragPreviewOption object
1364 */
1365 NG::DragPreviewOption option;
1366
1367 /**
1368 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1369 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1370 */
1371 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1372 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1373 }
1374
1375 /**
1376 * @tc.name: DragDropFuncWrapperTest038
1377 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1378 * @tc.type: FUNC
1379 * @tc.author:
1380 */
1381 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest038, TestSize.Level1)
1382 {
1383 /**
1384 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.3f
1385 */
__anonb21908c02702(WeakPtr<NG::FrameNode> frameNode) 1386 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1387 auto node = frameNode.Upgrade();
1388 CHECK_NULL_VOID(node);
1389 if ((PARA_OPACITY_VALUE_37 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_37 > MIN_OPACITY)) {
1390 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_37);
1391 } else {
1392 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1393 }
1394 };
1395
1396 /**
1397 * @tc.steps: step2. construct a DragPreviewOption object
1398 */
1399 NG::DragPreviewOption option;
1400
1401 /**
1402 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1403 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1404 */
1405 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1406 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1407 }
1408
1409 /**
1410 * @tc.name: DragDropFuncWrapperTest039
1411 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1412 * @tc.type: FUNC
1413 * @tc.author:
1414 */
1415 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest039, TestSize.Level1)
1416 {
1417 /**
1418 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.4f
1419 */
__anonb21908c02802(WeakPtr<NG::FrameNode> frameNode) 1420 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1421 auto node = frameNode.Upgrade();
1422 CHECK_NULL_VOID(node);
1423 if ((PARA_OPACITY_VALUE_38 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_38 > MIN_OPACITY)) {
1424 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_38);
1425 } else {
1426 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1427 }
1428 };
1429
1430 /**
1431 * @tc.steps: step2. construct a DragPreviewOption object
1432 */
1433 NG::DragPreviewOption option;
1434
1435 /**
1436 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1437 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1438 */
1439 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1440 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1441 }
1442
1443 /**
1444 * @tc.name: DragDropFuncWrapperTest040
1445 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1446 * @tc.type: FUNC
1447 * @tc.author:
1448 */
1449 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest040, TestSize.Level1)
1450 {
1451 /**
1452 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.5f
1453 */
__anonb21908c02902(WeakPtr<NG::FrameNode> frameNode) 1454 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1455 auto node = frameNode.Upgrade();
1456 CHECK_NULL_VOID(node);
1457 if ((PARA_OPACITY_VALUE_39 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_39 > MIN_OPACITY)) {
1458 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_39);
1459 } else {
1460 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1461 }
1462 };
1463
1464 /**
1465 * @tc.steps: step2. construct a DragPreviewOption object
1466 */
1467 NG::DragPreviewOption option;
1468
1469 /**
1470 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1471 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1472 */
1473 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1474 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1475 }
1476
1477 /**
1478 * @tc.name: DragDropFuncWrapperTest041
1479 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1480 * @tc.type: FUNC
1481 * @tc.author:
1482 */
1483 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest041, TestSize.Level1)
1484 {
1485 /**
1486 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.6f
1487 */
__anonb21908c02a02(WeakPtr<NG::FrameNode> frameNode) 1488 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1489 auto node = frameNode.Upgrade();
1490 CHECK_NULL_VOID(node);
1491 if ((PARA_OPACITY_VALUE_40 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_40 > MIN_OPACITY)) {
1492 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_40);
1493 } else {
1494 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1495 }
1496 };
1497
1498 /**
1499 * @tc.steps: step2. construct a DragPreviewOption object
1500 */
1501 NG::DragPreviewOption option;
1502
1503 /**
1504 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1505 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1506 */
1507 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1508 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1509 }
1510
1511 /**
1512 * @tc.name: DragDropFuncWrapperTest042
1513 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1514 * @tc.type: FUNC
1515 * @tc.author:
1516 */
1517 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest042, TestSize.Level1)
1518 {
1519 /**
1520 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.7f
1521 */
__anonb21908c02b02(WeakPtr<NG::FrameNode> frameNode) 1522 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1523 auto node = frameNode.Upgrade();
1524 CHECK_NULL_VOID(node);
1525 if ((PARA_OPACITY_VALUE_41 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_41 > MIN_OPACITY)) {
1526 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_41);
1527 } else {
1528 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1529 }
1530 };
1531
1532 /**
1533 * @tc.steps: step2. construct a DragPreviewOption object
1534 */
1535 NG::DragPreviewOption option;
1536
1537 /**
1538 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1539 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1540 */
1541 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1542 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1543 }
1544
1545 /**
1546 * @tc.name: DragDropFuncWrapperTest043
1547 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1548 * @tc.type: FUNC
1549 * @tc.author:
1550 */
1551 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest043, TestSize.Level1)
1552 {
1553 /**
1554 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.8f
1555 */
__anonb21908c02c02(WeakPtr<NG::FrameNode> frameNode) 1556 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1557 auto node = frameNode.Upgrade();
1558 CHECK_NULL_VOID(node);
1559 if ((PARA_OPACITY_VALUE_42 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_42 > MIN_OPACITY)) {
1560 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_42);
1561 } else {
1562 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1563 }
1564 };
1565
1566 /**
1567 * @tc.steps: step2. construct a DragPreviewOption object
1568 */
1569 NG::DragPreviewOption option;
1570
1571 /**
1572 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1573 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1574 */
1575 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1576 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1577 }
1578
1579 /**
1580 * @tc.name: DragDropFuncWrapperTest044
1581 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1582 * @tc.type: FUNC
1583 * @tc.author:
1584 */
1585 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest044, TestSize.Level1)
1586 {
1587 /**
1588 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 3.9f
1589 */
__anonb21908c02d02(WeakPtr<NG::FrameNode> frameNode) 1590 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1591 auto node = frameNode.Upgrade();
1592 CHECK_NULL_VOID(node);
1593 if ((PARA_OPACITY_VALUE_43 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_43 > MIN_OPACITY)) {
1594 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_43);
1595 } else {
1596 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1597 }
1598 };
1599
1600 /**
1601 * @tc.steps: step2. construct a DragPreviewOption object
1602 */
1603 NG::DragPreviewOption option;
1604
1605 /**
1606 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1607 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1608 */
1609 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1610 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1611 }
1612
1613 /**
1614 * @tc.name: DragDropFuncWrapperTest045
1615 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1616 * @tc.type: FUNC
1617 * @tc.author:
1618 */
1619 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest045, TestSize.Level1)
1620 {
1621 /**
1622 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.0f
1623 */
__anonb21908c02e02(WeakPtr<NG::FrameNode> frameNode) 1624 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1625 auto node = frameNode.Upgrade();
1626 CHECK_NULL_VOID(node);
1627 if ((PARA_OPACITY_VALUE_44 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_44 > MIN_OPACITY)) {
1628 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_44);
1629 } else {
1630 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1631 }
1632 };
1633
1634 /**
1635 * @tc.steps: step2. construct a DragPreviewOption object
1636 */
1637 NG::DragPreviewOption option;
1638
1639 /**
1640 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1641 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1642 */
1643 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1644 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1645 }
1646
1647 /**
1648 * @tc.name: DragDropFuncWrapperTest046
1649 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1650 * @tc.type: FUNC
1651 * @tc.author:
1652 */
1653 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest046, TestSize.Level1)
1654 {
1655 /**
1656 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.1f
1657 */
__anonb21908c02f02(WeakPtr<NG::FrameNode> frameNode) 1658 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1659 auto node = frameNode.Upgrade();
1660 CHECK_NULL_VOID(node);
1661 if ((PARA_OPACITY_VALUE_45 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_45 > MIN_OPACITY)) {
1662 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_45);
1663 } else {
1664 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1665 }
1666 };
1667
1668 /**
1669 * @tc.steps: step2. construct a DragPreviewOption object
1670 */
1671 NG::DragPreviewOption option;
1672
1673 /**
1674 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1675 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1676 */
1677 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1678 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1679 }
1680
1681 /**
1682 * @tc.name: DragDropFuncWrapperTest047
1683 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1684 * @tc.type: FUNC
1685 * @tc.author:
1686 */
1687 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest047, TestSize.Level1)
1688 {
1689 /**
1690 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.2f
1691 */
__anonb21908c03002(WeakPtr<NG::FrameNode> frameNode) 1692 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1693 auto node = frameNode.Upgrade();
1694 CHECK_NULL_VOID(node);
1695 if ((PARA_OPACITY_VALUE_46 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_46 > MIN_OPACITY)) {
1696 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_46);
1697 } else {
1698 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1699 }
1700 };
1701
1702 /**
1703 * @tc.steps: step2. construct a DragPreviewOption object
1704 */
1705 NG::DragPreviewOption option;
1706
1707 /**
1708 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1709 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1710 */
1711 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1712 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1713 }
1714
1715 /**
1716 * @tc.name: DragDropFuncWrapperTest048
1717 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1718 * @tc.type: FUNC
1719 * @tc.author:
1720 */
1721 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest048, TestSize.Level1)
1722 {
1723 /**
1724 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.3f
1725 */
__anonb21908c03102(WeakPtr<NG::FrameNode> frameNode) 1726 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1727 auto node = frameNode.Upgrade();
1728 CHECK_NULL_VOID(node);
1729 if ((PARA_OPACITY_VALUE_47 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_47 > MIN_OPACITY)) {
1730 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_47);
1731 } else {
1732 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1733 }
1734 };
1735
1736 /**
1737 * @tc.steps: step2. construct a DragPreviewOption object
1738 */
1739 NG::DragPreviewOption option;
1740
1741 /**
1742 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1743 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1744 */
1745 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1746 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1747 }
1748
1749 /**
1750 * @tc.name: DragDropFuncWrapperTest049
1751 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1752 * @tc.type: FUNC
1753 * @tc.author:
1754 */
1755 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest049, TestSize.Level1)
1756 {
1757 /**
1758 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.4f
1759 */
__anonb21908c03202(WeakPtr<NG::FrameNode> frameNode) 1760 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1761 auto node = frameNode.Upgrade();
1762 CHECK_NULL_VOID(node);
1763 if ((PARA_OPACITY_VALUE_48 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_48 > MIN_OPACITY)) {
1764 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_48);
1765 } else {
1766 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1767 }
1768 };
1769
1770 /**
1771 * @tc.steps: step2. construct a DragPreviewOption object
1772 */
1773 NG::DragPreviewOption option;
1774
1775 /**
1776 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1777 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1778 */
1779 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1780 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1781 }
1782
1783 /**
1784 * @tc.name: DragDropFuncWrapperTest050
1785 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1786 * @tc.type: FUNC
1787 * @tc.author:
1788 */
1789 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest050, TestSize.Level1)
1790 {
1791 /**
1792 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.5f
1793 */
__anonb21908c03302(WeakPtr<NG::FrameNode> frameNode) 1794 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1795 auto node = frameNode.Upgrade();
1796 CHECK_NULL_VOID(node);
1797 if ((PARA_OPACITY_VALUE_49 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_49 > MIN_OPACITY)) {
1798 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_49);
1799 } else {
1800 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1801 }
1802 };
1803
1804 /**
1805 * @tc.steps: step2. construct a DragPreviewOption object
1806 */
1807 NG::DragPreviewOption option;
1808
1809 /**
1810 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1811 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1812 */
1813 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1814 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1815 }
1816
1817 /**
1818 * @tc.name: DragDropFuncWrapperTest051
1819 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1820 * @tc.type: FUNC
1821 * @tc.author:
1822 */
1823 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest051, TestSize.Level1)
1824 {
1825 /**
1826 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.6f
1827 */
__anonb21908c03402(WeakPtr<NG::FrameNode> frameNode) 1828 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1829 auto node = frameNode.Upgrade();
1830 CHECK_NULL_VOID(node);
1831 if ((PARA_OPACITY_VALUE_50 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_50 > MIN_OPACITY)) {
1832 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_50);
1833 } else {
1834 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1835 }
1836 };
1837
1838 /**
1839 * @tc.steps: step2. construct a DragPreviewOption object
1840 */
1841 NG::DragPreviewOption option;
1842
1843 /**
1844 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1845 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1846 */
1847 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1848 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1849 }
1850
1851 /**
1852 * @tc.name: DragDropFuncWrapperTest052
1853 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1854 * @tc.type: FUNC
1855 * @tc.author:
1856 */
1857 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest052, TestSize.Level1)
1858 {
1859 /**
1860 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.7f
1861 */
__anonb21908c03502(WeakPtr<NG::FrameNode> frameNode) 1862 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1863 auto node = frameNode.Upgrade();
1864 CHECK_NULL_VOID(node);
1865 if ((PARA_OPACITY_VALUE_51 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_51 > MIN_OPACITY)) {
1866 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_51);
1867 } else {
1868 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1869 }
1870 };
1871
1872 /**
1873 * @tc.steps: step2. construct a DragPreviewOption object
1874 */
1875 NG::DragPreviewOption option;
1876
1877 /**
1878 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1879 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1880 */
1881 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1882 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1883 }
1884
1885 /**
1886 * @tc.name: DragDropFuncWrapperTest053
1887 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1888 * @tc.type: FUNC
1889 * @tc.author:
1890 */
1891 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest053, TestSize.Level1)
1892 {
1893 /**
1894 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.8f
1895 */
__anonb21908c03602(WeakPtr<NG::FrameNode> frameNode) 1896 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1897 auto node = frameNode.Upgrade();
1898 CHECK_NULL_VOID(node);
1899 if ((PARA_OPACITY_VALUE_52 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_52 > MIN_OPACITY)) {
1900 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_52);
1901 } else {
1902 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1903 }
1904 };
1905
1906 /**
1907 * @tc.steps: step2. construct a DragPreviewOption object
1908 */
1909 NG::DragPreviewOption option;
1910
1911 /**
1912 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1913 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1914 */
1915 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1916 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1917 }
1918
1919 /**
1920 * @tc.name: DragDropFuncWrapperTest054
1921 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1922 * @tc.type: FUNC
1923 * @tc.author:
1924 */
1925 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest054, TestSize.Level1)
1926 {
1927 /**
1928 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 4.9f
1929 */
__anonb21908c03702(WeakPtr<NG::FrameNode> frameNode) 1930 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1931 auto node = frameNode.Upgrade();
1932 CHECK_NULL_VOID(node);
1933 if ((PARA_OPACITY_VALUE_53 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_53 > MIN_OPACITY)) {
1934 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_53);
1935 } else {
1936 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1937 }
1938 };
1939
1940 /**
1941 * @tc.steps: step2. construct a DragPreviewOption object
1942 */
1943 NG::DragPreviewOption option;
1944
1945 /**
1946 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1947 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1948 */
1949 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1950 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1951 }
1952
1953 /**
1954 * @tc.name: DragDropFuncWrapperTest055
1955 * @tc.desc: Test UpdateDragPreviewOptionsFromModifier
1956 * @tc.type: FUNC
1957 * @tc.author:
1958 */
1959 HWTEST_F(DragDropFuncWrapperTestNg, DragDropFuncWrapperTest055, TestSize.Level1)
1960 {
1961 /**
1962 * @tc.steps: step1. construct a lambda function, set drag preview opacity is 5.0f
1963 */
__anonb21908c03802(WeakPtr<NG::FrameNode> frameNode) 1964 auto applyOnNodeSync = [](WeakPtr<NG::FrameNode> frameNode) {
1965 auto node = frameNode.Upgrade();
1966 CHECK_NULL_VOID(node);
1967 if ((PARA_OPACITY_VALUE_54 <= MAX_OPACITY) && (PARA_OPACITY_VALUE_54 > MIN_OPACITY)) {
1968 node->GetRenderContext()->UpdateOpacity(PARA_OPACITY_VALUE_54);
1969 } else {
1970 node->GetRenderContext()->UpdateOpacity(DEFAULT_OPACITY);
1971 }
1972 };
1973
1974 /**
1975 * @tc.steps: step2. construct a DragPreviewOption object
1976 */
1977 NG::DragPreviewOption option;
1978
1979 /**
1980 * @tc.steps: step3. call UpdateDragPreviewOptionsFromModifier
1981 * @tc.expected: step3. opacity in DragPreviewOption is equal to 0.95f.
1982 */
1983 NG::DragDropFuncWrapper::UpdateDragPreviewOptionsFromModifier(applyOnNodeSync, option);
1984 EXPECT_EQ(option.options.opacity, DEFAULT_OPACITY);
1985 }
1986
1987 } // namespace OHOS::Ace::NG
1988