• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "napi/native_api.h"
17 #include "native_utils.h"
18 #include "test.h"
19 
20 constexpr const int32_t LENGTH = 1024;
21 static constexpr int INT_ONE = 1;
22 static constexpr int INT_TWO = 2;
23 static constexpr int INT_FOUR = 4;
24 static constexpr int BUFF_SIZE = 20;
25 static constexpr const char TEST_CHAR_STRING[] = "TestString";
26 static constexpr const char TEST_CHAR_ERROR_MESSAGE[] = "Common error";
27 static constexpr const char TEST_CHAR_ERROR_CODE[] = "500";
28 static constexpr const char TEST_CHAR_ERROR_CODE_KEY[] = "code";
29 static constexpr const char TEST_CHAR_ERROR_MESSAGE_KEY[] = "message";
30 
31 class NapiPendingExceptionTest : public NativeEngineTest {
32 public:
SetUpTestCase()33     static void SetUpTestCase()
34     {
35         GTEST_LOG_(INFO) << "NapiPendingExceptionTest SetUpTestCase";
36     }
37 
TearDownTestCase()38     static void TearDownTestCase()
39     {
40         GTEST_LOG_(INFO) << "NapiPendingExceptionTest TearDownTestCase";
41     }
42 
SetUp()43     void SetUp() override
44     {
45         napi_env env = reinterpret_cast<napi_env>(engine_);
46         napi_open_handle_scope(env, &scope_);
47     }
48 
TearDown()49     void TearDown() override
50     {
51         napi_env env = reinterpret_cast<napi_env>(engine_);
52         napi_value exception = nullptr;
53         napi_get_and_clear_last_exception(env, &exception);
54         napi_close_handle_scope(env, scope_);
55     }
56 
ConstructionException()57     inline void ConstructionException()
58     {
59         napi_env env = reinterpret_cast<napi_env>(engine_);
60         bool isExceptionPending = false;
61         ASSERT_CHECK_CALL(napi_throw_error(env, nullptr, TEST_CHAR_ERROR_MESSAGE));
62         ASSERT_CHECK_CALL(napi_is_exception_pending(env, &isExceptionPending));
63         ASSERT_TRUE(isExceptionPending);
64         engine_->lastException_ = panda::JSNApi::GetUncaughtException(engine_->GetEcmaVm());
65     }
66 
DestructionException()67     inline void DestructionException()
68     {
69         napi_env env = reinterpret_cast<napi_env>(engine_);
70         napi_value result = nullptr;
71         ASSERT_CHECK_CALL(napi_get_and_clear_last_exception(env, &result));
72     }
73 
74 private:
75     napi_handle_scope scope_ = nullptr;
76 };
77 
78 HWTEST_F(NapiPendingExceptionTest, NapiLoadModuleWithInfoTest001, testing::ext::TestSize.Level1)
79 {
80     ASSERT_NE(engine_, nullptr);
81     napi_env env = reinterpret_cast<napi_env>(engine_);
82 
83     ConstructionException();
84     napi_value result = nullptr;
85     napi_status res = napi_load_module_with_info(env, nullptr, nullptr, &result);
86     DestructionException();
87     ASSERT_EQ(res, napi_pending_exception);
88 }
89 
90 HWTEST_F(NapiPendingExceptionTest, NapiCreateArraybufferTest001, testing::ext::TestSize.Level1)
91 {
92     ASSERT_NE(engine_, nullptr);
93     napi_env env = reinterpret_cast<napi_env>(engine_);
94 
95     ConstructionException();
96     napi_value arrayBuffer = nullptr;
97     void *arrayBufferPtr = nullptr;
98     napi_status res = napi_create_arraybuffer(env, LENGTH, &arrayBufferPtr, &arrayBuffer);
99     DestructionException();
100     ASSERT_EQ(res, napi_pending_exception);
101 }
102 
103 HWTEST_F(NapiPendingExceptionTest, NapiCreateExternalArraybufferTest001, testing::ext::TestSize.Level1)
104 {
105     ASSERT_NE(engine_, nullptr);
106     napi_env env = reinterpret_cast<napi_env>(engine_);
107 
108     ConstructionException();
109     napi_value external = nullptr;
110     napi_status res = napi_create_external_arraybuffer(
111         env,
112         (void *)TEST_CHAR_STRING,
113         strlen(TEST_CHAR_STRING),
__anone2de46bc0102(napi_env env, void *data, void *hint) 114         [](napi_env env, void *data, void *hint) { ASSERT_STREQ((const char *)data, (const char *)hint); },
115         (void *)TEST_CHAR_STRING,
116         &external);
117     ASSERT_EQ(res, napi_pending_exception);
118 }
119 
120 HWTEST_F(NapiPendingExceptionTest, NapiCreateTypedarrayTest001, testing::ext::TestSize.Level1)
121 {
122     ASSERT_NE(engine_, nullptr);
123     napi_env env = reinterpret_cast<napi_env>(engine_);
124 
125     napi_value arrayBuffer = nullptr;
126     void *arrayBufferPtr = nullptr;
127     ASSERT_CHECK_CALL(napi_create_arraybuffer(env, LENGTH, &arrayBufferPtr, &arrayBuffer));
128 
129     ConstructionException();
130     napi_value typedArray = nullptr;
131     size_t byteOffsetCreate = 0;
132     napi_status res = napi_create_typedarray(env, napi_int8_array, LENGTH, arrayBuffer, byteOffsetCreate, &typedArray);
133     DestructionException();
134     ASSERT_EQ(res, napi_pending_exception);
135 }
136 
137 HWTEST_F(NapiPendingExceptionTest, NapiCreateDataviewTest001, testing::ext::TestSize.Level1)
138 {
139     ASSERT_NE(engine_, nullptr);
140     napi_env env = reinterpret_cast<napi_env>(engine_);
141 
142     napi_value arrayBuffer = nullptr;
143     void *arrayBufferPtr = nullptr;
144     ASSERT_CHECK_CALL(napi_create_arraybuffer(env, LENGTH, &arrayBufferPtr, &arrayBuffer));
145 
146     ConstructionException();
147     napi_value result = nullptr;
148     napi_status res = napi_create_dataview(env, LENGTH, arrayBuffer, 0, &result);
149     DestructionException();
150     ASSERT_EQ(res, napi_pending_exception);
151 }
152 
153 HWTEST_F(NapiPendingExceptionTest, NapiGetArrayLengthTest001, testing::ext::TestSize.Level1)
154 {
155     ASSERT_NE(engine_, nullptr);
156     napi_env env = reinterpret_cast<napi_env>(engine_);
157 
158     napi_value array = nullptr;
159     ASSERT_CHECK_CALL(napi_create_array(env, &array));
160 
161     ConstructionException();
162     uint32_t arrayLength = 0;
163     napi_status res = napi_get_array_length(env, array, &arrayLength);
164     DestructionException();
165     ASSERT_EQ(res, napi_pending_exception);
166 }
167 
168 HWTEST_F(NapiPendingExceptionTest, NapiGetPrototypeTest001, testing::ext::TestSize.Level1)
169 {
170     ASSERT_NE(engine_, nullptr);
171     napi_env env = reinterpret_cast<napi_env>(engine_);
172 
173     napi_value object = nullptr;
174     ASSERT_CHECK_CALL(napi_create_object(env, &object));
175 
176     ConstructionException();
177     napi_value result = nullptr;
178     napi_status res = napi_get_prototype(env, object, &result);
179     DestructionException();
180     ASSERT_EQ(res, napi_pending_exception);
181 }
182 
183 HWTEST_F(NapiPendingExceptionTest, NapiSetPropertyTest001, testing::ext::TestSize.Level1)
184 {
185     ASSERT_NE(engine_, nullptr);
186     napi_env env = reinterpret_cast<napi_env>(engine_);
187 
188     napi_value obj = nullptr;
189     napi_value key = nullptr;
190     napi_value value = nullptr;
191     ASSERT_CHECK_CALL(napi_create_object(env, &obj));
192     ASSERT_CHECK_CALL(napi_create_int32(env, INT_ONE, &key));
193     ASSERT_CHECK_CALL(napi_create_int32(env, INT_TWO, &value));
194 
195     ConstructionException();
196     napi_status res = napi_set_property(env, obj, key, value);
197     DestructionException();
198     ASSERT_EQ(res, napi_pending_exception);
199 }
200 
201 HWTEST_F(NapiPendingExceptionTest, NapiGetPropertyTest001, testing::ext::TestSize.Level1)
202 {
203     ASSERT_NE(engine_, nullptr);
204     napi_env env = reinterpret_cast<napi_env>(engine_);
205 
206     napi_value obj = nullptr;
207     napi_value key = nullptr;
208     napi_value value = nullptr;
209     ASSERT_CHECK_CALL(napi_create_object(env, &obj));
210     ASSERT_CHECK_CALL(napi_create_int32(env, INT_ONE, &key));
211     ASSERT_CHECK_CALL(napi_create_int32(env, INT_TWO, &value));
212     ASSERT_CHECK_CALL(napi_set_property(env, obj, key, value));
213 
214     ConstructionException();
215     napi_value result = nullptr;
216     napi_status res = napi_get_property(env, obj, key, &result);
217     DestructionException();
218     ASSERT_EQ(res, napi_pending_exception);
219 }
220 
221 HWTEST_F(NapiPendingExceptionTest, NapiHasPropertyTest001, testing::ext::TestSize.Level1)
222 {
223     ASSERT_NE(engine_, nullptr);
224     napi_env env = reinterpret_cast<napi_env>(engine_);
225 
226     napi_value obj = nullptr;
227     napi_value key = nullptr;
228     napi_value value = nullptr;
229     ASSERT_CHECK_CALL(napi_create_object(env, &obj));
230     ASSERT_CHECK_CALL(napi_create_int32(env, INT_ONE, &key));
231     ASSERT_CHECK_CALL(napi_create_int32(env, INT_TWO, &value));
232     ASSERT_CHECK_CALL(napi_set_property(env, obj, key, value));
233 
234     ConstructionException();
235     bool result = false;
236     napi_status res = napi_has_property(env, obj, key, &result);
237     DestructionException();
238     ASSERT_EQ(res, napi_pending_exception);
239 }
240 
241 HWTEST_F(NapiPendingExceptionTest, NapiDeletePropertyTest001, testing::ext::TestSize.Level1)
242 {
243     ASSERT_NE(engine_, nullptr);
244     napi_env env = reinterpret_cast<napi_env>(engine_);
245 
246     napi_value obj = nullptr;
247     napi_value key = nullptr;
248     napi_value value = nullptr;
249     ASSERT_CHECK_CALL(napi_create_object(env, &obj));
250     ASSERT_CHECK_CALL(napi_create_int32(env, INT_ONE, &key));
251     ASSERT_CHECK_CALL(napi_create_int32(env, INT_TWO, &value));
252     ASSERT_CHECK_CALL(napi_set_property(env, obj, key, value));
253 
254     ConstructionException();
255     bool result = false;
256     napi_status res = napi_delete_property(env, obj, key, &result);
257     DestructionException();
258     ASSERT_EQ(res, napi_pending_exception);
259 }
260 
261 HWTEST_F(NapiPendingExceptionTest, NapiHasOwnPropertyTest001, testing::ext::TestSize.Level1)
262 {
263     ASSERT_NE(engine_, nullptr);
264     napi_env env = reinterpret_cast<napi_env>(engine_);
265 
266     napi_value obj = nullptr;
267     napi_value key = nullptr;
268     napi_value value = nullptr;
269     ASSERT_CHECK_CALL(napi_create_object(env, &obj));
270     ASSERT_CHECK_CALL(napi_create_int32(env, INT_ONE, &key));
271     ASSERT_CHECK_CALL(napi_create_int32(env, INT_TWO, &value));
272     ASSERT_CHECK_CALL(napi_set_property(env, obj, key, value));
273 
274     ConstructionException();
275     bool result = false;
276     napi_status res = napi_has_own_property(env, obj, key, &result);
277     DestructionException();
278     ASSERT_EQ(res, napi_pending_exception);
279 }
280 
281 HWTEST_F(NapiPendingExceptionTest, NapiSetNamedPropertyTest001, testing::ext::TestSize.Level1)
282 {
283     ASSERT_NE(engine_, nullptr);
284     napi_env env = reinterpret_cast<napi_env>(engine_);
285 
286     napi_value obj = nullptr;
287     napi_value value = nullptr;
288     ASSERT_CHECK_CALL(napi_create_object(env, &obj));
289     ASSERT_CHECK_CALL(napi_create_int32(env, INT_TWO, &value));
290 
291     ConstructionException();
292     napi_status res = napi_set_named_property(env, obj, TEST_CHAR_STRING, value);
293     DestructionException();
294     ASSERT_EQ(res, napi_pending_exception);
295 }
296 
297 HWTEST_F(NapiPendingExceptionTest, NapiGetNamedPropertyTest001, testing::ext::TestSize.Level1)
298 {
299     ASSERT_NE(engine_, nullptr);
300     napi_env env = reinterpret_cast<napi_env>(engine_);
301 
302     napi_value obj = nullptr;
303     ASSERT_CHECK_CALL(napi_create_object(env, &obj));
304 
305     ConstructionException();
306     napi_value value = nullptr;
307     napi_status res = napi_get_named_property(env, obj, TEST_CHAR_STRING, &value);
308     DestructionException();
309     ASSERT_EQ(res, napi_pending_exception);
310 }
311 
312 HWTEST_F(NapiPendingExceptionTest, NapiHasNamedPropertyTest001, testing::ext::TestSize.Level1)
313 {
314     ASSERT_NE(engine_, nullptr);
315     napi_env env = reinterpret_cast<napi_env>(engine_);
316 
317     napi_value obj = nullptr;
318     ASSERT_CHECK_CALL(napi_create_object(env, &obj));
319 
320     ConstructionException();
321     bool value = false;
322     napi_status res = napi_has_named_property(env, obj, TEST_CHAR_STRING, &value);
323     DestructionException();
324     ASSERT_EQ(res, napi_pending_exception);
325 }
326 
327 HWTEST_F(NapiPendingExceptionTest, NapiSetElementTest001, testing::ext::TestSize.Level1)
328 {
329     ASSERT_NE(engine_, nullptr);
330     napi_env env = reinterpret_cast<napi_env>(engine_);
331 
332     napi_value array = nullptr;
333     napi_value value = nullptr;
334     ASSERT_CHECK_CALL(napi_create_array(env, &array));
335     ASSERT_CHECK_CALL(napi_create_int32(env, INT_ONE, &value));
336 
337     ConstructionException();
338     napi_status res = napi_set_element(env, array, 0, value);
339     DestructionException();
340     ASSERT_EQ(res, napi_pending_exception);
341 }
342 
343 HWTEST_F(NapiPendingExceptionTest, NapiGetElementTest001, testing::ext::TestSize.Level1)
344 {
345     ASSERT_NE(engine_, nullptr);
346     napi_env env = reinterpret_cast<napi_env>(engine_);
347 
348     napi_value array = nullptr;
349     ASSERT_CHECK_CALL(napi_create_array(env, &array));
350 
351     ConstructionException();
352     napi_value value = nullptr;
353     napi_status res = napi_get_element(env, array, 0, &value);
354     DestructionException();
355     ASSERT_EQ(res, napi_pending_exception);
356 }
357 
358 HWTEST_F(NapiPendingExceptionTest, NapiHasElementTest001, testing::ext::TestSize.Level1)
359 {
360     ASSERT_NE(engine_, nullptr);
361     napi_env env = reinterpret_cast<napi_env>(engine_);
362 
363     napi_value array = nullptr;
364     ASSERT_CHECK_CALL(napi_create_array(env, &array));
365 
366     ConstructionException();
367     bool value = false;
368     napi_status res = napi_has_element(env, array, 0, &value);
369     DestructionException();
370     ASSERT_EQ(res, napi_pending_exception);
371 }
372 
373 HWTEST_F(NapiPendingExceptionTest, NapiDeleteElementTest001, testing::ext::TestSize.Level1)
374 {
375     ASSERT_NE(engine_, nullptr);
376     napi_env env = reinterpret_cast<napi_env>(engine_);
377 
378     napi_value array = nullptr;
379     ASSERT_CHECK_CALL(napi_create_array(env, &array));
380 
381     ConstructionException();
382     bool value = false;
383     napi_status res = napi_delete_element(env, array, 0, &value);
384     DestructionException();
385     ASSERT_EQ(res, napi_pending_exception);
386 }
387 
388 HWTEST_F(NapiPendingExceptionTest, NapiCreateFunctionTest001, testing::ext::TestSize.Level1)
389 {
390     ASSERT_NE(engine_, nullptr);
391     napi_env env = reinterpret_cast<napi_env>(engine_);
392 
__anone2de46bc0202(napi_env env, napi_callback_info info) 393     auto func = [](napi_env env, napi_callback_info info) -> napi_value { return nullptr; };
394 
395     ConstructionException();
396     napi_value jsCallback = nullptr;
397     napi_status res = napi_create_function(env, TEST_CHAR_STRING, NAPI_AUTO_LENGTH, func, nullptr, &jsCallback);
398     DestructionException();
399     ASSERT_EQ(res, napi_pending_exception);
400 }
401 
402 HWTEST_F(NapiPendingExceptionTest, NapiNewInstanceTest001, testing::ext::TestSize.Level1)
403 {
404     ASSERT_NE(engine_, nullptr);
405     napi_env env = reinterpret_cast<napi_env>(engine_);
406 
407     napi_value testClass = nullptr;
408     ASSERT_CHECK_CALL(napi_define_class(
409         env,
410         TEST_CHAR_STRING,
411         NAPI_AUTO_LENGTH,
__anone2de46bc0302(napi_env env, napi_callback_info info) 412         [](napi_env env, napi_callback_info info) -> napi_value {
413             napi_value thisVar = nullptr;
414             napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
415             return thisVar;
416         },
417         nullptr,
418         0,
419         nullptr,
420         &testClass));
421 
422     ConstructionException();
423     napi_value instanceValue = nullptr;
424     napi_status res = napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
425     DestructionException();
426     ASSERT_EQ(res, napi_pending_exception);
427 }
428 
429 HWTEST_F(NapiPendingExceptionTest, NapiDefineClassTest001, testing::ext::TestSize.Level1)
430 {
431     ASSERT_NE(engine_, nullptr);
432     napi_env env = reinterpret_cast<napi_env>(engine_);
433 
434     ConstructionException();
435     napi_value testClass = nullptr;
436     napi_status res = napi_define_class(
437         env,
438         TEST_CHAR_STRING,
439         NAPI_AUTO_LENGTH,
__anone2de46bc0402(napi_env env, napi_callback_info info) 440         [](napi_env env, napi_callback_info info) -> napi_value {
441             napi_value thisVar = nullptr;
442             napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
443             return thisVar;
444         },
445         nullptr,
446         0,
447         nullptr,
448         &testClass);
449     DestructionException();
450     ASSERT_EQ(res, napi_pending_exception);
451 }
452 
453 HWTEST_F(NapiPendingExceptionTest, NapiWrapTest001, testing::ext::TestSize.Level1)
454 {
455     ASSERT_NE(engine_, nullptr);
456     napi_env env = reinterpret_cast<napi_env>(engine_);
457 
458     napi_value object = nullptr;
459     ASSERT_CHECK_CALL(napi_create_object(env, &object));
__anone2de46bc0502(napi_env, void *data, void *) 460     auto finalizer = [](napi_env, void *data, void *) { delete reinterpret_cast<uint8_t *>(data); };
461     uint8_t *data0 = new uint8_t;
462 
463     ConstructionException();
464     napi_status res = napi_wrap(env, object, data0, finalizer, nullptr, nullptr);
465     DestructionException();
466     ASSERT_EQ(res, napi_pending_exception);
467 }
468 
469 HWTEST_F(NapiPendingExceptionTest, NapiUnwrapTest001, testing::ext::TestSize.Level1)
470 {
471     ASSERT_NE(engine_, nullptr);
472     napi_env env = reinterpret_cast<napi_env>(engine_);
473 
474     napi_value object = nullptr;
475     ASSERT_CHECK_CALL(napi_create_object(env, &object));
__anone2de46bc0602(napi_env, void *data, void *) 476     auto finalizer = [](napi_env, void *data, void *) { delete reinterpret_cast<uint8_t *>(data); };
477     uint8_t *data0 = new uint8_t;
478     ASSERT_CHECK_CALL(napi_wrap(env, object, data0, finalizer, nullptr, nullptr));
479 
480     ConstructionException();
481     void *result = nullptr;
482     napi_status res = napi_unwrap(env, object, &result);
483     DestructionException();
484     ASSERT_EQ(res, napi_pending_exception);
485 }
486 
487 HWTEST_F(NapiPendingExceptionTest, NapiRemoveWrapTest001, testing::ext::TestSize.Level1)
488 {
489     ASSERT_NE(engine_, nullptr);
490     napi_env env = reinterpret_cast<napi_env>(engine_);
491 
492     napi_value object = nullptr;
493     ASSERT_CHECK_CALL(napi_create_object(env, &object));
__anone2de46bc0702(napi_env, void *data, void *) 494     auto finalizer = [](napi_env, void *data, void *) { delete reinterpret_cast<uint8_t *>(data); };
495     uint8_t *data0 = new uint8_t;
496     ASSERT_CHECK_CALL(napi_wrap(env, object, data0, finalizer, nullptr, nullptr));
497 
498     ConstructionException();
499     void *result = nullptr;
500     napi_status res = napi_remove_wrap(env, object, &result);
501     DestructionException();
502     ASSERT_EQ(res, napi_pending_exception);
503 }
504 
505 HWTEST_F(NapiPendingExceptionTest, NapiCreateBigintWordsTest001, testing::ext::TestSize.Level1)
506 {
507     ASSERT_NE(engine_, nullptr);
508     napi_env env = reinterpret_cast<napi_env>(engine_);
509 
510     int signBit = 0;
511     size_t wordCount = INT_FOUR;
512     uint64_t words[] = {12ULL, 34ULL, 56ULL, 78ULL};
513 
514     ConstructionException();
515     napi_value result = nullptr;
516     napi_status res = napi_create_bigint_words(env, signBit, wordCount, words, &result);
517     DestructionException();
518     ASSERT_EQ(res, napi_pending_exception);
519 }
520 
521 HWTEST_F(NapiPendingExceptionTest, NapiObjectFreezeTest001, testing::ext::TestSize.Level1)
522 {
523     ASSERT_NE(engine_, nullptr);
524     napi_env env = reinterpret_cast<napi_env>(engine_);
525 
526     napi_value obj = nullptr;
527     ASSERT_CHECK_CALL(napi_create_object(env, &obj));
528 
529     ConstructionException();
530     napi_status res = napi_object_freeze(env, obj);
531     DestructionException();
532     ASSERT_EQ(res, napi_pending_exception);
533 }
534 
535 HWTEST_F(NapiPendingExceptionTest, NapiObjectSealTest001, testing::ext::TestSize.Level1)
536 {
537     ASSERT_NE(engine_, nullptr);
538     napi_env env = reinterpret_cast<napi_env>(engine_);
539 
540     napi_value obj = nullptr;
541     ASSERT_CHECK_CALL(napi_create_object(env, &obj));
542 
543     ConstructionException();
544     napi_status res = napi_object_seal(env, obj);
545     DestructionException();
546     ASSERT_EQ(res, napi_pending_exception);
547 }
548 
549 /**
550  * @tc.name: NapiGetAndClearLastException001
551  * @tc.desc: Test napi_get_and_clear_last_exception without exception.
552  *           interface.
553  * @tc.type: FUNC
554  */
555 HWTEST_F(NapiPendingExceptionTest, NapiGetAndClearLastException001, testing::ext::TestSize.Level1)
556 {
557     ASSERT_NE(engine_, nullptr);
558     napi_env env = reinterpret_cast<napi_env>(engine_);
559 
560     napi_value exceptionObj = nullptr;
561     napi_status status = napi_get_and_clear_last_exception(env, &exceptionObj);
562     ASSERT_EQ(status, napi_ok);
563     ASSERT_EQ(exceptionObj, nullptr);
564 }
565 
566 /**
567  * @tc.name: NapiGetAndClearLastException002
568  * @tc.desc: Test napi_get_and_clear_last_exception with exception.
569  *           interface.
570  * @tc.type: FUNC
571  */
572 HWTEST_F(NapiPendingExceptionTest, NapiGetAndClearLastException002, testing::ext::TestSize.Level1)
573 {
574     ASSERT_NE(engine_, nullptr);
575     napi_env env = reinterpret_cast<napi_env>(engine_);
576 
577     napi_status status = napi_throw_error(env, TEST_CHAR_ERROR_CODE, TEST_CHAR_ERROR_MESSAGE);
578     ASSERT_EQ(status, napi_ok);
579 
580     napi_value exceptionObj = nullptr;
581     status = napi_get_and_clear_last_exception(env, &exceptionObj);
582     ASSERT_EQ(status, napi_ok);
583     ASSERT_NE(exceptionObj, nullptr);
584 
585     bool hasProperty = false;
586     ASSERT_CHECK_CALL(napi_has_named_property(env, exceptionObj, TEST_CHAR_ERROR_CODE_KEY, &hasProperty));
587     ASSERT_TRUE(hasProperty);
588     napi_value codeValue = nullptr;
589     ASSERT_CHECK_CALL(napi_get_named_property(env, exceptionObj, TEST_CHAR_ERROR_CODE_KEY, &codeValue));
590     char testCode[BUFF_SIZE] = {0};
591     size_t length = 0;
592     ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, codeValue, testCode, BUFF_SIZE, &length));
593     ASSERT_EQ(length, strlen(TEST_CHAR_ERROR_CODE));
594     ASSERT_STREQ(TEST_CHAR_ERROR_CODE, testCode);
595 
596     hasProperty = false;
597     ASSERT_CHECK_CALL(napi_has_named_property(env, exceptionObj, TEST_CHAR_ERROR_MESSAGE_KEY, &hasProperty));
598     ASSERT_TRUE(hasProperty);
599     napi_value messageValue = nullptr;
600     ASSERT_CHECK_CALL(napi_get_named_property(env, exceptionObj, TEST_CHAR_ERROR_MESSAGE_KEY, &messageValue));
601     char testMessage[BUFF_SIZE] = {0};
602     length = 0;
603     ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, messageValue, testMessage, BUFF_SIZE, &length));
604     ASSERT_EQ(length, strlen(TEST_CHAR_ERROR_MESSAGE));
605     ASSERT_STREQ(TEST_CHAR_ERROR_MESSAGE, testMessage);
606 }