1 /*
2 * Copyright (c) 2021-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 "test.h"
17 #include "napi/native_api.h"
18
19 static constexpr int INT_ZERO = 0;
20 static constexpr int INT_ONE = 1;
21 static constexpr int INT_TWO = 2;
22 static constexpr int INT_THREE = 3;
23 static constexpr double TEST_DOUBLE = 1.1;
24 static constexpr char TEST_STRING[5] = "test";
25
26 class NapiErrorCodeTest : public NativeEngineTest {
27 public:
SetUpTestCase()28 static void SetUpTestCase()
29 {
30 GTEST_LOG_(INFO) << "NapiErrorCodeTest SetUpTestCase";
31 }
32
TearDownTestCase()33 static void TearDownTestCase()
34 {
35 GTEST_LOG_(INFO) << "NapiErrorCodeTest TearDownTestCase";
36 }
37
SetUp()38 void SetUp() override
39 {
40 napi_env env = reinterpret_cast<napi_env>(engine_);
41 napi_open_handle_scope(env, &scope_);
42 }
43
TearDown()44 void TearDown() override
45 {
46 napi_env env = reinterpret_cast<napi_env>(engine_);
47 napi_value exception = nullptr;
48 napi_get_and_clear_last_exception(env, &exception);
49 napi_close_handle_scope(env, scope_);
50 }
51 private:
52 napi_handle_scope scope_ = nullptr;
53 };
54
AssertFalse()55 void AssertFalse()
56 {
57 ASSERT_TRUE(false);
58 }
59
TestAbort(napi_env env,napi_callback_info info)60 napi_value TestAbort(napi_env env, napi_callback_info info)
61 {
62 AssertFalse();
63 return nullptr;
64 }
65
66 /**
67 * @tc.name: NapiFatalExceptionTest
68 * @tc.desc: Test interface of napi_coerce_to_bool
69 * @tc.type: FUNC
70 */
71 HWTEST_F(NapiErrorCodeTest, NapiCoerceToBoolTest001, testing::ext::TestSize.Level1)
72 {
73 napi_env env = reinterpret_cast<napi_env>(engine_);
74 napi_value value = nullptr;
75 napi_value result;
76 napi_status status = napi_coerce_to_bool(env, value, &result);
77 ASSERT_EQ(status, napi_invalid_arg);
78 }
79
80 HWTEST_F(NapiErrorCodeTest, NapiCoerceToBoolTest002, testing::ext::TestSize.Level1)
81 {
82 napi_env env = reinterpret_cast<napi_env>(engine_);
83 napi_value value;
84 napi_value *result = nullptr;
85 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
86 status = napi_coerce_to_bool(env, value, result);
87 ASSERT_EQ(status, napi_invalid_arg);
88 }
89
90 /**
91 * @tc.name: NapiFatalExceptionTest
92 * @tc.desc: Test interface of napi_coerce_to_bool
93 * @tc.type: FUNC
94 */
95 HWTEST_F(NapiErrorCodeTest, NapiCoerceToBoolTest003, testing::ext::TestSize.Level1)
96 {
97 napi_env env = reinterpret_cast<napi_env>(engine_);
98 napi_value value;
99 napi_value result;
100 napi_status status = napi_create_double(env, NAN, &value);
101 status = napi_coerce_to_bool(env, value, &result);
102 bool ret = true;
103 napi_get_value_bool(env, result, &ret);
104 ASSERT_EQ(ret, false);
105 ASSERT_EQ(status, napi_ok);
106 }
107
108 /**
109 * @tc.name: NapiFatalExceptionTest
110 * @tc.desc: Test interface of napi_coerce_to_bool
111 * @tc.type: FUNC
112 */
113 HWTEST_F(NapiErrorCodeTest, NapiCoerceToBoolTest004, testing::ext::TestSize.Level1)
114 {
115 napi_env env = reinterpret_cast<napi_env>(engine_);
116 napi_value value;
117 napi_value result;
118 napi_status status = napi_get_undefined(env, &value);
119 status = napi_coerce_to_bool(env, value, &result);
120 bool ret = true;
121 napi_get_value_bool(env, result, &ret);
122 ASSERT_EQ(ret, false);
123 ASSERT_EQ(status, napi_ok);
124 }
125
126 /**
127 * @tc.name: NapiFatalExceptionTest
128 * @tc.desc: Test interface of napi_coerce_to_bool
129 * @tc.type: FUNC
130 */
131 HWTEST_F(NapiErrorCodeTest, NapiCoerceToBoolTest005, testing::ext::TestSize.Level1)
132 {
133 napi_env env = reinterpret_cast<napi_env>(engine_);
134 napi_value value;
135 napi_value result;
136 napi_status status = napi_get_null(env, &value);
137 status = napi_coerce_to_bool(env, value, &result);
138 bool ret = true;
139 napi_get_value_bool(env, result, &ret);
140 ASSERT_EQ(ret, false);
141 ASSERT_EQ(status, napi_ok);
142 }
143
144 HWTEST_F(NapiErrorCodeTest, NapiCoerceToNumberTest001, testing::ext::TestSize.Level1)
145 {
146 napi_env env = reinterpret_cast<napi_env>(engine_);
147 napi_value value = nullptr;
148 napi_value result;
149 napi_status status = napi_coerce_to_number(env, value, &result);
150 ASSERT_EQ(status, napi_invalid_arg);
151 }
152
153 HWTEST_F(NapiErrorCodeTest, NapiCoerceToNumberTest002, testing::ext::TestSize.Level1)
154 {
155 napi_env env = reinterpret_cast<napi_env>(engine_);
156 napi_value value;
157 napi_value *result = nullptr;
158 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
159 status = napi_coerce_to_number(env, value, result);
160 ASSERT_EQ(status, napi_invalid_arg);
161 }
162
163 HWTEST_F(NapiErrorCodeTest, NapiCoerceToNumberTest003, testing::ext::TestSize.Level1)
164 {
165 napi_env env = reinterpret_cast<napi_env>(engine_);
166 napi_value value;
167 napi_value result;
168 napi_status status = napi_create_string_utf8(env, "", 0, &value);
169 status = napi_coerce_to_number(env, value, &result);
170 ASSERT_EQ(status, napi_ok);
171 int32_t num;
172 status = napi_get_value_int32(env, result, &num);
173 ASSERT_EQ(num, 0);
174 }
175
176 HWTEST_F(NapiErrorCodeTest, NapiCoerceToNumberTest004, testing::ext::TestSize.Level1)
177 {
178 napi_env env = reinterpret_cast<napi_env>(engine_);
179 napi_value value;
180 napi_value result;
181 napi_status status = napi_create_string_utf8(env, TEST_STRING, 4, &value);
182 status = napi_coerce_to_number(env, value, &result);
183 ASSERT_EQ(status, napi_ok);
184 double db;
185 status = napi_get_value_double(env, result, &db);
186 ASSERT_EQ(std::isnan(db), true);
187 }
188
189 HWTEST_F(NapiErrorCodeTest, NapiCoerceToNumberTest005, testing::ext::TestSize.Level1)
190 {
191 napi_env env = reinterpret_cast<napi_env>(engine_);
192 napi_value value;
193 napi_value result;
194 napi_status status = napi_get_undefined(env, &value);
195 status = napi_coerce_to_number(env, value, &result);
196 ASSERT_EQ(status, napi_ok);
197 double db;
198 status = napi_get_value_double(env, result, &db);
199 ASSERT_EQ(std::isnan(db), true);
200 }
201
202 HWTEST_F(NapiErrorCodeTest, NapiCoerceToNumberTest006, testing::ext::TestSize.Level1)
203 {
204 napi_env env = reinterpret_cast<napi_env>(engine_);
205 napi_value value;
206 napi_value result;
207 napi_status status = napi_get_null(env, &value);
208 status = napi_coerce_to_number(env, value, &result);
209 ASSERT_EQ(status, napi_ok);
210 int32_t num;
211 status = napi_get_value_int32(env, result, &num);
212 ASSERT_EQ(num, 0);
213 }
214
215 HWTEST_F(NapiErrorCodeTest, NapiCoerceToNumberTest007, testing::ext::TestSize.Level1)
216 {
217 napi_env env = reinterpret_cast<napi_env>(engine_);
218 napi_value value;
219 napi_value result;
220 napi_status status = napi_create_object(env, &value);
221 status = napi_coerce_to_number(env, value, &result);
222 ASSERT_EQ(status, napi_ok);
223 double db;
224 status = napi_get_value_double(env, result, &db);
225 ASSERT_EQ(std::isnan(db), true);
226 }
227
228 HWTEST_F(NapiErrorCodeTest, NapiCoerceToObjectTest001, testing::ext::TestSize.Level1)
229 {
230 napi_env env = reinterpret_cast<napi_env>(engine_);
231 napi_value value = nullptr;
232 napi_value result;
233 napi_status status = napi_coerce_to_object(env, value, &result);
234 ASSERT_EQ(status, napi_invalid_arg);
235 }
236
237 HWTEST_F(NapiErrorCodeTest, NapiCoerceToObjectTest002, testing::ext::TestSize.Level1)
238 {
239 napi_env env = reinterpret_cast<napi_env>(engine_);
240 napi_value value;
241 napi_value *result = nullptr;
242 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
243 status = napi_coerce_to_object(env, value, result);
244 ASSERT_EQ(status, napi_invalid_arg);
245 }
246
247 HWTEST_F(NapiErrorCodeTest, NapiCoerceToObjectTest003, testing::ext::TestSize.Level1)
248 {
249 napi_env env = reinterpret_cast<napi_env>(engine_);
250 napi_value value;
251 napi_value result;
252 napi_status status = napi_get_undefined(env, &value);
253 status = napi_coerce_to_object(env, value, &result);
254 ASSERT_EQ(status, napi_ok);
255 napi_valuetype type = napi_undefined;
256 status = napi_typeof(env, result, &type);
257 ASSERT_EQ(status, napi_ok);
258 ASSERT_EQ(type, napi_undefined);
259 }
260
261 HWTEST_F(NapiErrorCodeTest, NapiCoerceToObjectTest004, testing::ext::TestSize.Level1)
262 {
263 napi_env env = reinterpret_cast<napi_env>(engine_);
264 napi_value value;
265 napi_value result;
266 napi_status status = napi_get_null(env, &value);
267 status = napi_coerce_to_object(env, value, &result);
268 ASSERT_EQ(status, napi_ok);
269 napi_valuetype type = napi_undefined;
270 status = napi_typeof(env, result, &type);
271 ASSERT_EQ(status, napi_ok);
272 ASSERT_EQ(type, napi_undefined);
273 }
274
275 HWTEST_F(NapiErrorCodeTest, NapiCoerceToStringTest001, testing::ext::TestSize.Level1)
276 {
277 napi_env env = reinterpret_cast<napi_env>(engine_);
278 napi_value value = nullptr;
279 napi_value result;
280 napi_status status = napi_coerce_to_string(env, value, &result);
281 ASSERT_EQ(status, napi_invalid_arg);
282 }
283
284 HWTEST_F(NapiErrorCodeTest, NapiCoerceToStringTest002, testing::ext::TestSize.Level1)
285 {
286 napi_env env = reinterpret_cast<napi_env>(engine_);
287 napi_value value;
288 napi_value *result = nullptr;
289 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
290 status = napi_coerce_to_string(env, value, result);
291 ASSERT_EQ(status, napi_invalid_arg);
292 }
293
294 HWTEST_F(NapiErrorCodeTest, NapiCoerceToStringTest003, testing::ext::TestSize.Level1)
295 {
296 napi_env env = reinterpret_cast<napi_env>(engine_);
297 napi_value value = nullptr;
298 constexpr char codeStr[] = "test code";
299 napi_status status = napi_create_string_utf8(env, codeStr, NAPI_AUTO_LENGTH, &value);
300 ASSERT_EQ(status, napi_ok);
301 napi_value *result = nullptr;
302 status = napi_coerce_to_string(env, value, result);
303 ASSERT_EQ(status, napi_invalid_arg);
304 }
305
306 HWTEST_F(NapiErrorCodeTest, NapiTypeofTest001, testing::ext::TestSize.Level1)
307 {
308 napi_env env = reinterpret_cast<napi_env>(engine_);
309 napi_value value = nullptr;
310 napi_valuetype result;
311 napi_status status = napi_typeof(env, value, &result);
312 ASSERT_EQ(status, napi_invalid_arg);
313 }
314
315 HWTEST_F(NapiErrorCodeTest, NapiTypeofTest002, testing::ext::TestSize.Level1)
316 {
317 napi_env env = reinterpret_cast<napi_env>(engine_);
318 napi_value value;
319 napi_valuetype *result = nullptr;
320 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
321 status = napi_typeof(env, value, result);
322 ASSERT_EQ(status, napi_invalid_arg);
323 }
324
325 HWTEST_F(NapiErrorCodeTest, NapiInstanceofTest001, testing::ext::TestSize.Level1)
326 {
327 napi_env env = reinterpret_cast<napi_env>(engine_);
328 napi_value value = nullptr;
329 napi_value constructor;
330 bool result;
331 napi_status status = napi_create_object(env, &constructor);
332 status = napi_instanceof(env, value, constructor, &result);
333 ASSERT_EQ(status, napi_invalid_arg);
334 }
335
336 HWTEST_F(NapiErrorCodeTest, NapiInstanceofTest002, testing::ext::TestSize.Level1)
337 {
338 napi_env env = reinterpret_cast<napi_env>(engine_);
339 napi_value value;
340 napi_value constructor = nullptr;
341 bool result;
342 napi_status status = napi_create_object(env, &value);
343 status = napi_instanceof(env, value, constructor, &result);
344 ASSERT_EQ(status, napi_invalid_arg);
345 }
346
347 HWTEST_F(NapiErrorCodeTest, NapiInstanceofTest003, testing::ext::TestSize.Level1)
348 {
349 napi_env env = reinterpret_cast<napi_env>(engine_);
350 napi_value value;
351 napi_value constructor;
352 bool *result = nullptr;
353 napi_status status = napi_create_object(env, &value);
354 status = napi_create_object(env, &constructor);
355 status = napi_instanceof(env, value, constructor, result);
356 ASSERT_EQ(status, napi_invalid_arg);
357 }
358
359 HWTEST_F(NapiErrorCodeTest, NapiInstanceofTest004, testing::ext::TestSize.Level1)
360 {
361 napi_env env = reinterpret_cast<napi_env>(engine_);
362 napi_value value;
363 napi_value constructor;
364 bool result;
365 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
366 status = napi_create_object(env, &constructor);
367 status = napi_instanceof(env, value, constructor, &result);
368 ASSERT_EQ(status, napi_object_expected);
369 }
370
371 HWTEST_F(NapiErrorCodeTest, NapiInstanceofTest005, testing::ext::TestSize.Level1)
372 {
373 napi_env env = reinterpret_cast<napi_env>(engine_);
374 napi_value value;
375 napi_value constructor;
376 bool result;
377 napi_status status = napi_create_object(env, &value);
378 status = napi_create_double(env, TEST_DOUBLE, &constructor);
379 status = napi_instanceof(env, value, constructor, &result);
380 ASSERT_EQ(status, napi_function_expected);
381 }
382
383 HWTEST_F(NapiErrorCodeTest, NapiIsArrayTest001, testing::ext::TestSize.Level1)
384 {
385 napi_env env = reinterpret_cast<napi_env>(engine_);
386 napi_value value = nullptr;
387 bool result;
388 napi_status status = napi_is_array(env, value, &result);
389 ASSERT_EQ(status, napi_invalid_arg);
390 }
391
392 HWTEST_F(NapiErrorCodeTest, NapiIsArrayTest002, testing::ext::TestSize.Level1)
393 {
394 napi_env env = reinterpret_cast<napi_env>(engine_);
395 napi_value value;
396 bool *result = nullptr;
397 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
398 status = napi_is_array(env, value, result);
399 ASSERT_EQ(status, napi_invalid_arg);
400 }
401
402 HWTEST_F(NapiErrorCodeTest, NapiIsArrayTest003, testing::ext::TestSize.Level1)
403 {
404 napi_env env = reinterpret_cast<napi_env>(engine_);
405 napi_value value;
406 bool *result = nullptr;
407 napi_status status = napi_create_array(env, &value);
408 status = napi_is_array(env, value, result);
409 ASSERT_EQ(status, napi_invalid_arg);
410 }
411
412 HWTEST_F(NapiErrorCodeTest, NapiIsArrayTest004, testing::ext::TestSize.Level1)
413 {
414 napi_env env = reinterpret_cast<napi_env>(engine_);
415 napi_value value;
416 bool *result = nullptr;
417 napi_status status = napi_create_array_with_length(env, INT_THREE, &value);
418 status = napi_is_array(env, value, result);
419 ASSERT_EQ(status, napi_invalid_arg);
420 }
421
422 HWTEST_F(NapiErrorCodeTest, NapiIsArrayBufferTest001, testing::ext::TestSize.Level1)
423 {
424 napi_env env = reinterpret_cast<napi_env>(engine_);
425 napi_value value = nullptr;
426 bool result;
427 napi_status status = napi_is_arraybuffer(env, value, &result);
428 ASSERT_EQ(status, napi_invalid_arg);
429 }
430
431 HWTEST_F(NapiErrorCodeTest, NapiIsArrayBufferTest002, testing::ext::TestSize.Level1)
432 {
433 napi_env env = reinterpret_cast<napi_env>(engine_);
434 napi_value value;
435 bool *result = nullptr;
436 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
437 status = napi_is_arraybuffer(env, value, result);
438 ASSERT_EQ(status, napi_invalid_arg);
439 }
440
441 HWTEST_F(NapiErrorCodeTest, NapiIsArrayBufferTest003, testing::ext::TestSize.Level1)
442 {
443 napi_env env = reinterpret_cast<napi_env>(engine_);
444 bool *result = nullptr;
445 napi_value arrayBuffer = nullptr;
446 void* arrayBufferPtr = nullptr;
447 size_t arrayBufferSize = 0; // 0: define initial length
448 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
449 napi_status status = napi_is_arraybuffer(env, arrayBuffer, result);
450 ASSERT_FALSE(result);
451 ASSERT_EQ(status, napi_invalid_arg);
452 }
453
454 HWTEST_F(NapiErrorCodeTest, NapiIsTypeBufferTest001, testing::ext::TestSize.Level1)
455 {
456 napi_env env = reinterpret_cast<napi_env>(engine_);
457 napi_value value = nullptr;
458 bool result;
459 napi_status status = napi_is_typedarray(env, value, &result);
460 ASSERT_EQ(status, napi_invalid_arg);
461 }
462
463 HWTEST_F(NapiErrorCodeTest, NapiIsTypeBufferTest002, testing::ext::TestSize.Level1)
464 {
465 napi_env env = reinterpret_cast<napi_env>(engine_);
466 napi_value value;
467 bool *result = nullptr;
468 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
469 status = napi_is_typedarray(env, value, result);
470 ASSERT_EQ(status, napi_invalid_arg);
471 }
472
473 HWTEST_F(NapiErrorCodeTest, NapiIsTypeBufferTest003, testing::ext::TestSize.Level1)
474 {
475 napi_env env = reinterpret_cast<napi_env>(engine_);
476 napi_value value;
477 bool *result = nullptr;
478 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
479 status = napi_is_typedarray(env, value, result);
480 ASSERT_EQ(status, napi_invalid_arg);
481 }
482
483 HWTEST_F(NapiErrorCodeTest, NapiIsDataViewTest001, testing::ext::TestSize.Level1)
484 {
485 napi_env env = reinterpret_cast<napi_env>(engine_);
486 napi_value value = nullptr;
487 bool result;
488 napi_status status = napi_is_dataview(env, value, &result);
489 ASSERT_EQ(status, napi_invalid_arg);
490 }
491
492 HWTEST_F(NapiErrorCodeTest, NapiIsDataViewTest002, testing::ext::TestSize.Level1)
493 {
494 napi_env env = reinterpret_cast<napi_env>(engine_);
495 napi_value value;
496 bool *result = nullptr;
497 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
498 status = napi_is_dataview(env, value, result);
499 ASSERT_EQ(status, napi_invalid_arg);
500 }
501
502 HWTEST_F(NapiErrorCodeTest, NapiIsDateTest001, testing::ext::TestSize.Level1)
503 {
504 napi_env env = reinterpret_cast<napi_env>(engine_);
505 napi_value value = nullptr;
506 bool result;
507 napi_status status = napi_is_date(env, value, &result);
508 ASSERT_EQ(status, napi_invalid_arg);
509 }
510
511 HWTEST_F(NapiErrorCodeTest, NapiIsDateTest002, testing::ext::TestSize.Level1)
512 {
513 napi_env env = reinterpret_cast<napi_env>(engine_);
514 napi_value value;
515 bool *result = nullptr;
516 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
517 status = napi_is_date(env, value, result);
518 ASSERT_EQ(status, napi_invalid_arg);
519 }
520
521 HWTEST_F(NapiErrorCodeTest, NapiStrictEqualsTest001, testing::ext::TestSize.Level1)
522 {
523 napi_env env = reinterpret_cast<napi_env>(engine_);
524 napi_value lhs = nullptr;
525 napi_value rhs;
526 bool result;
527 napi_status status = napi_create_double(env, TEST_DOUBLE, &rhs);
528 status = napi_strict_equals(env, lhs, rhs, &result);
529 ASSERT_EQ(status, napi_invalid_arg);
530 }
531
532 HWTEST_F(NapiErrorCodeTest, NapiStrictEqualsTest002, testing::ext::TestSize.Level1)
533 {
534 napi_env env = reinterpret_cast<napi_env>(engine_);
535 napi_value lhs;
536 napi_value rhs = nullptr;
537 bool result;
538 napi_status status = napi_create_double(env, TEST_DOUBLE, &lhs);
539 status = napi_strict_equals(env, lhs, rhs, &result);
540 ASSERT_EQ(status, napi_invalid_arg);
541 }
542
543 HWTEST_F(NapiErrorCodeTest, NapiStrictEqualsTest003, testing::ext::TestSize.Level1)
544 {
545 napi_env env = reinterpret_cast<napi_env>(engine_);
546 napi_value lhs;
547 napi_value rhs;
548 bool *result = nullptr;
549 napi_status status = napi_create_double(env, TEST_DOUBLE, &lhs);
550 status = napi_create_double(env, TEST_DOUBLE, &rhs);
551 status = napi_strict_equals(env, lhs, rhs, result);
552 ASSERT_EQ(status, napi_invalid_arg);
553 }
554
555 HWTEST_F(NapiErrorCodeTest, NapiStrictEqualsTest004, testing::ext::TestSize.Level1)
556 {
557 napi_env env = reinterpret_cast<napi_env>(engine_);
558 napi_value lhs;
559 napi_value rhs;
560 bool result;
561 napi_status status = napi_create_double(env, NAN, &lhs);
562 status = napi_create_double(env, NAN, &rhs);
563 status = napi_strict_equals(env, lhs, rhs, &result);
564 ASSERT_EQ(status, false);
565 }
566
567 HWTEST_F(NapiErrorCodeTest, NapiStrictEqualsTest005, testing::ext::TestSize.Level1)
568 {
569 napi_env env = reinterpret_cast<napi_env>(engine_);
570 napi_value lhs;
571 napi_value rhs;
572 bool result;
573 napi_create_int32(env, INT_ZERO, &lhs);
574 napi_create_int32(env, INT_ONE, &rhs);
575 napi_strict_equals(env, lhs, rhs, &result);
576 ASSERT_FALSE(result);
577 napi_create_int32(env, INT_ZERO, &rhs);
578 napi_strict_equals(env, lhs, rhs, &result);
579 ASSERT_TRUE(result);
580 }
581
582 HWTEST_F(NapiErrorCodeTest, NapiGetPropertyNamesTest001, testing::ext::TestSize.Level1)
583 {
584 napi_env env = reinterpret_cast<napi_env>(engine_);
585 napi_value value = nullptr;
586 napi_value result;
587 napi_status status = napi_get_property_names(env, value, &result);
588 ASSERT_EQ(status, napi_invalid_arg);
589 }
590
591 HWTEST_F(NapiErrorCodeTest, NapiGetPropertyNamesTest002, testing::ext::TestSize.Level1)
592 {
593 napi_env env = reinterpret_cast<napi_env>(engine_);
594 napi_value value;
595 napi_value *result = nullptr;
596 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
597 status = napi_get_property_names(env, value, result);
598 ASSERT_EQ(status, napi_invalid_arg);
599 }
600
601 HWTEST_F(NapiErrorCodeTest, NapiGetPropertyNamesTest003, testing::ext::TestSize.Level1)
602 {
603 napi_env env = reinterpret_cast<napi_env>(engine_);
604 napi_value value;
605 napi_value result;
606 napi_status status = napi_create_double(env, TEST_DOUBLE, &value);
607 status = napi_get_property_names(env, value, &result);
608 ASSERT_EQ(status, napi_object_expected);
609 }
610
611 HWTEST_F(NapiErrorCodeTest, NapiGetPropertyNamesTest004, testing::ext::TestSize.Level1)
612 {
613 napi_env env = reinterpret_cast<napi_env>(engine_);
614 napi_value value;
615 napi_value result;
616 napi_status status = napi_create_int32(env, INT_ZERO, &value);
617 status = napi_get_property_names(env, value, &result);
618 ASSERT_NE(value, result);
619 ASSERT_EQ(status, napi_object_expected);
620 }
621
622 HWTEST_F(NapiErrorCodeTest, NapiSetPropertyTest001, testing::ext::TestSize.Level1)
623 {
624 napi_env env = reinterpret_cast<napi_env>(engine_);
625 napi_value obj = nullptr;
626 napi_value key;
627 napi_value value;
628
629 napi_create_int32(env, INT_ONE, &key);
630 napi_create_int32(env, INT_TWO, &value);
631 napi_status status = napi_set_property(env, obj, key, value);
632 ASSERT_EQ(status, napi_invalid_arg);
633 }
634
635 HWTEST_F(NapiErrorCodeTest, NapiSetPropertyTest002, testing::ext::TestSize.Level1)
636 {
637 napi_env env = reinterpret_cast<napi_env>(engine_);
638 napi_value obj;
639 napi_value key = nullptr;
640 napi_value value;
641
642 napi_create_object(env, &obj);
643 napi_create_int32(env, INT_TWO, &value);
644 napi_status status = napi_set_property(env, obj, key, value);
645 ASSERT_EQ(status, napi_invalid_arg);
646 }
647
648 HWTEST_F(NapiErrorCodeTest, NapiSetPropertyTest003, testing::ext::TestSize.Level1)
649 {
650 napi_env env = reinterpret_cast<napi_env>(engine_);
651 napi_value obj;
652 napi_value key;
653 napi_value value = nullptr;
654
655 napi_create_object(env, &obj);
656 napi_create_int32(env, INT_ONE, &key);
657 napi_status status = napi_set_property(env, obj, key, value);
658 ASSERT_EQ(status, napi_invalid_arg);
659 }
660
661 HWTEST_F(NapiErrorCodeTest, NapiSetPropertyTest004, testing::ext::TestSize.Level1)
662 {
663 napi_env env = reinterpret_cast<napi_env>(engine_);
664 napi_value obj;
665 napi_value key;
666 napi_value value;
667
668 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
669 napi_create_int32(env, INT_ONE, &key);
670 napi_create_int32(env, INT_TWO, &value);
671 status = napi_set_property(env, obj, key, value);
672 ASSERT_EQ(status, napi_object_expected);
673 }
674
675 HWTEST_F(NapiErrorCodeTest, NapiSetPropertyTest005, testing::ext::TestSize.Level1)
676 {
677 napi_env env = reinterpret_cast<napi_env>(engine_);
678 napi_value obj;
679 napi_value key;
680 napi_value value;
681
682 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
683 napi_create_int32(env, INT_ZERO, &key);
684 napi_create_int32(env, INT_THREE, &value);
685 status = napi_set_property(env, obj, key, value);
686 ASSERT_EQ(status, napi_object_expected);
687 }
688
689 HWTEST_F(NapiErrorCodeTest, NapiGetPropertyTest001, testing::ext::TestSize.Level1)
690 {
691 napi_env env = reinterpret_cast<napi_env>(engine_);
692 napi_value obj = nullptr;
693 napi_value key;
694 napi_value result;
695
696 napi_create_int32(env, INT_ONE, &key);
697 napi_status status = napi_get_property(env, obj, key, &result);
698 ASSERT_EQ(status, napi_invalid_arg);
699 }
700
701 HWTEST_F(NapiErrorCodeTest, NapiGetPropertyTest002, testing::ext::TestSize.Level1)
702 {
703 napi_env env = reinterpret_cast<napi_env>(engine_);
704 napi_value obj;
705 napi_value key = nullptr;
706 napi_value result;
707
708 napi_create_object(env, &obj);
709 napi_status status = napi_get_property(env, obj, key, &result);
710 ASSERT_EQ(status, napi_invalid_arg);
711 }
712
713 HWTEST_F(NapiErrorCodeTest, NapiGetPropertyTest003, testing::ext::TestSize.Level1)
714 {
715 napi_env env = reinterpret_cast<napi_env>(engine_);
716 napi_value obj;
717 napi_value key;
718 napi_value *result = nullptr;
719
720 napi_create_object(env, &obj);
721 napi_create_int32(env, INT_ONE, &key);
722 napi_status status = napi_get_property(env, obj, key, result);
723 ASSERT_EQ(status, napi_invalid_arg);
724 }
725
726 HWTEST_F(NapiErrorCodeTest, NapiGetPropertyTest004, testing::ext::TestSize.Level1)
727 {
728 napi_env env = reinterpret_cast<napi_env>(engine_);
729 napi_value obj;
730 napi_value key;
731 napi_value result;
732
733 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
734 napi_create_int32(env, INT_ONE, &key);
735 status = napi_get_property(env, obj, key, &result);
736 ASSERT_EQ(status, napi_object_expected);
737 }
738
739 HWTEST_F(NapiErrorCodeTest, NapiGetPropertyTest005, testing::ext::TestSize.Level1)
740 {
741 napi_env env = reinterpret_cast<napi_env>(engine_);
742 napi_value obj;
743 napi_value key;
744 napi_value value;
745 napi_value result;
746 napi_create_double(env, TEST_DOUBLE, &obj);
747 napi_create_int32(env, INT_ZERO, &key);
748 napi_create_int32(env, INT_THREE, &value);
749 napi_set_property(env, obj, key, value);
750 napi_status status = napi_get_property(env, obj, key, &result);
751 ASSERT_NE(value, result);
752 ASSERT_EQ(status, napi_object_expected);
753 }
754
755 HWTEST_F(NapiErrorCodeTest, NapiHasPropertyTest001, testing::ext::TestSize.Level1)
756 {
757 napi_env env = reinterpret_cast<napi_env>(engine_);
758 napi_value obj = nullptr;
759 napi_value key;
760 bool result;
761
762 napi_create_int32(env, INT_ONE, &key);
763 napi_status status = napi_has_property(env, obj, key, &result);
764 ASSERT_EQ(status, napi_invalid_arg);
765 }
766
767 HWTEST_F(NapiErrorCodeTest, NapiHasPropertyTest002, testing::ext::TestSize.Level1)
768 {
769 napi_env env = reinterpret_cast<napi_env>(engine_);
770 napi_value obj;
771 napi_value key = nullptr;
772 bool result;
773
774 napi_create_object(env, &obj);
775 napi_status status = napi_has_property(env, obj, key, &result);
776 ASSERT_EQ(status, napi_invalid_arg);
777 }
778
779 HWTEST_F(NapiErrorCodeTest, NapiHasPropertyTest003, testing::ext::TestSize.Level1)
780 {
781 napi_env env = reinterpret_cast<napi_env>(engine_);
782 napi_value obj;
783 napi_value key;
784 bool *result = nullptr;
785
786 napi_create_object(env, &obj);
787 napi_create_int32(env, INT_ONE, &key);
788 napi_status status = napi_has_property(env, obj, key, result);
789 ASSERT_EQ(status, napi_invalid_arg);
790 }
791
792 HWTEST_F(NapiErrorCodeTest, NapiHasPropertyTest004, testing::ext::TestSize.Level1)
793 {
794 napi_env env = reinterpret_cast<napi_env>(engine_);
795 napi_value obj;
796 napi_value key;
797 bool result;
798
799 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
800 napi_create_int32(env, INT_ONE, &key);
801 status = napi_has_property(env, obj, key, &result);
802 ASSERT_EQ(status, napi_object_expected);
803 }
804
805 HWTEST_F(NapiErrorCodeTest, NapiHasPropertyTest005, testing::ext::TestSize.Level1)
806 {
807 napi_env env = reinterpret_cast<napi_env>(engine_);
808 napi_value obj;
809 napi_value key;
810 napi_value value;
811 bool result;
812
813 napi_create_double(env, TEST_DOUBLE, &obj);
814 napi_create_int32(env, INT_ZERO, &key);
815 napi_create_int32(env, INT_ONE, &value);
816 napi_set_property(env, obj, key, value);
817 napi_has_property(env, obj, key, &result);
818 ASSERT_FALSE(result);
819 }
820
821 HWTEST_F(NapiErrorCodeTest, NapiDeletePropertyTest001, testing::ext::TestSize.Level1)
822 {
823 napi_env env = reinterpret_cast<napi_env>(engine_);
824 napi_value obj = nullptr;
825 napi_value key;
826 bool result;
827
828 napi_create_int32(env, INT_ONE, &key);
829 napi_status status = napi_delete_property(env, obj, key, &result);
830 ASSERT_EQ(status, napi_invalid_arg);
831 }
832
833 HWTEST_F(NapiErrorCodeTest, NapiDeletePropertyTest002, testing::ext::TestSize.Level1)
834 {
835 napi_env env = reinterpret_cast<napi_env>(engine_);
836 napi_value obj;
837 napi_value key = nullptr;
838 bool result;
839
840 napi_create_object(env, &obj);
841 napi_status status = napi_delete_property(env, obj, key, &result);
842 ASSERT_EQ(status, napi_invalid_arg);
843 }
844
845 HWTEST_F(NapiErrorCodeTest, NapiDeletePropertyTest004, testing::ext::TestSize.Level1)
846 {
847 napi_env env = reinterpret_cast<napi_env>(engine_);
848 napi_value obj;
849 napi_value key;
850 bool result;
851
852 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
853 napi_create_int32(env, INT_ONE, &key);
854 status = napi_delete_property(env, obj, key, &result);
855 ASSERT_EQ(status, napi_object_expected);
856 }
857
858 HWTEST_F(NapiErrorCodeTest, NapiDeletePropertyTest005, testing::ext::TestSize.Level1)
859 {
860 napi_env env = reinterpret_cast<napi_env>(engine_);
861 napi_value obj;
862 napi_value key;
863 napi_value value;
864 bool result;
865
866 napi_create_double(env, TEST_DOUBLE, &obj);
867 napi_create_int32(env, INT_ZERO, &key);
868 napi_create_int32(env, INT_TWO, &value);
869 napi_set_property(env, obj, key, value);
870 napi_status status = napi_delete_property(env, obj, key, &result);
871 ASSERT_FALSE(result);
872 ASSERT_EQ(status, napi_object_expected);
873 }
874
875 HWTEST_F(NapiErrorCodeTest, NapiHasOwnPropertyTest001, testing::ext::TestSize.Level1)
876 {
877 napi_env env = reinterpret_cast<napi_env>(engine_);
878 napi_value obj = nullptr;
879 napi_value key;
880 bool result;
881
882 napi_create_int32(env, INT_ONE, &key);
883 napi_status status = napi_has_own_property(env, obj, key, &result);
884 ASSERT_EQ(status, napi_invalid_arg);
885 }
886
887 HWTEST_F(NapiErrorCodeTest, NapiHasOwnPropertyTest002, testing::ext::TestSize.Level1)
888 {
889 napi_env env = reinterpret_cast<napi_env>(engine_);
890 napi_value obj;
891 napi_value key = nullptr;
892 bool result;
893
894 napi_create_object(env, &obj);
895 napi_status status = napi_has_own_property(env, obj, key, &result);
896 ASSERT_EQ(status, napi_invalid_arg);
897 }
898
899 HWTEST_F(NapiErrorCodeTest, NapiHasOwnPropertyTest003, testing::ext::TestSize.Level1)
900 {
901 napi_env env = reinterpret_cast<napi_env>(engine_);
902 napi_value obj;
903 napi_value key;
904 bool *result = nullptr;
905
906 napi_create_object(env, &obj);
907 napi_create_int32(env, INT_ONE, &key);
908 napi_status status = napi_has_own_property(env, obj, key, result);
909 ASSERT_EQ(status, napi_invalid_arg);
910 }
911
912 HWTEST_F(NapiErrorCodeTest, NapiHasOwnPropertyTest004, testing::ext::TestSize.Level1)
913 {
914 napi_env env = reinterpret_cast<napi_env>(engine_);
915 napi_value obj;
916 napi_value key;
917 bool result;
918
919 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
920 napi_create_int32(env, INT_ONE, &key);
921 status = napi_has_own_property(env, obj, key, &result);
922 ASSERT_EQ(status, napi_object_expected);
923 }
924
925 HWTEST_F(NapiErrorCodeTest, NapiHasOwnPropertyTest005, testing::ext::TestSize.Level1)
926 {
927 napi_env env = reinterpret_cast<napi_env>(engine_);
928 napi_value obj;
929 napi_value key;
930 napi_value value;
931 bool result;
932
933 napi_create_double(env, TEST_DOUBLE, &obj);
934 napi_create_int32(env, INT_ONE, &key);
935 napi_create_int32(env, INT_ONE, &value);
936 napi_set_property(env, obj, key, value);
937 napi_status status = napi_has_own_property(env, obj, key, &result);
938 ASSERT_FALSE(result);
939 ASSERT_EQ(status, napi_object_expected);
940 }
941
942 HWTEST_F(NapiErrorCodeTest, NapiSetNamedPropertyTest001, testing::ext::TestSize.Level1)
943 {
944 napi_env env = reinterpret_cast<napi_env>(engine_);
945 napi_value obj = nullptr;
946 napi_value value;
947
948 napi_create_int32(env, INT_TWO, &value);
949 napi_status status = napi_set_named_property(env, obj, TEST_STRING, value);
950 ASSERT_EQ(status, napi_invalid_arg);
951 }
952
953 HWTEST_F(NapiErrorCodeTest, NapiSetNamedPropertyTest002, testing::ext::TestSize.Level1)
954 {
955 napi_env env = reinterpret_cast<napi_env>(engine_);
956 napi_value obj;
957 char* utf8name = nullptr;
958 napi_value value;
959
960 napi_create_object(env, &obj);
961 napi_create_int32(env, INT_TWO, &value);
962 napi_status status = napi_set_named_property(env, obj, utf8name, value);
963 ASSERT_EQ(status, napi_invalid_arg);
964 }
965
966 HWTEST_F(NapiErrorCodeTest, NapiSetNamedPropertyTest003, testing::ext::TestSize.Level1)
967 {
968 napi_env env = reinterpret_cast<napi_env>(engine_);
969 napi_value obj;
970 napi_value value = nullptr;
971
972 napi_create_object(env, &obj);
973 napi_status status = napi_set_named_property(env, obj, TEST_STRING, value);
974 ASSERT_EQ(status, napi_invalid_arg);
975 }
976
977 HWTEST_F(NapiErrorCodeTest, NapiSetNamedPropertyTest004, testing::ext::TestSize.Level1)
978 {
979 napi_env env = reinterpret_cast<napi_env>(engine_);
980 napi_value obj;
981 napi_value value;
982
983 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
984 napi_create_int32(env, INT_TWO, &value);
985 status = napi_set_named_property(env, obj, TEST_STRING, value);
986 ASSERT_EQ(status, napi_object_expected);
987 }
988
989 HWTEST_F(NapiErrorCodeTest, NapiSetNamedPropertyTest005, testing::ext::TestSize.Level1)
990 {
991 napi_env env = reinterpret_cast<napi_env>(engine_);
992 napi_value obj;
993 napi_value value;
994
995 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
996 napi_create_int32(env, INT_THREE, &value);
997 status = napi_set_named_property(env, obj, TEST_STRING, value);
998 ASSERT_EQ(status, napi_object_expected);
999 }
1000
1001 HWTEST_F(NapiErrorCodeTest, NapiGetNamedPropertyTest001, testing::ext::TestSize.Level1)
1002 {
1003 napi_env env = reinterpret_cast<napi_env>(engine_);
1004 napi_value obj = nullptr;
1005 napi_value value;
1006
1007 napi_status status = napi_get_named_property(env, obj, TEST_STRING, &value);
1008 ASSERT_EQ(status, napi_invalid_arg);
1009 }
1010
1011 HWTEST_F(NapiErrorCodeTest, NapiGetNamedPropertyTest002, testing::ext::TestSize.Level1)
1012 {
1013 napi_env env = reinterpret_cast<napi_env>(engine_);
1014 napi_value obj;
1015 char* utf8name = nullptr;
1016 napi_value value;
1017
1018 napi_create_object(env, &obj);
1019 napi_status status = napi_get_named_property(env, obj, utf8name, &value);
1020 ASSERT_EQ(status, napi_invalid_arg);
1021 }
1022
1023 HWTEST_F(NapiErrorCodeTest, NapiGetNamedPropertyTest003, testing::ext::TestSize.Level1)
1024 {
1025 napi_env env = reinterpret_cast<napi_env>(engine_);
1026 napi_value obj;
1027 napi_value *value = nullptr;
1028
1029 napi_create_object(env, &obj);
1030 napi_status status = napi_get_named_property(env, obj, TEST_STRING, value);
1031 ASSERT_EQ(status, napi_invalid_arg);
1032 }
1033
1034 HWTEST_F(NapiErrorCodeTest, NapiGetNamedPropertyTest004, testing::ext::TestSize.Level1)
1035 {
1036 napi_env env = reinterpret_cast<napi_env>(engine_);
1037 napi_value obj;
1038 napi_value value;
1039
1040 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
1041 status = napi_get_named_property(env, obj, TEST_STRING, &value);
1042 ASSERT_EQ(status, napi_object_expected);
1043 }
1044
1045 HWTEST_F(NapiErrorCodeTest, NapiGetNamedPropertyTest005, testing::ext::TestSize.Level1)
1046 {
1047 napi_env env = reinterpret_cast<napi_env>(engine_);
1048 napi_value obj;
1049 napi_value value;
1050
1051 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
1052 napi_create_int32(env, INT_THREE, &value);
1053 status = napi_set_named_property(env, obj, TEST_STRING, value);
1054 napi_value res;
1055 status = napi_get_named_property(env, obj, TEST_STRING, &res);
1056 ASSERT_NE(res, value);
1057 ASSERT_EQ(status, napi_object_expected);
1058 }
1059
1060 HWTEST_F(NapiErrorCodeTest, NapiHasNamedPropertyTest001, testing::ext::TestSize.Level1)
1061 {
1062 napi_env env = reinterpret_cast<napi_env>(engine_);
1063 napi_value obj = nullptr;
1064 bool result;
1065
1066 napi_status status = napi_has_named_property(env, obj, TEST_STRING, &result);
1067 ASSERT_EQ(status, napi_invalid_arg);
1068 }
1069
1070 HWTEST_F(NapiErrorCodeTest, NapiHasNamedPropertyTest002, testing::ext::TestSize.Level1)
1071 {
1072 napi_env env = reinterpret_cast<napi_env>(engine_);
1073 napi_value obj;
1074 char* utf8name = nullptr;
1075 bool result;
1076
1077 napi_create_object(env, &obj);
1078 napi_status status = napi_has_named_property(env, obj, utf8name, &result);
1079 ASSERT_EQ(status, napi_invalid_arg);
1080 }
1081
1082 HWTEST_F(NapiErrorCodeTest, NapiHasNamedPropertyTest003, testing::ext::TestSize.Level1)
1083 {
1084 napi_env env = reinterpret_cast<napi_env>(engine_);
1085 napi_value obj;
1086 bool *result = nullptr;
1087
1088 napi_create_object(env, &obj);
1089 napi_status status = napi_has_named_property(env, obj, TEST_STRING, result);
1090 ASSERT_EQ(status, napi_invalid_arg);
1091 }
1092
1093 HWTEST_F(NapiErrorCodeTest, NapiHasNamedPropertyTest004, testing::ext::TestSize.Level1)
1094 {
1095 napi_env env = reinterpret_cast<napi_env>(engine_);
1096 napi_value obj;
1097 bool result;
1098
1099 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
1100 status = napi_has_named_property(env, obj, TEST_STRING, &result);
1101 ASSERT_EQ(status, napi_object_expected);
1102 }
1103
1104 HWTEST_F(NapiErrorCodeTest, NapiHasNamedPropertyTest006, testing::ext::TestSize.Level1)
1105 {
1106 napi_env env = reinterpret_cast<napi_env>(engine_);
1107 napi_value global, globalThis, proxy_constructor, proxy;
1108 napi_get_global(env, &global);
1109 ASSERT_CHECK_CALL(napi_get_named_property(env, global, "globalThis", &globalThis));
1110 ASSERT_CHECK_CALL(napi_get_named_property(env, global, "Proxy", &proxy_constructor));
1111 napi_value obj;
1112 ASSERT_CHECK_CALL(napi_create_object(env, &obj));
1113 napi_value args[2] = {obj, obj};
1114 ASSERT_CHECK_CALL(napi_new_instance(env, proxy_constructor, 2, args, &proxy));
1115
1116 bool result = false;
1117 napi_status status = napi_has_named_property(env, proxy, "toString", &result);
1118 ASSERT_EQ(result, true);
1119 ASSERT_EQ(status, napi_ok);
1120 }
1121
1122 HWTEST_F(NapiErrorCodeTest, NapiHasNamedPropertyTest005, testing::ext::TestSize.Level1)
1123 {
1124 napi_env env = reinterpret_cast<napi_env>(engine_);
1125 napi_value obj;
1126 napi_value value;
1127
1128 napi_create_double(env, TEST_DOUBLE, &obj);
1129 napi_create_int32(env, INT_THREE, &value);
1130 napi_set_named_property(env, obj, TEST_STRING, value);
1131 bool result;
1132 napi_status status = napi_has_named_property(env, obj, TEST_STRING, &result);
1133 ASSERT_EQ(status, napi_object_expected);
1134 }
1135
1136 HWTEST_F(NapiErrorCodeTest, NapiSetElementTest001, testing::ext::TestSize.Level1)
1137 {
1138 napi_env env = reinterpret_cast<napi_env>(engine_);
1139 napi_value obj = nullptr;
1140 uint32_t index = 1;
1141 napi_value value;
1142
1143 napi_create_int32(env, INT_TWO, &value);
1144 napi_status status = napi_set_element(env, obj, index, value);
1145 ASSERT_EQ(status, napi_invalid_arg);
1146 }
1147
1148 HWTEST_F(NapiErrorCodeTest, NapiSetElementTest002, testing::ext::TestSize.Level1)
1149 {
1150 napi_env env = reinterpret_cast<napi_env>(engine_);
1151 napi_value obj;
1152 uint32_t index = 1;
1153 napi_value value = nullptr;
1154
1155 napi_create_object(env, &obj);
1156 napi_status status = napi_set_element(env, obj, index, value);
1157 ASSERT_EQ(status, napi_invalid_arg);
1158 }
1159
1160 HWTEST_F(NapiErrorCodeTest, NapiSetElementTest003, testing::ext::TestSize.Level1)
1161 {
1162 napi_env env = reinterpret_cast<napi_env>(engine_);
1163 napi_value obj;
1164 uint32_t index = 1;
1165 napi_value value;
1166
1167 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
1168 napi_create_int32(env, INT_TWO, &value);
1169 status = napi_set_element(env, obj, index, value);
1170 ASSERT_EQ(status, napi_object_expected);
1171 }
1172
1173 HWTEST_F(NapiErrorCodeTest, NapiSetElementTest004, testing::ext::TestSize.Level1)
1174 {
1175 napi_env env = reinterpret_cast<napi_env>(engine_);
1176 napi_value obj;
1177 napi_value value;
1178
1179 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
1180 napi_create_int32(env, INT_TWO, &value);
1181 status = napi_set_element(env, obj, INT_ONE, value);
1182 ASSERT_EQ(status, napi_object_expected);
1183 }
1184
1185 HWTEST_F(NapiErrorCodeTest, NapiGetElementTest001, testing::ext::TestSize.Level1)
1186 {
1187 napi_env env = reinterpret_cast<napi_env>(engine_);
1188 napi_value obj = nullptr;
1189 uint32_t index = 1;
1190 napi_value value;
1191
1192 napi_status status = napi_get_element(env, obj, index, &value);
1193 ASSERT_EQ(status, napi_invalid_arg);
1194 }
1195
1196 HWTEST_F(NapiErrorCodeTest, NapiGetElementTest002, testing::ext::TestSize.Level1)
1197 {
1198 napi_env env = reinterpret_cast<napi_env>(engine_);
1199 napi_value obj;
1200 uint32_t index = 1;
1201 napi_value *value = nullptr;
1202
1203 napi_create_object(env, &obj);
1204 napi_status status = napi_get_element(env, obj, index, value);
1205 ASSERT_EQ(status, napi_invalid_arg);
1206 }
1207
1208 HWTEST_F(NapiErrorCodeTest, NapiGetElementTest003, testing::ext::TestSize.Level1)
1209 {
1210 napi_env env = reinterpret_cast<napi_env>(engine_);
1211 napi_value obj;
1212 uint32_t index = 1;
1213 napi_value value;
1214
1215 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
1216 status = napi_get_element(env, obj, index, &value);
1217 ASSERT_EQ(status, napi_object_expected);
1218 }
1219
1220 HWTEST_F(NapiErrorCodeTest, NapiGetElementTest004, testing::ext::TestSize.Level1)
1221 {
1222 napi_env env = reinterpret_cast<napi_env>(engine_);
1223 napi_value obj;
1224 napi_value value;
1225
1226 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
1227 ASSERT_EQ(status, napi_ok);
1228 napi_create_int32(env, INT_TWO, &value);
1229 napi_set_element(env, obj, INT_ONE, value);
1230 napi_value res;
1231 status = napi_get_element(env, obj, INT_ONE, &res);
1232 ASSERT_NE(value, res);
1233 ASSERT_EQ(status, napi_object_expected);
1234 }
1235
1236 HWTEST_F(NapiErrorCodeTest, NapiHasElementTest001, testing::ext::TestSize.Level1)
1237 {
1238 napi_env env = reinterpret_cast<napi_env>(engine_);
1239 napi_value obj = nullptr;
1240 uint32_t index = 1;
1241 bool result;
1242
1243 napi_status status = napi_has_element(env, obj, index, &result);
1244 ASSERT_EQ(status, napi_invalid_arg);
1245 }
1246
1247 HWTEST_F(NapiErrorCodeTest, NapiHasElementTest002, testing::ext::TestSize.Level1)
1248 {
1249 napi_env env = reinterpret_cast<napi_env>(engine_);
1250 napi_value obj;
1251 uint32_t index = 1;
1252 bool *result = nullptr;
1253
1254 napi_create_object(env, &obj);
1255 napi_status status = napi_has_element(env, obj, index, result);
1256 ASSERT_EQ(status, napi_invalid_arg);
1257 }
1258
1259 HWTEST_F(NapiErrorCodeTest, NapiHasElementTest003, testing::ext::TestSize.Level1)
1260 {
1261 napi_env env = reinterpret_cast<napi_env>(engine_);
1262 napi_value obj;
1263 uint32_t index = 1;
1264 bool result;
1265
1266 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
1267 status = napi_has_element(env, obj, index, &result);
1268 ASSERT_EQ(status, napi_object_expected);
1269 }
1270
1271 HWTEST_F(NapiErrorCodeTest, NapiHasElementTest004, testing::ext::TestSize.Level1)
1272 {
1273 napi_env env = reinterpret_cast<napi_env>(engine_);
1274 napi_value obj;
1275 napi_value value;
1276
1277 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
1278 ASSERT_EQ(status, napi_ok);
1279 napi_create_int32(env, INT_TWO, &value);
1280 napi_set_element(env, obj, INT_ONE, value);
1281 bool res;
1282 status = napi_has_element(env, obj, INT_ONE, &res);
1283 ASSERT_EQ(status, napi_object_expected);
1284 }
1285
1286 HWTEST_F(NapiErrorCodeTest, NapiDeleteElementTest001, testing::ext::TestSize.Level1)
1287 {
1288 napi_env env = reinterpret_cast<napi_env>(engine_);
1289 napi_value obj = nullptr;
1290 uint32_t index = 1;
1291 bool result;
1292
1293 napi_status status = napi_delete_element(env, obj, index, &result);
1294 ASSERT_EQ(status, napi_invalid_arg);
1295 }
1296
1297 HWTEST_F(NapiErrorCodeTest, NapiDeleteElementTest002, testing::ext::TestSize.Level1)
1298 {
1299 napi_env env = reinterpret_cast<napi_env>(engine_);
1300 napi_value obj;
1301 uint32_t index = 1;
1302 bool result;
1303
1304 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
1305 status = napi_delete_element(env, obj, index, &result);
1306 ASSERT_EQ(status, napi_object_expected);
1307 }
1308
1309 HWTEST_F(NapiErrorCodeTest, NapiDeleteElementTest003, testing::ext::TestSize.Level1)
1310 {
1311 napi_env env = reinterpret_cast<napi_env>(engine_);
1312 napi_value obj;
1313 napi_value value;
1314
1315 napi_status status = napi_create_double(env, TEST_DOUBLE, &obj);
1316 ASSERT_EQ(status, napi_ok);
1317 napi_create_int32(env, INT_THREE, &value);
1318 napi_set_element(env, obj, INT_ONE, value);
1319 bool res;
1320 status = napi_delete_element(env, obj, INT_ONE, &res);
1321 ASSERT_EQ(status, napi_object_expected);
1322 }
1323
1324 HWTEST_F(NapiErrorCodeTest, NapiDefinePropertiesTest001, testing::ext::TestSize.Level1)
1325 {
1326 napi_env env = reinterpret_cast<napi_env>(engine_);
1327 napi_property_descriptor desc[] = {
__anon3c80bded0102() 1328 {"testMethod", nullptr, [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; },
1329 nullptr, nullptr, nullptr, napi_default, nullptr},
1330 };
1331 napi_value result = nullptr;
1332
1333 napi_status status = napi_define_properties(env, result, sizeof(desc)/sizeof(desc[0]), desc);
1334 ASSERT_EQ(status, napi_invalid_arg);
1335 }
1336
1337 HWTEST_F(NapiErrorCodeTest, NapiDefinePropertiesTest002, testing::ext::TestSize.Level1)
1338 {
1339 napi_env env = reinterpret_cast<napi_env>(engine_);
1340 napi_property_descriptor *desc = nullptr;
1341 napi_value result;
1342 napi_create_object(env, &result);
1343
1344 napi_status status = napi_define_properties(env, result, INT_ONE, desc);
1345 ASSERT_EQ(status, napi_invalid_arg);
1346 }
1347
1348 HWTEST_F(NapiErrorCodeTest, NapiDefinePropertiesTest003, testing::ext::TestSize.Level1)
1349 {
1350 napi_env env = reinterpret_cast<napi_env>(engine_);
1351 napi_property_descriptor desc[] = {
__anon3c80bded0202() 1352 {"testMethod", nullptr, [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; },
1353 nullptr, nullptr, nullptr, napi_default, nullptr},
1354 };
1355 napi_value result;
1356 napi_create_double(env, TEST_DOUBLE, &result);
1357
1358 napi_status status = napi_define_properties(env, result, INT_ONE, desc);
1359 ASSERT_EQ(status, napi_object_expected);
1360 }
1361
1362 HWTEST_F(NapiErrorCodeTest, NapiDefinePropertiesTest004, testing::ext::TestSize.Level1)
1363 {
1364 napi_env env = reinterpret_cast<napi_env>(engine_);
1365 napi_property_descriptor desc[] = {
__anon3c80bded0302() 1366 {nullptr, nullptr, [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; },
1367 nullptr, nullptr, nullptr, napi_default, nullptr},
1368 };
1369 napi_value result;
1370 napi_create_object(env, &result);
1371
1372 napi_status status = napi_define_properties(env, result, INT_ONE, desc);
1373 ASSERT_EQ(status, napi_name_expected);
1374 }
1375
1376 HWTEST_F(NapiErrorCodeTest, NapiDefinePropertiesTest005, testing::ext::TestSize.Level1)
1377 {
1378 napi_env env = reinterpret_cast<napi_env>(engine_);
1379 napi_value name;
1380 napi_create_object(env, &name);
1381 napi_property_descriptor desc[] = {
__anon3c80bded0402() 1382 {nullptr, name, [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; },
1383 nullptr, nullptr, nullptr, napi_default, nullptr},
1384 };
1385 napi_value result;
1386 napi_create_object(env, &result);
1387
1388 napi_status status = napi_define_properties(env, result, INT_ONE, desc);
1389 ASSERT_EQ(status, napi_name_expected);
1390 }
1391
1392 HWTEST_F(NapiErrorCodeTest, NapiDefinePropertiesTest006, testing::ext::TestSize.Level1)
1393 {
1394 napi_env env = reinterpret_cast<napi_env>(engine_);
1395 napi_value func1 = nullptr;
1396 napi_status status = napi_create_function(env, "testAbort", NAPI_AUTO_LENGTH,
1397 TestAbort, nullptr, &func1);
1398 ASSERT_TRUE(status == napi_ok);
1399 napi_property_descriptor properties[] = {
1400 // napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable
1401 {"testAbort", nullptr, nullptr, nullptr, nullptr, func1, napi_default, nullptr}
1402 };
1403 napi_value globalObj = nullptr;
1404 napi_get_global(env, &globalObj);
1405 status = napi_define_properties(env, globalObj, sizeof(properties) / sizeof(properties[0]), properties);
1406 ASSERT_TRUE(status == napi_ok);
1407 }
1408
1409 HWTEST_F(NapiErrorCodeTest, NapiTypeTagObjectTest001, testing::ext::TestSize.Level1)
1410 {
1411 napi_env env = reinterpret_cast<napi_env>(engine_);
1412 napi_value obj = nullptr;
1413 napi_type_tag tag;
1414
1415 napi_status status = napi_type_tag_object(env, obj, &tag);
1416 ASSERT_EQ(status, napi_invalid_arg);
1417 }
1418
1419 HWTEST_F(NapiErrorCodeTest, NapiTypeTagObjectTest002, testing::ext::TestSize.Level1)
1420 {
1421 napi_env env = reinterpret_cast<napi_env>(engine_);
1422 napi_value obj;
1423 napi_type_tag* tag = nullptr;
1424 napi_create_object(env, &obj);
1425
1426 napi_status status = napi_type_tag_object(env, obj, tag);
1427 ASSERT_EQ(status, napi_invalid_arg);
1428 }
1429
1430 HWTEST_F(NapiErrorCodeTest, NapiTypeTagObjectTest003, testing::ext::TestSize.Level1)
1431 {
1432 napi_env env = reinterpret_cast<napi_env>(engine_);
1433 napi_value obj;
1434 napi_type_tag tag;
1435 napi_create_double(env, TEST_DOUBLE, &obj);
1436
1437 napi_status status = napi_type_tag_object(env, obj, &tag);
1438 ASSERT_EQ(status, napi_object_expected);
1439 }
1440
1441 HWTEST_F(NapiErrorCodeTest, NapiTypeTagObjectTest004, testing::ext::TestSize.Level1)
1442 {
1443 napi_env env = reinterpret_cast<napi_env>(engine_);
1444 napi_value obj;
1445 napi_type_tag tag;
1446 napi_create_int32(env, INT_ONE, &obj);
1447
1448 napi_status status = napi_type_tag_object(env, obj, &tag);
1449 ASSERT_EQ(status, napi_object_expected);
1450 }
1451
1452 HWTEST_F(NapiErrorCodeTest, NapiCheckObjectTypeTagTest001, testing::ext::TestSize.Level1)
1453 {
1454 napi_env env = reinterpret_cast<napi_env>(engine_);
1455 napi_value obj = nullptr;
1456 napi_type_tag tag;
1457 bool result;
1458
1459 napi_status status = napi_check_object_type_tag(env, obj, &tag, &result);
1460 ASSERT_EQ(status, napi_invalid_arg);
1461 }
1462
1463 HWTEST_F(NapiErrorCodeTest, NapiCheckObjectTypeTagTest002, testing::ext::TestSize.Level1)
1464 {
1465 napi_env env = reinterpret_cast<napi_env>(engine_);
1466 napi_value obj;
1467 napi_type_tag *tag = nullptr;
1468 bool result;
1469 napi_create_object(env, &obj);
1470
1471 napi_status status = napi_check_object_type_tag(env, obj, tag, &result);
1472 ASSERT_EQ(status, napi_invalid_arg);
1473 }
1474
1475 HWTEST_F(NapiErrorCodeTest, NapiCheckObjectTypeTagTest003, testing::ext::TestSize.Level1)
1476 {
1477 napi_env env = reinterpret_cast<napi_env>(engine_);
1478 napi_value obj;
1479 napi_type_tag tag;
1480 bool *result = nullptr;
1481 napi_create_object(env, &obj);
1482
1483 napi_status status = napi_check_object_type_tag(env, obj, &tag, result);
1484 ASSERT_EQ(status, napi_invalid_arg);
1485 }
1486
1487 HWTEST_F(NapiErrorCodeTest, NapiCheckObjectTypeTagTest004, testing::ext::TestSize.Level1)
1488 {
1489 napi_env env = reinterpret_cast<napi_env>(engine_);
1490 napi_value obj;
1491 napi_type_tag tag;
1492 napi_create_int32(env, INT_ONE, &obj);
1493
1494 napi_status status = napi_type_tag_object(env, obj, &tag);
1495 bool result;
1496 status = napi_check_object_type_tag(env, obj, &tag, &result);
1497 ASSERT_FALSE(result);
1498 ASSERT_EQ(status, napi_object_expected);
1499 }
1500
1501 HWTEST_F(NapiErrorCodeTest, NapiCallFunctionTest001, testing::ext::TestSize.Level1)
1502 {
1503 napi_env env = reinterpret_cast<napi_env>(engine_);
1504 napi_value funcValue = nullptr;
1505 napi_value recv = nullptr;
1506 size_t argc = 1;
1507 napi_value args[1] = {nullptr};
1508 napi_value funcResultValue = nullptr;
1509
1510 napi_status status = napi_call_function(env, recv, funcValue, argc, args, &funcResultValue);
1511 ASSERT_EQ(status, napi_invalid_arg);
1512 }
1513
1514 HWTEST_F(NapiErrorCodeTest, NapiCallFunctionTest002, testing::ext::TestSize.Level1)
1515 {
1516 napi_env env = reinterpret_cast<napi_env>(engine_);
1517 napi_value funcValue = nullptr;
1518 napi_value recv = nullptr;
1519 size_t argc = 1;
1520 napi_value* args = nullptr;
1521 napi_value funcResultValue = nullptr;
1522
1523 napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH,
__anon3c80bded0502(napi_env env, napi_callback_info info) 1524 [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; }, nullptr, &funcValue);
1525 napi_status status = napi_call_function(env, recv, funcValue, argc, args, &funcResultValue);
1526 ASSERT_EQ(status, napi_invalid_arg);
1527 }
1528
1529 HWTEST_F(NapiErrorCodeTest, NapiCallFunctionTest003, testing::ext::TestSize.Level1)
1530 {
1531 napi_env env = reinterpret_cast<napi_env>(engine_);
1532 napi_value funcValue = nullptr;
1533 napi_value recv = nullptr;
1534 size_t argc = 1;
1535 napi_value args[1] = {nullptr};
1536 napi_value funcResultValue = nullptr;
1537
1538 napi_create_object(env, &funcValue);
1539 napi_status status = napi_call_function(env, recv, funcValue, argc, args, &funcResultValue);
1540 ASSERT_EQ(status, napi_function_expected);
1541 }
1542
1543 HWTEST_F(NapiErrorCodeTest, NapiCallFunctionTest004, testing::ext::TestSize.Level1)
1544 {
1545 napi_env env = reinterpret_cast<napi_env>(engine_);
1546 napi_value funcValue = nullptr;
1547 napi_value recv = nullptr;
1548 size_t argc = 1;
1549 napi_value args[1] = {nullptr};
1550 napi_value funcResultValue = nullptr;
1551
__anon3c80bded0602(napi_env env, napi_callback_info info) 1552 napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, [](napi_env env, napi_callback_info info) -> napi_value {
1553 napi_throw_error(env, "500", "Common error");
1554 return nullptr;
1555 }, nullptr, &funcValue);
1556 napi_status status = napi_call_function(env, recv, funcValue, argc, args, &funcResultValue);
1557 ASSERT_EQ(status, napi_pending_exception);
1558 }
1559
1560 HWTEST_F(NapiErrorCodeTest, NapiCreateFunctionTest001, testing::ext::TestSize.Level1)
1561 {
1562 napi_env env = reinterpret_cast<napi_env>(engine_);
1563 napi_value funcValue = nullptr;
1564
1565 napi_status status = napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, nullptr, nullptr, &funcValue);
1566 ASSERT_EQ(status, napi_invalid_arg);
1567 }
1568
1569 HWTEST_F(NapiErrorCodeTest, NapiCreateFunctionTest002, testing::ext::TestSize.Level1)
1570 {
1571 napi_env env = reinterpret_cast<napi_env>(engine_);
1572 napi_value *funcValue = nullptr;
1573
1574 napi_status status = napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH,
__anon3c80bded0702(napi_env env, napi_callback_info info) 1575 [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; }, nullptr, funcValue);
1576 ASSERT_EQ(status, napi_invalid_arg);
1577 }
1578
1579 HWTEST_F(NapiErrorCodeTest, NapiGetCbInfoTest001, testing::ext::TestSize.Level1)
1580 {
1581 napi_env env = reinterpret_cast<napi_env>(engine_);
1582 napi_callback_info info = nullptr;
1583 size_t argc = 0;
1584 napi_value* argv = nullptr;
1585 napi_value thisVar;
1586 void* data = nullptr;
1587
1588 napi_status status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1589 ASSERT_EQ(status, napi_invalid_arg);
1590 }
1591
1592 HWTEST_F(NapiErrorCodeTest, NapiGetCbInfoTest002, testing::ext::TestSize.Level1)
1593 {
1594 napi_env env = reinterpret_cast<napi_env>(engine_);
1595 napi_callback_info info = nullptr;
1596 size_t argc = 0; // 0: define initial length
1597 napi_value* argv = nullptr;
1598 napi_value thisVar;
1599 void* data = nullptr;
1600 napi_value undefined = nullptr;
1601 napi_get_undefined(env, &undefined);
1602 napi_value sendableArray = nullptr;
1603 napi_create_sendable_array(env, &sendableArray);
1604 ASSERT_NE(sendableArray, nullptr);
1605 napi_status status = napi_serialize(env, sendableArray, undefined, undefined, &data);
1606 ASSERT_NE(data, nullptr);
1607 ASSERT_EQ(status, napi_ok);
1608
1609 status = napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
1610 ASSERT_EQ(status, napi_invalid_arg);
1611 }
1612
1613 HWTEST_F(NapiErrorCodeTest, NapiGetNewTargetTest001, testing::ext::TestSize.Level1)
1614 {
1615 napi_env env = reinterpret_cast<napi_env>(engine_);
1616 napi_callback_info info = nullptr;
1617 napi_value result;
1618
1619 napi_status status = napi_get_new_target(env, info, &result);
1620 ASSERT_EQ(status, napi_invalid_arg);
1621 }
1622
1623 HWTEST_F(NapiErrorCodeTest, NapiGetNewTargetTest002, testing::ext::TestSize.Level1)
1624 {
1625 napi_env env = reinterpret_cast<napi_env>(engine_);
1626 napi_callback_info info = napi_callback_info(nullptr);;
1627 napi_value* result = nullptr;
1628
1629 napi_status status = napi_get_new_target(env, info, result);
1630 ASSERT_EQ(status, napi_invalid_arg);
1631 }
1632
1633 HWTEST_F(NapiErrorCodeTest, NapiGetNewTargetTest003, testing::ext::TestSize.Level1)
1634 {
1635 napi_env env = reinterpret_cast<napi_env>(engine_);
1636 napi_callback_info info = napi_callback_info(nullptr);;
1637 napi_value result = nullptr;
1638 napi_create_int32(env, INT_ONE, &result);
1639
1640 napi_status status = napi_get_new_target(env, info, &result);
1641 ASSERT_EQ(status, napi_invalid_arg);
1642 }
1643
1644 HWTEST_F(NapiErrorCodeTest, NapiGetNewTargetTest004, testing::ext::TestSize.Level1)
1645 {
1646 napi_env env = reinterpret_cast<napi_env>(engine_);
1647 napi_callback_info info = napi_callback_info(nullptr);;
1648 napi_value result = nullptr;
1649 napi_create_double(env, TEST_DOUBLE, &result);
1650
1651 napi_status status = napi_get_new_target(env, info, &result);
1652 ASSERT_EQ(status, napi_invalid_arg);
1653 }
1654
1655 HWTEST_F(NapiErrorCodeTest, NapiGetNewTargetTest005, testing::ext::TestSize.Level1)
1656 {
1657 napi_env env = reinterpret_cast<napi_env>(engine_);
1658 napi_callback_info info = napi_callback_info(nullptr);;
1659 napi_value result = nullptr;
1660 napi_create_string_utf8(env, TEST_STRING, 4, &result);
1661
1662 napi_status status = napi_get_new_target(env, info, &result);
1663 ASSERT_EQ(status, napi_invalid_arg);
1664 }
1665
1666 HWTEST_F(NapiErrorCodeTest, NapiNewInstanceTest001, testing::ext::TestSize.Level1)
1667 {
1668 napi_env env = reinterpret_cast<napi_env>(engine_);
1669 napi_value constructor = nullptr;
1670 size_t argc = 0;
1671 napi_value args[1] = {nullptr};
1672 napi_value result;
1673
1674 napi_status status = napi_new_instance(env, constructor, argc, args, &result);
1675 ASSERT_EQ(status, napi_invalid_arg);
1676 }
1677
1678 HWTEST_F(NapiErrorCodeTest, NapiNewInstanceTest002, testing::ext::TestSize.Level1)
1679 {
1680 napi_env env = reinterpret_cast<napi_env>(engine_);
1681 napi_value constructor;
1682 size_t argc = 1;
1683 napi_value* args = nullptr;
1684 napi_value result;
1685
1686 napi_create_object(env, &constructor);
1687 napi_status status = napi_new_instance(env, constructor, argc, args, &result);
1688 ASSERT_EQ(status, napi_invalid_arg);
1689 }
1690
1691 HWTEST_F(NapiErrorCodeTest, NapiNewInstanceTest003, testing::ext::TestSize.Level1)
1692 {
1693 napi_env env = reinterpret_cast<napi_env>(engine_);
1694 napi_value constructor;
1695 size_t argc = 1;
1696 napi_value args[1] = {nullptr};
1697 napi_value* result = nullptr;
1698
1699 napi_create_object(env, &constructor);
1700 napi_status status = napi_new_instance(env, constructor, argc, args, result);
1701 ASSERT_EQ(status, napi_invalid_arg);
1702 }
1703
1704 HWTEST_F(NapiErrorCodeTest, NapiNewInstanceTest004, testing::ext::TestSize.Level1)
1705 {
1706 napi_env env = reinterpret_cast<napi_env>(engine_);
1707 napi_value constructor;
1708 size_t argc = 1;
1709 napi_value args[1] = {nullptr};
1710 napi_value result;
1711
1712 napi_create_object(env, &constructor);
1713 napi_status status = napi_new_instance(env, constructor, argc, args, &result);
1714 ASSERT_EQ(status, napi_function_expected);
1715 }
1716
1717 HWTEST_F(NapiErrorCodeTest, NapiDefineClassTest001, testing::ext::TestSize.Level1)
1718 {
1719 napi_env env = reinterpret_cast<napi_env>(engine_);
1720 napi_value result;
1721 napi_status status = napi_define_class(
1722 env, nullptr, NAPI_AUTO_LENGTH,
__anon3c80bded0802(napi_env env, napi_callback_info info) 1723 [](napi_env env, napi_callback_info info) -> napi_value {
1724 napi_value thisVar = nullptr;
1725 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1726
1727 return thisVar;
1728 },
1729 nullptr, 0, nullptr, &result);
1730 ASSERT_EQ(status, napi_invalid_arg);
1731 }
1732
1733
1734 HWTEST_F(NapiErrorCodeTest, NapiDefineClassTest002, testing::ext::TestSize.Level1)
1735 {
1736 napi_env env = reinterpret_cast<napi_env>(engine_);
1737 napi_value result;
1738 napi_status status = napi_define_class(
1739 env, "TestClass", NAPI_AUTO_LENGTH,
1740 nullptr, nullptr, 0, nullptr, &result);
1741 ASSERT_EQ(status, napi_invalid_arg);
1742 }
1743
1744 HWTEST_F(NapiErrorCodeTest, NapiDefineClassTest003, testing::ext::TestSize.Level1)
1745 {
1746 napi_env env = reinterpret_cast<napi_env>(engine_);
1747 napi_value* result = nullptr;
1748 napi_status status = napi_define_class(
1749 env, "TestClass", NAPI_AUTO_LENGTH,
__anon3c80bded0902(napi_env env, napi_callback_info info) 1750 [](napi_env env, napi_callback_info info) -> napi_value {
1751 napi_value thisVar = nullptr;
1752 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1753
1754 return thisVar;
1755 },
1756 nullptr, 0, nullptr, result);
1757 ASSERT_EQ(status, napi_invalid_arg);
1758 }
1759
1760 HWTEST_F(NapiErrorCodeTest, NapiDefineClassTest004, testing::ext::TestSize.Level1)
1761 {
1762 napi_env env = reinterpret_cast<napi_env>(engine_);
1763 napi_value result;
1764 napi_status status = napi_define_class(
1765 env, "TestClass", NAPI_AUTO_LENGTH,
__anon3c80bded0a02(napi_env env, napi_callback_info info) 1766 [](napi_env env, napi_callback_info info) -> napi_value {
1767 napi_value thisVar = nullptr;
1768 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1769
1770 return thisVar;
1771 },
1772 nullptr, 1, nullptr, &result);
1773 ASSERT_EQ(status, napi_invalid_arg);
1774 }
1775
1776 HWTEST_F(NapiErrorCodeTest, NapiWrapTest001, testing::ext::TestSize.Level1)
1777 {
1778 napi_env env = reinterpret_cast<napi_env>(engine_);
1779 napi_value obj = nullptr;
1780 napi_ref result;
1781
1782 napi_status status = napi_wrap(env, obj, (void *)TEST_STRING,
__anon3c80bded0b02(napi_env, void* data, void* hint) 1783 [](napi_env, void* data, void* hint) {}, nullptr, &result);
1784 ASSERT_EQ(status, napi_invalid_arg);
1785 }
1786
1787 HWTEST_F(NapiErrorCodeTest, NapiWrapTest002, testing::ext::TestSize.Level1)
1788 {
1789 napi_env env = reinterpret_cast<napi_env>(engine_);
1790 napi_value obj;
1791 napi_ref result;
1792
1793 napi_create_object(env, &obj);
__anon3c80bded0c02(napi_env, void* data, void* hint) 1794 napi_status status = napi_wrap(env, obj, nullptr, [](napi_env, void* data, void* hint) {}, nullptr, &result);
1795 ASSERT_EQ(status, napi_invalid_arg);
1796 }
1797
1798 HWTEST_F(NapiErrorCodeTest, NapiWrapTest003, testing::ext::TestSize.Level1)
1799 {
1800 napi_env env = reinterpret_cast<napi_env>(engine_);
1801 napi_value obj;
1802 napi_ref result;
1803
1804 napi_create_object(env, &obj);
1805 napi_status status = napi_wrap(env, obj, (void *)TEST_STRING, nullptr, nullptr, &result);
1806 ASSERT_EQ(status, napi_invalid_arg);
1807 }
1808
1809 HWTEST_F(NapiErrorCodeTest, NapiWrapTest004, testing::ext::TestSize.Level1)
1810 {
1811 napi_env env = reinterpret_cast<napi_env>(engine_);
1812 napi_value obj;
1813 napi_ref result;
1814
1815 napi_create_double(env, TEST_DOUBLE, &obj);
1816 napi_status status = napi_wrap(env, obj, (void *)TEST_STRING,
__anon3c80bded0d02(napi_env, void* data, void* hint) 1817 [](napi_env, void* data, void* hint) {}, nullptr, &result);
1818 ASSERT_EQ(status, napi_object_expected);
1819 }
1820
1821 HWTEST_F(NapiErrorCodeTest, NapiWrapTest005, testing::ext::TestSize.Level1)
1822 {
1823 napi_env env = reinterpret_cast<napi_env>(engine_);
1824 napi_value obj;
1825 napi_ref result;
1826
1827 napi_create_int32(env, INT_ONE, &obj);
1828 napi_status status = napi_wrap(env, obj, (void *)TEST_STRING,
__anon3c80bded0e02(napi_env, void* data, void* hint) 1829 [](napi_env, void* data, void* hint) {}, nullptr, &result);
1830 ASSERT_EQ(status, napi_object_expected);
1831 }
1832
1833 HWTEST_F(NapiErrorCodeTest, NapiWrapTest006, testing::ext::TestSize.Level1)
1834 {
1835 napi_env env = reinterpret_cast<napi_env>(engine_);
1836 napi_value obj;
1837 napi_ref result;
1838
1839 napi_create_int64(env, INT_TWO, &obj);
1840 napi_status status = napi_wrap(env, obj, (void *)TEST_STRING,
__anon3c80bded0f02(napi_env, void* data, void* hint) 1841 [](napi_env, void* data, void* hint) {}, nullptr, &result);
1842 ASSERT_EQ(status, napi_object_expected);
1843 }
1844
1845 HWTEST_F(NapiErrorCodeTest, NapiUnwrapTest001, testing::ext::TestSize.Level1)
1846 {
1847 napi_env env = reinterpret_cast<napi_env>(engine_);
1848 napi_value obj = nullptr;
1849 char *testStr = nullptr;
1850
1851 napi_status status = napi_unwrap(env, obj, (void **)&testStr);
1852 ASSERT_EQ(status, napi_invalid_arg);
1853 }
1854
1855 HWTEST_F(NapiErrorCodeTest, NapiUnwrapTest002, testing::ext::TestSize.Level1)
1856 {
1857 napi_env env = reinterpret_cast<napi_env>(engine_);
1858 napi_value obj;
1859 char **testStr = nullptr;
1860
1861 napi_create_object(env, &obj);
1862 napi_status status = napi_unwrap(env, obj, (void **)testStr);
1863 ASSERT_EQ(status, napi_invalid_arg);
1864 }
1865
1866 HWTEST_F(NapiErrorCodeTest, NapiUnwrapTest003, testing::ext::TestSize.Level1)
1867 {
1868 napi_env env = reinterpret_cast<napi_env>(engine_);
1869 napi_value obj = nullptr;
1870 char *testStr = nullptr;
1871
1872 napi_create_double(env, TEST_DOUBLE, &obj);
1873 napi_status status = napi_unwrap(env, obj, (void **)&testStr);
1874 ASSERT_EQ(status, napi_object_expected);
1875 }
1876
1877 HWTEST_F(NapiErrorCodeTest, NapiUnwrapTest004, testing::ext::TestSize.Level1)
1878 {
1879 napi_env env = reinterpret_cast<napi_env>(engine_);
1880 napi_value obj = nullptr;
1881 char *testStr = nullptr;
1882
1883 napi_create_int32(env, INT_ONE, &obj);
1884 napi_status status = napi_unwrap(env, obj, (void **)&testStr);
1885 ASSERT_EQ(status, napi_object_expected);
1886 }
1887
1888 HWTEST_F(NapiErrorCodeTest, NapiUnwrapTest005, testing::ext::TestSize.Level1)
1889 {
1890 napi_env env = reinterpret_cast<napi_env>(engine_);
1891 napi_value obj = nullptr;
1892 char *testStr = nullptr;
1893
1894 napi_create_int64(env, INT_TWO, &obj);
1895 napi_status status = napi_unwrap(env, obj, (void **)&testStr);
1896 ASSERT_EQ(status, napi_object_expected);
1897 }
1898
1899 HWTEST_F(NapiErrorCodeTest, NapiUnwrapTest006, testing::ext::TestSize.Level1)
1900 {
1901 napi_env env = reinterpret_cast<napi_env>(engine_);
1902 napi_value obj;
1903 char **testStr = nullptr;
__anon3c80bded1002(napi_env env, napi_callback_info info) 1904 auto func = [](napi_env env, napi_callback_info info) -> napi_value {
1905 return nullptr;
1906 };
1907
1908 napi_create_function(env, nullptr, 0, func, nullptr, &obj);
1909 napi_status status = napi_unwrap(env, obj, (void **)testStr);
1910 ASSERT_EQ(status, napi_invalid_arg);
1911 }
1912
1913 HWTEST_F(NapiErrorCodeTest, NapiRemoveWrapTest001, testing::ext::TestSize.Level1)
1914 {
1915 napi_env env = reinterpret_cast<napi_env>(engine_);
1916 napi_value obj = nullptr;
1917 char *testStr = nullptr;
1918
1919 napi_status status = napi_remove_wrap(env, obj, (void **)&testStr);
1920 ASSERT_EQ(status, napi_invalid_arg);
1921 }
1922
1923 HWTEST_F(NapiErrorCodeTest, NapiRemoveWrapTest002, testing::ext::TestSize.Level1)
1924 {
1925 napi_env env = reinterpret_cast<napi_env>(engine_);
1926 napi_value obj;
1927 char **testStr = nullptr;
1928
1929 napi_create_object(env, &obj);
1930 napi_status status = napi_remove_wrap(env, obj, (void **)testStr);
1931 ASSERT_EQ(status, napi_invalid_arg);
1932 }
1933
1934 HWTEST_F(NapiErrorCodeTest, NapiRemoveWrapTest003, testing::ext::TestSize.Level1)
1935 {
1936 napi_env env = reinterpret_cast<napi_env>(engine_);
1937 napi_value obj = nullptr;
1938 char *testStr = nullptr;
1939
1940 napi_create_double(env, TEST_DOUBLE, &obj);
1941 napi_status status = napi_remove_wrap(env, obj, (void **)&testStr);
1942 ASSERT_EQ(status, napi_object_expected);
1943 }