1 /*
2 * Copyright (c) 2025 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 "gtest/gtest.h"
17 #include "vector"
18
19 #include "napi_runtime.cpp"
20 #include "core/common/resource/resource_manager.h"
21 #include "interfaces/napi/kits/utils/napi_utils.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS::Ace {
27
28 namespace {
29 const char TYPE_KEY[] = "type";
30 const char PARAMS_KEY[] = "params";
31 const char RESOURCE_ID_KEY[] = "id";
32 const char BUNDLE_NAME[] = "bundle";
33 const char MODULE_NAME[] = "module";
34 const char BUNDLE_NAME_KEY[] = "bundleName";
35 const char MODULE_NAME_KEY[] = "moduleName";
36 const char DYNAMIC_RES_STRING[] = "app.string.test";
37 constexpr int32_t DYNAMIC_ID = -1;
38 constexpr int32_t RESOURCE_ID = 16666666;
39 } // namespace
40
41 class NapiUtilsTest : public testing::Test {
42 public:
SetUpTestSuite()43 static void SetUpTestSuite() {}
TearDownTestSuite()44 static void TearDownTestSuite() {}
SetUp()45 void SetUp() {};
TearDown()46 void TearDown() {};
47 };
48
49
CreateDynamicV2ResourceObject(napi_env env)50 napi_value CreateDynamicV2ResourceObject(napi_env env)
51 {
52 napi_value typeNapi;
53 napi_value resIdNapi;
54 napi_value paramsNapi;
55 napi_value resStringNapi = Napi::CreateNapiString(env, DYNAMIC_RES_STRING);
56 napi_create_array(env, ¶msNapi);
57 napi_set_element(env, paramsNapi, 0, resStringNapi);
58 napi_create_int32(env, DYNAMIC_ID, &typeNapi);
59 napi_create_int32(env, DYNAMIC_ID, &resIdNapi);
60 napi_property_descriptor desc[] = {
61 DECLARE_NAPI_DEFAULT_PROPERTY(RESOURCE_ID_KEY, resIdNapi),
62 DECLARE_NAPI_DEFAULT_PROPERTY(TYPE_KEY, typeNapi),
63 DECLARE_NAPI_DEFAULT_PROPERTY(PARAMS_KEY, paramsNapi),
64 DECLARE_NAPI_DEFAULT_PROPERTY(BUNDLE_NAME_KEY, Napi::CreateNapiString(env, BUNDLE_NAME)),
65 DECLARE_NAPI_DEFAULT_PROPERTY(MODULE_NAME_KEY, Napi::CreateNapiString(env, MODULE_NAME)),
66 };
67 napi_value resObj;
68 napi_create_object_with_properties(env, &resObj, sizeof(desc) / sizeof(desc[0]), desc);
69 return resObj;
70 }
71
CreateDynamicV1ResourceObject(napi_env env)72 napi_value CreateDynamicV1ResourceObject(napi_env env)
73 {
74 napi_value paramsNapi;
75 napi_create_array(env, ¶msNapi);
76 napi_property_descriptor desc[] = {
77 DECLARE_NAPI_DEFAULT_PROPERTY(RESOURCE_ID_KEY, Napi::CreateNapiString(env, DYNAMIC_RES_STRING)),
78 DECLARE_NAPI_DEFAULT_PROPERTY(PARAMS_KEY, paramsNapi),
79 DECLARE_NAPI_DEFAULT_PROPERTY(BUNDLE_NAME_KEY, Napi::CreateNapiString(env, BUNDLE_NAME)),
80 DECLARE_NAPI_DEFAULT_PROPERTY(MODULE_NAME_KEY, Napi::CreateNapiString(env, MODULE_NAME)),
81 };
82 napi_value resObj;
83 napi_create_object_with_properties(env, &resObj, sizeof(desc) / sizeof(desc[0]), desc);
84 return resObj;
85 }
86
CreateBaseResourceObject(napi_env env,Napi::ResourceType type)87 napi_value CreateBaseResourceObject(napi_env env, Napi::ResourceType type)
88 {
89 napi_value typeNapi;
90 napi_value resIdNapi;
91 napi_value paramsNapi;
92 napi_create_array(env, ¶msNapi);
93 napi_create_int32(env, RESOURCE_ID, &resIdNapi);
94 napi_create_int32(env, static_cast<int32_t>(type), &typeNapi);
95 napi_property_descriptor desc[] = {
96 DECLARE_NAPI_DEFAULT_PROPERTY(RESOURCE_ID_KEY, resIdNapi),
97 DECLARE_NAPI_DEFAULT_PROPERTY(TYPE_KEY, typeNapi),
98 DECLARE_NAPI_DEFAULT_PROPERTY(PARAMS_KEY, paramsNapi),
99 DECLARE_NAPI_DEFAULT_PROPERTY(BUNDLE_NAME_KEY, Napi::CreateNapiString(env, BUNDLE_NAME)),
100 DECLARE_NAPI_DEFAULT_PROPERTY(MODULE_NAME_KEY, Napi::CreateNapiString(env, MODULE_NAME)),
101 };
102 napi_value resObj;
103 napi_create_object_with_properties(env, &resObj, sizeof(desc) / sizeof(desc[0]), desc);
104 return resObj;
105 }
106
107 /**
108 * @tc.name: NapiUtilsTest001
109 * @tc.desc: GetParamLen
110 * @tc.type: FUNC
111 */
112 HWTEST_F(NapiUtilsTest, NapiUtilsTest001, TestSize.Level1)
113 {
114 NativeEngineMock engine;
115 /**
116 * @tc.steps: step1. Create napi string
117 * @tc.expected: Create success
118 */
119 std::string testStr = "test GetParamLen";
120 napi_value napiTestStr = nullptr;
121
122 napi_status status = napi_create_string_utf8(napi_env(engine), testStr.c_str(), testStr.length(), &napiTestStr);
123 EXPECT_EQ(status, napi_ok);
124
125 /**
126 * @tc.steps: step2. Call GetParamLen
127 * @tc.expected: Return value equals raw string length
128 */
129 size_t napiSize = Napi::GetParamLen(napi_env(engine), napiTestStr);
130 EXPECT_EQ(napiSize, testStr.length());
131 }
132
133 /**
134 * @tc.name: NapiUtilsTest002
135 * @tc.desc: NapiStringToString
136 * @tc.type: FUNC
137 */
138 HWTEST_F(NapiUtilsTest, NapiUtilsTest002, TestSize.Level1)
139 {
140 NativeEngineMock engine;
141 /**
142 * @tc.steps: step1. Create napi string
143 * @tc.expected: Create success
144 */
145 std::string testStr = "test napi string";
146 napi_value napiTestStr = nullptr;
147
148 napi_status status = napi_create_string_utf8(napi_env(engine), testStr.c_str(), testStr.length(), &napiTestStr);
149 EXPECT_EQ(status, napi_ok);
150
151 /**
152 * @tc.steps: step1. Call NapiStringToString
153 * @tc.expected: Return value equals raw string
154 */
155 std::string retVal;
156 Napi::NapiStringToString(napi_env(engine), napiTestStr, retVal);
157 EXPECT_EQ(retVal, testStr);
158 }
159
160 /**
161 * @tc.name: NapiUtilsTest003
162 * @tc.desc: CheckResourceStruct
163 * @tc.type: FUNC
164 */
165 HWTEST_F(NapiUtilsTest, NapiUtilsTest003, TestSize.Level1)
166 {
167 NativeEngineMock engine;
168 /**
169 * @tc.steps: step1. Create basic resource struct and check
170 * @tc.expected: Create success and check equal success
171 */
172 napi_value baseStruct = CreateBaseResourceObject(napi_env(engine), Napi::ResourceType::STRING);
173 auto resStruct1 = Napi::CheckResourceStruct(napi_env(engine), baseStruct);
174 EXPECT_EQ(resStruct1, Napi::ResourceStruct::CONSTANT);
175
176 /**
177 * @tc.steps: step2. Create dynamic v1 resource struct and check
178 * @tc.expected: Create success and check equal success
179 */
180 napi_value v1Struct = CreateDynamicV1ResourceObject(napi_env(engine));
181 auto resStruct2 = Napi::CheckResourceStruct(napi_env(engine), v1Struct);
182 EXPECT_EQ(resStruct2, Napi::ResourceStruct::DYNAMIC_V1);
183
184 /**
185 * @tc.steps: step3. Create dynamic v2 resource struct and check
186 * @tc.expected: Create success and check equal success
187 */
188 napi_value v2Struct = CreateDynamicV2ResourceObject(napi_env(engine));
189 auto resStruct3 = Napi::CheckResourceStruct(napi_env(engine), v2Struct);
190 EXPECT_EQ(resStruct3, Napi::ResourceStruct::DYNAMIC_V2);
191 }
192
193 /**
194 * @tc.name: NapiUtilsTest004
195 * @tc.desc: ConvertResourceType
196 * @tc.type: FUNC
197 */
198 HWTEST_F(NapiUtilsTest, NapiUtilsTest004, TestSize.Level1)
199 {
200 Napi::ResourceType resType;
201 /**
202 * @tc.steps: step1. Check color resource type
203 * @tc.expected: Type check success
204 */
205 Napi::ConvertResourceType("color", resType);
206 EXPECT_EQ(resType, Napi::ResourceType::COLOR);
207
208 /**
209 * @tc.steps: step2. Check media resource type
210 * @tc.expected: Type check success
211 */
212 Napi::ConvertResourceType("media", resType);
213 EXPECT_EQ(resType, Napi::ResourceType::MEDIA);
214
215 /**
216 * @tc.steps: step3. Check float resource type
217 * @tc.expected: Type check success
218 */
219 Napi::ConvertResourceType("float", resType);
220 EXPECT_EQ(resType, Napi::ResourceType::FLOAT);
221
222 /**
223 * @tc.steps: step4. Check string resource type
224 * @tc.expected: Type check success
225 */
226 Napi::ConvertResourceType("string", resType);
227 EXPECT_EQ(resType, Napi::ResourceType::STRING);
228
229 /**
230 * @tc.steps: step5. Check plural resource type
231 * @tc.expected: Type check success
232 */
233 Napi::ConvertResourceType("plural", resType);
234 EXPECT_EQ(resType, Napi::ResourceType::PLURAL);
235
236 /**
237 * @tc.steps: step6. Check pattern resource type
238 * @tc.expected: Type check success
239 */
240 Napi::ConvertResourceType("pattern", resType);
241 EXPECT_EQ(resType, Napi::ResourceType::PATTERN);
242
243 /**
244 * @tc.steps: step7. Check boolean resource type
245 * @tc.expected: Type check success
246 */
247 Napi::ConvertResourceType("boolean", resType);
248 EXPECT_EQ(resType, Napi::ResourceType::BOOLEAN);
249
250 /**
251 * @tc.steps: step8. Check integer resource type
252 * @tc.expected: Type check success
253 */
254 Napi::ConvertResourceType("integer", resType);
255 EXPECT_EQ(resType, Napi::ResourceType::INTEGER);
256
257 /**
258 * @tc.steps: step9. Check strarray resource type
259 * @tc.expected: Type check success
260 */
261 Napi::ConvertResourceType("strarray", resType);
262 EXPECT_EQ(resType, Napi::ResourceType::STRARRAY);
263
264 /**
265 * @tc.steps: step10. Check intarray resource type
266 * @tc.expected: Type check success
267 */
268 Napi::ConvertResourceType("intarray", resType);
269 EXPECT_EQ(resType, Napi::ResourceType::INTARRAY);
270 }
271
272 /**
273 * @tc.name: NapiUtilsTest005
274 * @tc.desc: ModifyResourceParam
275 * @tc.type: FUNC
276 */
277 HWTEST_F(NapiUtilsTest, NapiUtilsTest005, TestSize.Level1)
278 {
279 NativeEngineMock engine;
280 /**
281 * @tc.steps: step1. Create v1 resource struct and check
282 * @tc.expected: Create success and check equal success
283 */
284 napi_value v1Struct = CreateDynamicV1ResourceObject(napi_env(engine));
285 auto resStruct = Napi::CheckResourceStruct(napi_env(engine), v1Struct);
286 EXPECT_EQ(resStruct, Napi::ResourceStruct::DYNAMIC_V1);
287
288 /**
289 * @tc.steps: step2. Call ModifyResourceParam
290 */
291 std::string resName = DYNAMIC_RES_STRING;
292 Napi::ResourceType resType = Napi::ResourceType::STRING;
293 Napi::ModifyResourceParam(napi_env(engine), v1Struct, resType, resName);
294
295 /**
296 * @tc.steps: step3. Check resource params
297 * @tc.expected: params contains resource name
298 */
299 napi_value valueParamsNapi;
300 napi_get_property(
301 napi_env(engine), v1Struct, Napi::CreateNapiString(napi_env(engine), PARAMS_KEY), &valueParamsNapi);
302 napi_value resNameNApi = nullptr;
303 napi_get_element(napi_env(engine), valueParamsNapi, 0, &resNameNApi);
304 std::string resName1;
305 Napi::NapiStringToString(napi_env(engine), resNameNApi, resName1);
306 EXPECT_EQ(resName1, DYNAMIC_RES_STRING);
307 }
308
309 /**
310 * @tc.name: NapiUtilsTest006
311 * @tc.desc: ErrorToMessage
312 * @tc.type: FUNC
313 */
314 HWTEST_F(NapiUtilsTest, NapiUtilsTest006, TestSize.Level1)
315 {
316 /**
317 * @tc.steps: step1. Get ERROR_CODE_PERMISSION_DENIED error msg
318 * @tc.expected: Error msg correct
319 */
320 auto permissionDenyError = Napi::ErrorToMessage(ERROR_CODE_PERMISSION_DENIED);
321 EXPECT_EQ(permissionDenyError, "Permission denied. ");
322
323 /**
324 * @tc.steps: step2. Get ERROR_CODE_PARAM_INVALID error msg
325 * @tc.expected: Error msg correct
326 */
327 auto paramInvalidError = Napi::ErrorToMessage(ERROR_CODE_PARAM_INVALID);
328 EXPECT_EQ(paramInvalidError, "Parameter error. ");
329
330 /**
331 * @tc.steps: step3. Get ERROR_CODE_SYSTEMCAP_ERROR error msg
332 * @tc.expected: Error msg correct
333 */
334 auto systemCapError = Napi::ErrorToMessage(ERROR_CODE_SYSTEMCAP_ERROR);
335 EXPECT_EQ(systemCapError, "Capability not supported. ");
336
337 /**
338 * @tc.steps: step4. Get ERROR_CODE_INTERNAL_ERROR error msg
339 * @tc.expected: Error msg correct
340 */
341 auto codeInternalError = Napi::ErrorToMessage(ERROR_CODE_INTERNAL_ERROR);
342 EXPECT_EQ(codeInternalError, "Internal error. ");
343
344 /**
345 * @tc.steps: step5. Get ERROR_CODE_URI_ERROR error msg
346 * @tc.expected: Error msg correct
347 */
348 auto uriError = Napi::ErrorToMessage(ERROR_CODE_URI_ERROR);
349 EXPECT_EQ(uriError, "Uri error. ");
350
351 /**
352 * @tc.steps: step6. Get ERROR_CODE_PAGE_STACK_FULL error msg
353 * @tc.expected: Error msg correct
354 */
355 auto pageStackError = Napi::ErrorToMessage(ERROR_CODE_PAGE_STACK_FULL);
356 EXPECT_EQ(pageStackError, "Page stack error. ");
357
358 /**
359 * @tc.steps: step7. Get ERROR_CODE_URI_ERROR_LITE error msg
360 * @tc.expected: Error msg correct
361 */
362 auto uriLiteError = Napi::ErrorToMessage(ERROR_CODE_URI_ERROR_LITE);
363 EXPECT_EQ(uriLiteError, "Uri error. ");
364
365 /**
366 * @tc.steps: step8. Get ERROR_CODE_DIALOG_CONTENT_ERROR error msg
367 * @tc.expected: Error msg correct
368 */
369 auto dialogContentError = Napi::ErrorToMessage(ERROR_CODE_DIALOG_CONTENT_ERROR);
370 EXPECT_EQ(dialogContentError, "Dialog content error. ");
371
372 /**
373 * @tc.steps: step9. Get ERROR_CODE_DIALOG_CONTENT_ALREADY_EXIST error msg
374 * @tc.expected: Error msg correct
375 */
376 auto dialogContentExistError = Napi::ErrorToMessage(ERROR_CODE_DIALOG_CONTENT_ALREADY_EXIST);
377 EXPECT_EQ(dialogContentExistError, "Dialog content already exist. ");
378
379 /**
380 * @tc.steps: step10. Get ERROR_CODE_DIALOG_CONTENT_NOT_FOUND error msg
381 * @tc.expected: Error msg correct
382 */
383 auto dialogContentNotFoundError = Napi::ErrorToMessage(ERROR_CODE_DIALOG_CONTENT_NOT_FOUND);
384 EXPECT_EQ(dialogContentNotFoundError, "Dialog content not found. ");
385
386 /**
387 * @tc.steps: step11. Get ERROR_CODE_TOAST_NOT_FOUND error msg
388 * @tc.expected: Error msg correct
389 */
390 auto toastNotFoundError = Napi::ErrorToMessage(ERROR_CODE_TOAST_NOT_FOUND);
391 EXPECT_EQ(toastNotFoundError, "Toast not found. ");
392 }
393
394 /**
395 * @tc.name: NapiUtilsTest007
396 * @tc.desc: GetStringFromValueUtf8
397 * @tc.type: FUNC
398 */
399 HWTEST_F(NapiUtilsTest, NapiUtilsTest007, TestSize.Level1)
400 {
401 NativeEngineMock engine;
402 /**
403 * @tc.steps: step1. Create napi string
404 * @tc.expected: Create success
405 */
406 std::string testStr = "test napi string";
407 napi_value napiTestStr = nullptr;
408
409 napi_status status = napi_create_string_utf8(napi_env(engine), testStr.c_str(), testStr.length(), &napiTestStr);
410 EXPECT_EQ(status, napi_ok);
411
412 /**
413 * @tc.steps: step2. Call GetStringFromValueUtf8
414 * @tc.expected: Return value equals raw string
415 */
416 auto retVal = Napi::GetStringFromValueUtf8(napi_env(engine), napiTestStr);
417 EXPECT_EQ(retVal.has_value(), true);
418 EXPECT_EQ(retVal.value(), testStr);
419 }
420
421 } // namespace OHOS::Ace
422