1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "frameworks/bridge/declarative_frontend/engine/jsi/jsi_custom_env_view_white_list.h"
17 #include "gtest/gtest.h"
18 #include "napi/napi_runtime.cpp"
19 #include "native_interface.h"
20 #include "native_node_napi.h"
21 #include "native_type.h"
22 #include "node_model.h"
23 #include "node_model_safely.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 class NativeNodeNapiTest : public testing::Test {
29 public:
SetUpTestCase()30 static void SetUpTestCase() {};
TearDownTestCase()31 static void TearDownTestCase() {};
32 };
33
CallBack(uint64_t nanoTimestamp,uint32_t frameCount,void * userData)34 void CallBack(uint64_t nanoTimestamp, uint32_t frameCount, void* userData)
35 {
36 printf("nanoTimestamp = %llu\n", nanoTimestamp);
37 printf("frameCount = %d\n", frameCount);
38 if (userData) {
39 int* myData = (int*)userData;
40 printf("User data = %d\n", *myData);
41 }
42 }
43
44 /**
45 * @tc.name: NativeNodeNapiTest001
46 * @tc.desc: Test OH_ArkUI_GetContextFromNapiValue function.
47 * @tc.type: FUNC
48 */
49 HWTEST_F(NativeNodeNapiTest, NativeNodeNapiTest001, TestSize.Level1)
50 {
51 napi_env__* env = nullptr;
52 napi_value__* value = nullptr;
53 ArkUI_ContextHandle* context = nullptr;
54 int32_t code = OH_ArkUI_GetContextFromNapiValue(env, value, context);
55 EXPECT_EQ(code, 401);
56 }
57
58 /**
59 * @tc.name: NativeNodeNapiTest002
60 * @tc.desc: Test OH_ArkUI_GetNodeContentFromNapiValue function.
61 * @tc.type: FUNC
62 */
63 HWTEST_F(NativeNodeNapiTest, NativeNodeNapiTest002, TestSize.Level1)
64 {
65 napi_env__* env = nullptr;
66 napi_value__* value = nullptr;
67 ArkUI_NodeContentHandle* context = nullptr;
68 int32_t code = OH_ArkUI_GetNodeContentFromNapiValue(env, value, context);
69 EXPECT_EQ(code, 401);
70 }
71
72 /**
73 * @tc.name: NativeNodeNapiTest003
74 * @tc.desc: Test OH_ArkUI_GetNodeHandleFromNapiValue function.
75 * @tc.type: FUNC
76 */
77 HWTEST_F(NativeNodeNapiTest, NativeNodeNapiTest003, TestSize.Level1)
78 {
79 napi_env__* env = nullptr;
80 napi_value__* value = nullptr;
81 ArkUI_NodeHandle* context = nullptr;
82 int32_t code = OH_ArkUI_GetNodeHandleFromNapiValue(env, value, context);
83 EXPECT_EQ(code, 401);
84 }
85
86 /**
87 * @tc.name: NativeNodeNapiTest004
88 * @tc.desc: Test OH_ArkUI_QueryModuleInterfaceByName function.
89 * @tc.type: FUNC
90 */
91 HWTEST_F(NativeNodeNapiTest, NativeNodeNapiTest004, TestSize.Level1)
92 {
93 void* object = OH_ArkUI_QueryModuleInterfaceByName(static_cast<ArkUI_NativeAPIVariantKind>(-1), "");
94 EXPECT_EQ(object, nullptr);
95 }
96
97 /**
98 * @tc.name: NativeNodeNapiTest005
99 * @tc.desc: Test OH_ArkUI_QueryModuleInterfaceByName function.
100 * @tc.type: FUNC
101 */
102 HWTEST_F(NativeNodeNapiTest, NativeNodeNapiTest005, TestSize.Level1)
103 {
104 void* object = OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "");
105 EXPECT_EQ(object, nullptr);
106 }
107
108 /**
109 * @tc.name: NativeNodeNapiTest006
110 * @tc.desc: Test OH_ArkUI_QueryModuleInterfaceByName function.
111 * @tc.type: FUNC
112 */
113 HWTEST_F(NativeNodeNapiTest, NativeNodeNapiTest006, TestSize.Level1)
114 {
115 void* object = OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_DIALOG, "");
116 EXPECT_EQ(object, nullptr);
117 }
118
119 /**
120 * @tc.name: NativeNodeNapiTest007
121 * @tc.desc: Test OH_ArkUI_QueryModuleInterfaceByName function.
122 * @tc.type: FUNC
123 */
124 HWTEST_F(NativeNodeNapiTest, NativeNodeNapiTest007, TestSize.Level1)
125 {
126 void* object = OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_GESTURE, "");
127 EXPECT_EQ(object, nullptr);
128 }
129
130 /**
131 * @tc.name: NativeNodeNapiTest008
132 * @tc.desc: Test OH_ArkUI_QueryModuleInterfaceByName function.
133 * @tc.type: FUNC
134 */
135 HWTEST_F(NativeNodeNapiTest, NativeNodeNapiTest008, TestSize.Level1)
136 {
137 void* object = OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_ANIMATE, "");
138 EXPECT_EQ(object, nullptr);
139 }
140
141 /**
142 * @tc.name: NativeNodeNapiTest009
143 * @tc.desc: Test OH_ArkUI_QueryModuleInterfaceByName function.
144 * @tc.type: FUNC
145 */
146 HWTEST_F(NativeNodeNapiTest, NativeNodeNapiTest009, TestSize.Level1)
147 {
148 void* object = OH_ArkUI_QueryModuleInterfaceByName(
149 static_cast<ArkUI_NativeAPIVariantKind>(ARKUI_NATIVE_GESTURE + 1), "");
150 EXPECT_EQ(object, nullptr);
151 }
152
153 /**
154 * @tc.name: NativeNodeNapiTest010
155 * @tc.desc: Test OH_ArkUI_QueryModuleInterfaceByName function.
156 * @tc.type: FUNC
157 */
158 HWTEST_F(NativeNodeNapiTest, NativeNodeNapiTest010, TestSize.Level1)
159 {
160 void* object = OH_ArkUI_QueryModuleInterfaceByName(ARKUI_MULTI_THREAD_NATIVE_NODE, "");
161 EXPECT_EQ(object, nullptr);
162 object = OH_ArkUI_QueryModuleInterfaceByName(ARKUI_MULTI_THREAD_NATIVE_NODE, "ArkUI_NativeNodeAPI_1");
163 EXPECT_NE(object, nullptr);
164 }
165
166 /**
167 * @tc.name: NavigationAPITest001
168 * @tc.desc: Test OH_ArkUI_GetNavigationId function.
169 * @tc.type: FUNC
170 */
171 HWTEST_F(NativeNodeNapiTest, NavigationAPITest001, TestSize.Level1)
172 {
173 auto ret = OH_ArkUI_GetNavigationId(nullptr, nullptr, 0, nullptr);
174 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
175 }
176
177 /**
178 * @tc.name: NavigationAPITest002
179 * @tc.desc: Test OH_ArkUI_GetNavDestinationName function.
180 * @tc.type: FUNC
181 */
182 HWTEST_F(NativeNodeNapiTest, NavigationAPITest002, TestSize.Level1)
183 {
184 auto ret = OH_ArkUI_GetNavDestinationName(nullptr, nullptr, 0, nullptr);
185 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
186 }
187
188 /**
189 * @tc.name: NavigationAPITest003
190 * @tc.desc: Test OH_ArkUI_GetNavStackLength function.
191 * @tc.type: FUNC
192 */
193 HWTEST_F(NativeNodeNapiTest, NavigationAPITest003, TestSize.Level1)
194 {
195 auto ret = OH_ArkUI_GetNavStackLength(nullptr, nullptr);
196 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
197 }
198
199 /**
200 * @tc.name: NavigationAPITest004
201 * @tc.desc: Test OH_ArkUI_GetNavDestinationNameByIndex function.
202 * @tc.type: FUNC
203 */
204 HWTEST_F(NativeNodeNapiTest, NavigationAPITest004, TestSize.Level1)
205 {
206 auto ret = OH_ArkUI_GetNavDestinationNameByIndex(nullptr, 0, nullptr, 0, nullptr);
207 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
208 }
209
210 /**
211 * @tc.name: NavigationAPITest005
212 * @tc.desc: Test OH_ArkUI_GetNavDestinationId function.
213 * @tc.type: FUNC
214 */
215 HWTEST_F(NativeNodeNapiTest, NavigationAPITest005, TestSize.Level1)
216 {
217 auto ret = OH_ArkUI_GetNavDestinationId(nullptr, nullptr, 0, nullptr);
218 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
219 }
220
221 /**
222 * @tc.name: NavigationAPITest006
223 * @tc.desc: Test OH_ArkUI_GetNavDestinationState function.
224 * @tc.type: FUNC
225 */
226 HWTEST_F(NativeNodeNapiTest, NavigationAPITest006, TestSize.Level1)
227 {
228 auto ret = OH_ArkUI_GetNavDestinationState(nullptr, nullptr);
229 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
230 }
231
232 /**
233 * @tc.name: NavigationAPITest007
234 * @tc.desc: Test OH_ArkUI_GetNavDestinationIndex function.
235 * @tc.type: FUNC
236 */
237 HWTEST_F(NativeNodeNapiTest, NavigationAPITest007, TestSize.Level1)
238 {
239 auto ret = OH_ArkUI_GetNavDestinationIndex(nullptr, nullptr);
240 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
241 }
242
243 /**
244 * @tc.name: NavigationAPITest008
245 * @tc.desc: Test OH_ArkUI_GetNavDestinationParam function.
246 * @tc.type: FUNC
247 */
248 HWTEST_F(NativeNodeNapiTest, NavigationAPITest008, TestSize.Level1)
249 {
250 auto ret = OH_ArkUI_GetNavDestinationParam(nullptr);
251 EXPECT_EQ(ret, nullptr);
252 }
253
254 /**
255 * @tc.name: NavigationAPITest009
256 * @tc.desc: Test OH_ArkUI_GetRouterPageIndex function.
257 * @tc.type: FUNC
258 */
259 HWTEST_F(NativeNodeNapiTest, NavigationAPITest009, TestSize.Level1)
260 {
261 auto ret = OH_ArkUI_GetRouterPageIndex(nullptr, nullptr);
262 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
263 }
264
265 /**
266 * @tc.name: NavigationAPITest010
267 * @tc.desc: Test OH_ArkUI_GetRouterPageName function.
268 * @tc.type: FUNC
269 */
270 HWTEST_F(NativeNodeNapiTest, NavigationAPITest010, TestSize.Level1)
271 {
272 auto ret = OH_ArkUI_GetRouterPageName(nullptr, nullptr, 0, nullptr);
273 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
274 }
275
276 /**
277 * @tc.name: NavigationAPITest011
278 * @tc.desc: Test OH_ArkUI_GetRouterPagePath function.
279 * @tc.type: FUNC
280 */
281 HWTEST_F(NativeNodeNapiTest, NavigationAPITest011, TestSize.Level1)
282 {
283 auto ret = OH_ArkUI_GetRouterPagePath(nullptr, nullptr, 0, nullptr);
284 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
285 }
286
287 /**
288 * @tc.name: NavigationAPITest012
289 * @tc.desc: Test OH_ArkUI_GetRouterPageState function.
290 * @tc.type: FUNC
291 */
292 HWTEST_F(NativeNodeNapiTest, NavigationAPITest012, TestSize.Level1)
293 {
294 auto ret = OH_ArkUI_GetRouterPageState(nullptr, nullptr);
295 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
296 }
297
298 /**
299 * @tc.name: NavigationAPITest013
300 * @tc.desc: Test OH_ArkUI_GetRouterPageId function.
301 * @tc.type: FUNC
302 */
303 HWTEST_F(NativeNodeNapiTest, NavigationAPITest013, TestSize.Level1)
304 {
305 auto ret = OH_ArkUI_GetRouterPageId(nullptr, nullptr, 0, nullptr);
306 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
307 }
308
309 /**
310 * @tc.name: InitModuleForArkTSEnvAPITest001
311 * @tc.desc: Test OH_ArkUI_InitModuleForArkTSEnv function.
312 * @tc.type: FUNC
313 */
314 HWTEST_F(NativeNodeNapiTest, InitModuleForArkTSEnvAPITest001, TestSize.Level1)
315 {
316 NativeEngineMock engine;
317
318 /**
319 * @tc.steps: step1. Call OH_ArkUI_InitModuleForArkTSEnv with a null environment.
320 * @tc.expected: The return value should be ARKUI_ERROR_CODE_PARAM_INVALID.
321 */
322 auto ret = OH_ArkUI_InitModuleForArkTSEnv(nullptr);
323 EXPECT_EQ(ret, ARKUI_ERROR_CODE_PARAM_INVALID);
324
325 /**
326 * @tc.steps: step2. Call OH_ArkUI_InitModuleForArkTSEnv with a valid environment.
327 * @tc.expected: The return value should be ARKUI_ERROR_CODE_NO_ERROR.
328 */
329 ret = OH_ArkUI_InitModuleForArkTSEnv(napi_env(engine));
330 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
331
332 /**
333 * @tc.steps: step3. Call OH_ArkUI_InitModuleForArkTSEnv again with the same environment.
334 * @tc.expected: The return value should be ARKUI_ERROR_CODE_NO_ERROR.
335 */
336 ret = OH_ArkUI_InitModuleForArkTSEnv(napi_env(engine));
337 EXPECT_EQ(ret, ARKUI_ERROR_CODE_NO_ERROR);
338
339 /**
340 * @tc.steps: step4. Call OH_ArkUI_NotifyArkTSEnvDestroy.
341 */
342 OH_ArkUI_NotifyArkTSEnvDestroy(napi_env(engine));
343 OH_ArkUI_NotifyArkTSEnvDestroy(nullptr);
344 }
345
346 /**
347 * @tc.name: WhiteListInCustomEnvTest001
348 * @tc.desc: In custom env, white list check.
349 * @tc.type: FUNC
350 */
351 HWTEST_F(NativeNodeNapiTest, WhiteListInCustomEnvTest001, TestSize.Level1)
352 {
353 std::unordered_set<std::string> supportedTargetsInCustomEnvTest = {
354 "Flex",
355 "TextController",
356 "Text",
357 "Animator",
358 "SpringProp",
359 "SpringMotion",
360 "ScrollMotion",
361 "Span",
362 "NativeCustomSpan",
363 "SpanString",
364 "MutableSpanString",
365 "TextStyle",
366 "DecorationStyle",
367 "BaselineOffsetStyle",
368 "LetterSpacingStyle",
369 "UrlStyle",
370 "NativeGestureStyle",
371 "TextShadowSpan",
372 "BackgroundColorStyle",
373 "ImageAttachment",
374 "ParagraphStyleSpan",
375 "LineHeightSpan",
376 "TextLayout",
377 "Button",
378 "Canvas",
379 "LazyForEach",
380 "LazyVGridLayout",
381 "List",
382 "ListItem",
383 "ListItemGroup",
384 "LoadingProgress",
385 "Image",
386 "ImageAnimator",
387 "Counter",
388 "Progress",
389 "Column",
390 "Row",
391 "Grid",
392 "GridItem",
393 "GridContainer",
394 "Slider",
395 "Stack",
396 "ForEach",
397 "Divider",
398 "Swiper",
399 "Indicator",
400 "Panel",
401 "RepeatNative",
402 "RepeatVirtualScrollNative",
403 "RepeatVirtualScroll2Native",
404 "NativeNavPathStack",
405 "If",
406 "Scroll",
407 "ScrollBar",
408 "GridRow",
409 "GridCol",
410 "Stepper",
411 "StepperItem",
412 "Toggle",
413 "ToolBarItem",
414 "Blank",
415 "Calendar",
416 "Rect",
417 "Shape",
418 "Path",
419 "Circle",
420 "Line",
421 "Polygon",
422 "Polyline",
423 "Ellipse",
424 "Tabs",
425 "TabContent",
426 "TextPicker",
427 "TimePicker",
428 "DatePicker",
429 "PageTransitionEnter",
430 "PageTransitionExit",
431 "RowSplit",
432 "ColumnSplit",
433 "AlphabetIndexer",
434 "Hyperlink",
435 "Radio",
436 "ActionSheet",
437 "AlertDialog",
438 "ContextMenu",
439 "Particle",
440 "__KeyboardAvoid__",
441 "TextMenu",
442 "TextArea",
443 "TextInput",
444 "TextClock",
445 "SideBarContainer",
446 "DataPanel",
447 "Badge",
448 "Gauge",
449 "Marquee",
450 "Menu",
451 "MenuItem",
452 "MenuItemGroup",
453 "Gesture",
454 "TapGesture",
455 "LongPressGesture",
456 "PanGesture",
457 "SwipeGesture",
458 "PinchGesture",
459 "RotationGesture",
460 "GestureGroup",
461 "PanGestureOption",
462 "PanGestureOptions",
463 "NativeCustomDialogController",
464 "Scroller",
465 "ListScroller",
466 "SwiperController",
467 "IndicatorController",
468 "TabsController",
469 "CalendarController",
470 "CanvasRenderingContext2D",
471 "OffscreenCanvasRenderingContext2D",
472 "CanvasGradient",
473 "ImageData",
474 "Path2D",
475 "RenderingContextSettings",
476 "Matrix2D",
477 "CanvasPattern",
478 "DrawingRenderingContext",
479 "Search",
480 "Select",
481 "SearchController",
482 "TextClockController",
483 "Sheet",
484 "JSClipboard",
485 "PatternLock",
486 "PatternLockController",
487 "TextTimer",
488 "TextAreaController",
489 "TextInputController",
490 "TextTimerController",
491 "Checkbox",
492 "CheckboxGroup",
493 "Refresh",
494 "WaterFlow",
495 "FlowItem",
496 "RelativeContainer",
497 "__Common__",
498 "__Recycle__",
499 "LinearGradient",
500 "ImageSpan",
501 "RichEditor",
502 "RichEditorController",
503 "RichEditorStyledStringController",
504 "LayoutManager",
505 "NodeContainer",
506 "__JSBaseNode__",
507 "SymbolGlyph",
508 "SymbolSpan",
509 "ContainerSpan",
510 "__RectShape__",
511 "__CircleShape__",
512 "__EllipseShape__",
513 "__PathShape__",
514 "ContentSlot",
515 "ArkUINativeNodeContent",
516 "GestureRecognizer",
517 "EventTargetInfo",
518 "ScrollableTargetInfo",
519 "PanRecognizer",
520 "LinearIndicator",
521 "LinearIndicatorController",
522 "TapRecognizer",
523 "LongPressRecognizer",
524 "SwipeRecognizer",
525 "PinchRecognizer",
526 "RotationRecognizer",
527 "TouchRecognizer",
528 };
529 for (const auto& target : supportedTargetsInCustomEnvTest) {
530 EXPECT_NE(OHOS::Ace::Framework::supportedTargetsInCustomEnv.find(target),
531 OHOS::Ace::Framework::supportedTargetsInCustomEnv.end());
532 }
533 }
534
535 /**
536 * @tc.name: PostFrameCallbackAPITest001
537 * @tc.desc: Test OH_ArkUI_PostFrameCallback function.
538 * @tc.type: FUNC
539 */
540 HWTEST_F(NativeNodeNapiTest, PostFrameCallbackAPITest001, TestSize.Level1)
541 {
542 ArkUI_ContextHandle uiContext = new ArkUI_Context({.id=10000});
543 int userdata = 5;
544 auto ret = OH_ArkUI_PostFrameCallback(uiContext, &userdata, CallBack);
545 EXPECT_EQ(ret, ARKUI_ERROR_CODE_UI_CONTEXT_INVALID);
546 }
547
548 /**
549 * @tc.name: PostFrameCallbackAPITest002
550 * @tc.desc: Test OH_ArkUI_PostFrameCallback function.
551 * @tc.type: FUNC
552 */
553 HWTEST_F(NativeNodeNapiTest, PostFrameCallbackAPITest002, TestSize.Level1)
554 {
555 ArkUI_ContextHandle uiContext = new ArkUI_Context({.id=10000});
556 int userdata = 6;
557 auto ret = OH_ArkUI_PostFrameCallback(uiContext, &userdata, nullptr);
558 EXPECT_EQ(ret, ARKUI_ERROR_CODE_CALLBACK_INVALID);
559 }
560
561 /**
562 * @tc.name: PostFrameCallbackAPITest003
563 * @tc.desc: Test OH_ArkUI_PostFrameCallback function.
564 * @tc.type: FUNC
565 */
566 HWTEST_F(NativeNodeNapiTest, PostFrameCallbackAPITest003, TestSize.Level1)
567 {
568 int userdata = 7;
569 auto ret = OH_ArkUI_PostFrameCallback(nullptr, &userdata, CallBack);
570 EXPECT_EQ(ret, ARKUI_ERROR_CODE_UI_CONTEXT_INVALID);
571 }
572
573 /**
574 * @tc.name: OH_ArkUI_PostAsyncUITaskAPITest001
575 * @tc.desc: Test OH_ArkUI_PostAsyncUITask function.
576 * @tc.type: FUNC
577 */
578 HWTEST_F(NativeNodeNapiTest, OH_ArkUI_PostAsyncUITaskAPITest001, TestSize.Level1)
579 {
580 ArkUI_ContextHandle uiContext = new ArkUI_Context({.id=10000});
__anon2bbd585d0102(void* asyncUITaskData)581 auto ret = OH_ArkUI_PostAsyncUITask(uiContext, nullptr, [](void* asyncUITaskData){}, [](void* asyncUITaskData){});
582 EXPECT_NE(ret, ARKUI_ERROR_CODE_NO_ERROR);
583 }
584
585 /**
586 * @tc.name: OH_ArkUI_PostUITaskAPITest001
587 * @tc.desc: Test OH_ArkUI_PostUITask function.
588 * @tc.type: FUNC
589 */
590 HWTEST_F(NativeNodeNapiTest, OH_ArkUI_PostUITaskAPITest001, TestSize.Level1)
591 {
592 ArkUI_ContextHandle uiContext = new ArkUI_Context({.id=10000});
__anon2bbd585d0302(void* asyncUITaskData)593 auto ret = OH_ArkUI_PostUITask(uiContext, nullptr, [](void* asyncUITaskData){});
594 EXPECT_NE(ret, ARKUI_ERROR_CODE_NO_ERROR);
595 }
596
597 /**
598 * @tc.name: OH_ArkUI_PostUITaskAndWaitAPITest001
599 * @tc.desc: Test OH_ArkUI_PostUITaskAndWait function.
600 * @tc.type: FUNC
601 */
602 HWTEST_F(NativeNodeNapiTest, OH_ArkUI_PostUITaskAndWaitAPITest001, TestSize.Level1)
603 {
604 ArkUI_ContextHandle uiContext = new ArkUI_Context({.id=10000});
__anon2bbd585d0402(void* asyncUITaskData)605 auto ret = OH_ArkUI_PostUITaskAndWait(uiContext, nullptr, [](void* asyncUITaskData){});
606 EXPECT_NE(ret, ARKUI_ERROR_CODE_NO_ERROR);
607 }
608
609 /**
610 * @tc.name: GreatOrEqualTargetAPIVersion001
611 * @tc.desc: Test GreatOrEqualTargetAPIVersion function.
612 * @tc.type: FUNC
613 */
614 HWTEST_F(NativeNodeNapiTest, GreatOrEqualTargetAPIVersion001, TestSize.Level1)
615 {
616 ASSERT_TRUE(OHOS::Ace::NodeModel::InitialFullImpl());
617 auto ret = OHOS::Ace::AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(
618 OHOS::Ace::PlatformVersion::VERSION_TWELVE);
619 auto ret1 = OHOS::Ace::NodeModel::GreatOrEqualTargetAPIVersion(OHOS::Ace::PlatformVersion::VERSION_TWELVE);
620 EXPECT_EQ(ret, ret1);
621 }
622
623