1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstring>
17 #include <deque>
18 #include <fstream>
19 #include <iostream>
20 #include <string>
21 #include <vector>
22 #include <chrono>
23 #include <csetjmp>
24
25 #include "jsvm.h"
26 #include "jsvm_types.h"
27 #include "jsvm_utils.h"
28
29 #define JSVM_PARENT_CLASS_DES_COUNT 2
30 #define JSVM_OBJECT_INTERFAIELD_COUNT 3
31 #define JSVM_DEFINE_CLASS_OPTIONS_COUNT 2
32
33 using namespace std;
34 using namespace testing;
35 using namespace testing::ext;
36
37 JSVM_Env jsvm_env = nullptr;
38
39 static string srcProf = R"JS(
40 function sleep(delay) {
41 var start = (new Date()).getTime();
42 while ((new Date()).getTime() - start < delay) {
43 continue;
44 }
45 }
46 function work9() {
47 sleep(100);
48 }
49 function work8() {
50 work9();
51 sleep(100);
52 }
53 function work7() {
54 work8();
55 sleep(100);
56 }
57 function work6() {
58 work7();
59 sleep(100);
60 }
61 function work5() {
62 work6();
63 sleep(100);
64 }
65 function work4() {
66 work5();
67 sleep(100);
68 }
69
70 function work3() {
71 work4();
72 sleep(100);
73 }
74
75 function work2() {
76 work3();
77 sleep(100);
78 }
79
80 function work1() {
81 work2();
82 sleep(100);
83 }
84
85 work1();
86 )JS";
87
hello_fn(JSVM_Env env,JSVM_CallbackInfo info)88 static JSVM_Value hello_fn(JSVM_Env env, JSVM_CallbackInfo info)
89 {
90 JSVM_Value output;
91 void* data = nullptr;
92 OH_JSVM_GetCbInfo(env, info, nullptr, nullptr, nullptr, &data);
93 OH_JSVM_CreateStringUtf8(env, (char*)data, strlen((char*)data), &output);
94 return output;
95 }
96
97 class Task {
98 public:
99 virtual ~Task() = default;
100 virtual void Run() = 0;
101 };
102
103 static deque<Task*> task_queue;
104
read_fn(JSVM_Env env,JSVM_CallbackInfo info)105 static JSVM_Value read_fn(JSVM_Env env, JSVM_CallbackInfo info)
106 {
107 JSVM_Value promise;
108 JSVM_Deferred deferred;
109 OH_JSVM_CreatePromise(env, &deferred, &promise);
110 class ReadTask : public Task {
111 public:
112 ReadTask(JSVM_Env env, JSVM_Deferred deferred) : env_(env), deferred_(deferred) {}
113 void Run() override
114 {
115 string str;
116 getline(cin, str);
117 JSVM_Value result;
118 OH_JSVM_CreateStringUtf8(env_, str.c_str(), str.size(), &result);
119 OH_JSVM_ResolveDeferred(env_, deferred_, result);
120 }
121 private:
122 JSVM_Env env_;
123 JSVM_Deferred deferred_;
124 };
125 task_queue.push_back(new ReadTask(env, deferred));
126 return promise;
127 }
128
129 #define BUF_SIZE1 102400
print_fn(JSVM_Env env,JSVM_CallbackInfo info)130 static JSVM_Value print_fn(JSVM_Env env, JSVM_CallbackInfo info)
131 {
132 size_t argc = 1;
133 JSVM_Value argv[1];
134 OH_JSVM_GetCbInfo(env, info, &argc, argv, nullptr, nullptr);
135 if (argc > 0) {
136 char buf[BUF_SIZE1];
137 OH_JSVM_GetValueStringUtf8(env, argv[0], buf, BUF_SIZE1, nullptr);
138 std::cout << buf << std::endl;
139 }
140 return nullptr;
141 }
142
143 static JSVM_CallbackStruct hello_cb = { hello_fn, (void *)"Hello" };
144 static JSVM_CallbackStruct read_cb = { read_fn, nullptr };
145 static JSVM_CallbackStruct print_cb = { print_fn, nullptr };
146
147 static JSVM_PropertyDescriptor property_descriptors[] = {
148 {
149 "hello",
150 NULL,
151 &hello_cb,
152 NULL,
153 NULL,
154 NULL,
155 JSVM_DEFAULT
156 },
157 {
158 "read",
159 NULL,
160 &read_cb,
161 NULL,
162 NULL,
163 NULL,
164 JSVM_DEFAULT
165 },
166 {
167 "print",
168 NULL,
169 &print_cb,
170 NULL,
171 NULL,
172 NULL,
173 JSVM_DEFAULT
174 },
175 };
176
177 class JSVMTest : public testing::Test {
178 public:
SetUpTestCase()179 static void SetUpTestCase()
180 {
181 GTEST_LOG_(INFO) << "JSVMTest SetUpTestCase";
182 JSVM_InitOptions init_options{};
183 OH_JSVM_Init(&init_options);
184 }
185
TearDownTestCase()186 static void TearDownTestCase()
187 {
188 GTEST_LOG_(INFO) << "JSVMTest TearDownTestCase";
189 }
190
SetUp()191 void SetUp() override
192 {
193 GTEST_LOG_(INFO) << "JSVMTest SetUp";
194 OH_JSVM_CreateVM(nullptr, &vm);
195 // propertyCount is 3
196 OH_JSVM_CreateEnv(vm, 3, property_descriptors, &env);
197 OH_JSVM_OpenVMScope(vm, &vm_scope);
198 OH_JSVM_OpenEnvScope(env, &env_scope);
199 OH_JSVM_OpenHandleScope(env, &handleScope);
200 jsvm_env = env;
201 }
TearDown()202 void TearDown() override
203 {
204 GTEST_LOG_(INFO) << "JSVMTest TearDown";
205 OH_JSVM_CloseHandleScope(env, handleScope);
206 OH_JSVM_CloseEnvScope(env, env_scope);
207 OH_JSVM_CloseVMScope(vm, vm_scope);
208 OH_JSVM_DestroyEnv(env);
209 OH_JSVM_DestroyVM(vm);
210 }
211
212 protected:
213 JSVM_Env env = nullptr;
214 JSVM_VM vm = nullptr;
215 JSVM_EnvScope env_scope = nullptr;
216 JSVM_VMScope vm_scope = nullptr;
217 JSVM_HandleScope handleScope;
218 };
219
220 HWTEST_F(JSVMTest, JSVMGetVersion001, TestSize.Level1)
221 {
222 uint32_t versionId = 0;
223 JSVMTEST_CALL(OH_JSVM_GetVersion(env, &versionId));
224 ASSERT_EQ(versionId, 9);
225 }
226
227 HWTEST_F(JSVMTest, JSVMEquals001, TestSize.Level1)
228 {
229 JSVM_Value lhs = nullptr;
230 bool x = true;
231 JSVMTEST_CALL(OH_JSVM_GetBoolean(env, x, &lhs));
232 JSVM_Value rhs = nullptr;
233 bool y = true;
234 JSVMTEST_CALL(OH_JSVM_GetBoolean(env, y, &rhs));
235 bool isEquals = false;
236 JSVMTEST_CALL(OH_JSVM_Equals(env, lhs, rhs, &isEquals));
237 ASSERT_TRUE(isEquals);
238 }
239
240 HWTEST_F(JSVMTest, JSVMCreateCodeCache001, TestSize.Level1)
241 {
242 JSVM_Value jsSrc;
243 JSVMTEST_CALL(OH_JSVM_CreateStringUtf8(env, srcProf.c_str(), srcProf.size(), &jsSrc));
244
245 const uint8_t x1 = 34;
246 const uint8_t* x2 = &x1;
247 const uint8_t** dataPtr = &x2;
248 size_t x3 = 1;
249 size_t* lengthPtr = &x3;
250 JSVM_Script script = nullptr;
251 JSVMTEST_CALL(OH_JSVM_CompileScript(env, jsSrc, nullptr, 0, true, nullptr, &script));
252 JSVMTEST_CALL(OH_JSVM_CreateCodeCache(env, script, dataPtr, lengthPtr));
253 }
254
255 HWTEST_F(JSVMTest, JSVMAcquire001, TestSize.Level1)
256 {
257 JSVMTEST_CALL(OH_JSVM_AcquireLock(env));
258 }
259
260 HWTEST_F(JSVMTest, JSVMIsObject001, TestSize.Level1)
261 {
262 JSVM_Value obj;
263 JSVMTEST_CALL(OH_JSVM_CreateMap(env, &obj));
264 bool result = false;
265 JSVMTEST_CALL(OH_JSVM_IsObject(env, obj, &result));
266 ASSERT_TRUE(result);
267
268 JSVMTEST_CALL(OH_JSVM_CreateSymbol(env, nullptr, &obj));
269 result = false;
270 JSVMTEST_CALL(OH_JSVM_IsObject(env, obj, &result));
271 ASSERT_FALSE(result);
272 }
273
274 HWTEST_F(JSVMTest, JSVMIsBoolean001, TestSize.Level1)
275 {
276 JSVM_Value obj;
277 JSVMTEST_CALL(OH_JSVM_CreateArray(env, &obj));
278 bool result = false;
279 JSVMTEST_CALL(OH_JSVM_IsBoolean(env, obj, &result));
280 ASSERT_FALSE(result);
281
282 bool boolvalue = true;
283 JSVMTEST_CALL(OH_JSVM_GetBoolean(env, boolvalue, &obj));
284 result = false;
285 JSVMTEST_CALL(OH_JSVM_IsBoolean(env, obj, &result));
286 ASSERT_TRUE(result);
287 }
288
289 HWTEST_F(JSVMTest, JSVMIsString001, TestSize.Level1)
290 {
291 JSVM_Value createString;
292 char str[12] = "hello world";
293 JSVMTEST_CALL(OH_JSVM_CreateStringUtf8(env, str, 12, &createString));
294 bool result = false;
295 JSVMTEST_CALL(OH_JSVM_IsString(env, createString, &result));
296 ASSERT_TRUE(result);
297
298 JSVM_Value obj = nullptr;
299 JSVMTEST_CALL(OH_JSVM_CreateSet(env, &obj));
300 result = false;
301 JSVMTEST_CALL(OH_JSVM_IsString(env, obj, &result));
302 ASSERT_FALSE(result);
303 }
304
305 HWTEST_F(JSVMTest, JSVMIsFunction001, TestSize.Level1)
306 {
307 JSVM_Value function;
308 JSVM_CallbackStruct param;
309 param.data = nullptr;
310 param.callback = nullptr;
311 JSVMTEST_CALL(OH_JSVM_CreateFunction(env, "func", JSVM_AUTO_LENGTH, ¶m, &function));
312 bool result = false;
313 JSVMTEST_CALL(OH_JSVM_IsFunction(env, function, &result));
314 ASSERT_TRUE(result);
315
316 JSVM_Value obj;
317 JSVMTEST_CALL(OH_JSVM_CreateObject(env, &obj));
318 result = false;
319 JSVMTEST_CALL(OH_JSVM_IsFunction(env, obj, &result));
320 ASSERT_FALSE(result);
321 }
322
323 HWTEST_F(JSVMTest, JSVMIsSymbol001, TestSize.Level1)
324 {
325 JSVM_Value obj;
326 JSVMTEST_CALL(OH_JSVM_CreateSymbol(env, nullptr, &obj));
327 bool result = false;
328 JSVMTEST_CALL(OH_JSVM_IsSymbol(env, obj, &result));
329 ASSERT_TRUE(result);
330
331 JSVMTEST_CALL(OH_JSVM_CreateObject(env, &obj));
332 result = false;
333 JSVMTEST_CALL(OH_JSVM_IsSymbol(env, obj, &result));
334 ASSERT_FALSE(result);
335 }
336
337 HWTEST_F(JSVMTest, JSVMIsNumber001, TestSize.Level1)
338 {
339 JSVM_Value obj;
340 JSVMTEST_CALL(OH_JSVM_CreateObject(env, &obj));
341 bool result = false;
342 JSVMTEST_CALL(OH_JSVM_IsNumber(env, obj, &result));
343 ASSERT_FALSE(result);
344
345 JSVM_Value value;
346 int intValue = 2;
347 JSVMTEST_CALL(OH_JSVM_CreateInt32(env, intValue, &value));
348 result = false;
349 JSVMTEST_CALL(OH_JSVM_IsNumber(env, value, &result));
350 ASSERT_TRUE(result);
351 }
352
353 HWTEST_F(JSVMTest, JSVMIsBigInt001, TestSize.Level1)
354 {
355 JSVM_Value obj;
356 JSVMTEST_CALL(OH_JSVM_CreateObject(env, &obj));
357 bool result = false;
358 JSVMTEST_CALL(OH_JSVM_IsBigInt(env, obj, &result));
359 ASSERT_FALSE(result);
360
361 JSVM_Value bigint;
362 int intValue = 2;
363 JSVMTEST_CALL(OH_JSVM_CreateBigintInt64(env, intValue, &bigint));
364 result = false;
365 JSVMTEST_CALL(OH_JSVM_IsBigInt(env, bigint, &result));
366 ASSERT_TRUE(result);
367 }
368
369 HWTEST_F(JSVMTest, JSVMIsNull001, TestSize.Level1)
370 {
371 JSVM_Value input;
372 bool result = false;
373 JSVMTEST_CALL(OH_JSVM_CreateArray(env, &input));
374 JSVMTEST_CALL(OH_JSVM_IsNull(env, input, &result));
375 ASSERT_FALSE(result);
376
377 JSVM_Value input2;
378 bool result2;
379 JSVMTEST_CALL(OH_JSVM_GetNull(env, &input2));
380 JSVMTEST_CALL(OH_JSVM_IsNull(env, input2, &result2));
381 ASSERT_TRUE(result2);
382 }
383
384 HWTEST_F(JSVMTest, JSVMIsUndefined001, TestSize.Level1)
385 {
386 JSVM_Value input;
387 bool result = false;
388 JSVMTEST_CALL(OH_JSVM_CreateArray(env, &input));
389 JSVMTEST_CALL(OH_JSVM_IsUndefined(env, input, &result));
390 ASSERT_FALSE(result);
391
392 JSVM_Value input2;
393 bool result2;
394 JSVMTEST_CALL(OH_JSVM_GetUndefined(env, &input2));
395 JSVMTEST_CALL(OH_JSVM_IsUndefined(env, input2, &result2));
396 ASSERT_TRUE(result2);
397 }
398
399 HWTEST_F(JSVMTest, OH_JSVM_IsNullOrUndefined001, TestSize.Level1)
400 {
401 JSVM_Value input;
402 bool result = false;
403 JSVMTEST_CALL(OH_JSVM_CreateArray(env, &input));
404 JSVMTEST_CALL(OH_JSVM_IsNullOrUndefined(env, input, &result));
405 ASSERT_FALSE(result);
406
407 JSVM_Value input2;
408 bool result2 = false;
409 JSVMTEST_CALL(OH_JSVM_GetNull(env, &input2));
410 JSVMTEST_CALL(OH_JSVM_IsNullOrUndefined(env, input2, &result2));
411 ASSERT_TRUE(result2);
412
413 result2 = false;
414 JSVMTEST_CALL(OH_JSVM_GetUndefined(env, &input2));
415 JSVMTEST_CALL(OH_JSVM_IsNullOrUndefined(env, input2, &result2));
416 ASSERT_TRUE(result2);
417 }
418
419 HWTEST_F(JSVMTest, JSVMIsLocked001, TestSize.Level1)
420 {
421 bool isLocked = false;
422 JSVMTEST_CALL(OH_JSVM_IsLocked(env, &isLocked));
423 }
424
425 HWTEST_F(JSVMTest, JSVMReleaseLock001, TestSize.Level1)
426 {
427 bool isLocked = false;
428 JSVMTEST_CALL(OH_JSVM_IsLocked(env, &isLocked));
429 JSVMTEST_CALL(OH_JSVM_ReleaseLock(env));
430 }
431
432 HWTEST_F(JSVMTest, JSVMCompileScriptWithOrigin001, TestSize.Level1)
433 {
434 JSVM_Value jsSrc;
435 JSVMTEST_CALL(OH_JSVM_CreateStringUtf8(env, srcProf.c_str(), srcProf.size(), &jsSrc));
436 JSVM_Script script;
437 JSVM_ScriptOrigin origin {
438 .sourceMapUrl = "/data/local/tmp/workload/index.js.map",
439 // 源文件名字
440 .resourceName = "index.js",
441 // scirpt 在源文件中的起始行列号
442 .resourceLineOffset = 0,
443 .resourceColumnOffset = 0,
444 };
445 JSVMTEST_CALL(OH_JSVM_CompileScriptWithOrigin(env, jsSrc, nullptr, 0, true, nullptr, &origin, &script));
446 }
447
448 HWTEST_F(JSVMTest, JSVMCompileScriptWithOrigin002, TestSize.Level1)
449 {
450 JSVM_Value jsSrc = nullptr;
451 bool x = true;
452 JSVMTEST_CALL(OH_JSVM_GetBoolean(env, x, &jsSrc));
453 JSVM_Script script;
454 JSVM_ScriptOrigin origin {
455 .sourceMapUrl = "/data/local/tmp/workload/index.js.map",
456 // 源文件名字
457 .resourceName = "index.js",
458 // scirpt 在源文件中的起始行列号
459 .resourceLineOffset = 0,
460 .resourceColumnOffset = 0,
461 };
462 JSVM_Status status = OH_JSVM_CompileScriptWithOrigin(env, jsSrc, nullptr, 0, true, nullptr, &origin, &script);
463 ASSERT_EQ(status, 3);
464 }
465
466 HWTEST_F(JSVMTest, JSVMCompileScriptWithOrigin003, TestSize.Level1)
467 {
468 JSVM_Value jsSrc = nullptr;
469 bool x = true;
470 JSVMTEST_CALL(OH_JSVM_GetBoolean(env, x, &jsSrc));
471 JSVM_ScriptOrigin origin {
472 .sourceMapUrl = "/data/local/tmp/workload/index.js.map",
473 // 源文件名字
474 .resourceName = "index.js",
475 // scirpt 在源文件中的起始行列号
476 .resourceLineOffset = 0,
477 .resourceColumnOffset = 0,
478 };
479 JSVM_Status status = OH_JSVM_CompileScriptWithOrigin(env, jsSrc, nullptr, 0, true, nullptr, &origin, nullptr);
480 ASSERT_EQ(status, 1);
481 }
482
483 static JSVM_PropertyHandlerConfigurationStruct propertyCfg{
484 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr
485 };
486
487 HWTEST_F(JSVMTest, JSVMDefineClassWithPropertyHandler001, TestSize.Level1)
488 {
489 JSVM_CallbackStruct param;
__anon13abbe8e0102(JSVM_Env env, JSVM_CallbackInfo info) 490 param.callback = [](JSVM_Env env, JSVM_CallbackInfo info) -> JSVM_Value {
491 JSVM_Value thisVar = nullptr;
492 JSVMTEST_CALL(OH_JSVM_GetCbInfo(env, info, nullptr, nullptr, &thisVar, nullptr));
493 return thisVar;
494 };
495 param.data = nullptr;
496 JSVM_Value testWrapClass = nullptr;
497 JSVMTEST_CALL(OH_JSVM_DefineClassWithPropertyHandler(env, "Test2", 5, ¶m, 0, nullptr,
498 &propertyCfg, nullptr, &testWrapClass));
499 }
500
501 HWTEST_F(JSVMTest, JSVMDefineClassWithPropertyHandler002, TestSize.Level1)
502 {
503 JSVM_CallbackStruct param;
__anon13abbe8e0202(JSVM_Env env, JSVM_CallbackInfo info) 504 param.callback = [](JSVM_Env env, JSVM_CallbackInfo info) -> JSVM_Value {
505 JSVM_Value thisVar = nullptr;
506 JSVMTEST_CALL(OH_JSVM_GetCbInfo(env, info, nullptr, nullptr, &thisVar, nullptr));
507 return thisVar;
508 };
509 param.data = nullptr;
510 JSVM_Value testWrapClass = nullptr;
511 JSVMTEST_CALL(OH_JSVM_DefineClassWithPropertyHandler(env, "Test2", JSVM_AUTO_LENGTH, ¶m, 0,
512 nullptr, &propertyCfg, nullptr, &testWrapClass));
513 }
514
515 HWTEST_F(JSVMTest, JSVMDefineClassWithPropertyHandler003, TestSize.Level1)
516 {
517 JSVM_CallbackStruct param;
__anon13abbe8e0302(JSVM_Env env, JSVM_CallbackInfo info) 518 param.callback = [](JSVM_Env env, JSVM_CallbackInfo info) -> JSVM_Value {
519 JSVM_Value thisVar = nullptr;
520 JSVMTEST_CALL(OH_JSVM_GetCbInfo(env, info, nullptr, nullptr, &thisVar, nullptr));
521 return thisVar;
522 };
523 param.data = nullptr;
524 JSVM_Value testWrapClass = nullptr;
525 JSVMTEST_CALL(OH_JSVM_DefineClassWithPropertyHandler(env, "Test2", 4, ¶m, 0, nullptr, &propertyCfg,
526 nullptr, &testWrapClass));
527 }
528
529 HWTEST_F(JSVMTest, JSVMDefineClassWithPropertyHandler004, TestSize.Level1)
530 {
531 JSVM_CallbackStruct param;
__anon13abbe8e0402(JSVM_Env env, JSVM_CallbackInfo info) 532 param.callback = [](JSVM_Env env, JSVM_CallbackInfo info) -> JSVM_Value {
533 JSVM_Value thisVar = nullptr;
534 JSVMTEST_CALL(OH_JSVM_GetCbInfo(env, info, nullptr, nullptr, &thisVar, nullptr));
535 return thisVar;
536 };
537 param.data = nullptr;
538 JSVM_Value testWrapClass = nullptr;
539 JSVMTEST_CALL(OH_JSVM_DefineClassWithPropertyHandler(env, "Test2", 6, ¶m, 0, nullptr,
540 &propertyCfg, nullptr, &testWrapClass));
541 }
542
543 HWTEST_F(JSVMTest, JSVMDefineClassWithPropertyHandler005, TestSize.Level1)
544 {
545 JSVM_CallbackStruct param;
__anon13abbe8e0502(JSVM_Env env, JSVM_CallbackInfo info) 546 param.callback = [](JSVM_Env env, JSVM_CallbackInfo info) -> JSVM_Value {
547 JSVM_Value thisVar = nullptr;
548 JSVMTEST_CALL(OH_JSVM_GetCbInfo(env, info, nullptr, nullptr, &thisVar, nullptr));
549 return thisVar;
550 };
551 param.data = nullptr;
552 JSVM_Status status = OH_JSVM_DefineClassWithPropertyHandler(env, "Test2", JSVM_AUTO_LENGTH, ¶m, 0,
553 nullptr, &propertyCfg, nullptr, nullptr);
554 ASSERT_EQ(status, JSVM_INVALID_ARG);
555 }
556
557 HWTEST_F(JSVMTest, JSVMDefineClassWithPropertyHandler006, TestSize.Level1)
558 {
559 JSVM_Value testWrapClass = nullptr;
560 JSVM_Status status = OH_JSVM_DefineClassWithPropertyHandler(env, "Test2", JSVM_AUTO_LENGTH, nullptr, 0,
561 nullptr, &propertyCfg, nullptr, &testWrapClass);
562 ASSERT_EQ(status, JSVM_INVALID_ARG);
563 }
564
565 HWTEST_F(JSVMTest, JSVMDefineClassWithPropertyHandler007, TestSize.Level1)
566 {
567 JSVM_CallbackStruct param;
__anon13abbe8e0602(JSVM_Env env, JSVM_CallbackInfo info) 568 param.callback = [](JSVM_Env env, JSVM_CallbackInfo info) -> JSVM_Value {
569 JSVM_Value thisVar = nullptr;
570 JSVMTEST_CALL(OH_JSVM_GetCbInfo(env, info, nullptr, nullptr, &thisVar, nullptr));
571 return thisVar;
572 };
573 param.data = nullptr;
574 JSVM_Value testWrapClass = nullptr;
575 JSVM_Status status = OH_JSVM_DefineClassWithPropertyHandler(env, "Test2", JSVM_AUTO_LENGTH, ¶m, 0,
576 nullptr, nullptr, nullptr, &testWrapClass);
577 ASSERT_EQ(status, JSVM_INVALID_ARG);
578 }
579
580 HWTEST_F(JSVMTest, JSVMCreateSnapshot001, TestSize.Level1)
581 {
582 const char *blobData = nullptr;
583 size_t blobSize = 0;
584 JSVM_Env envs[1] = {env};
585 JSVM_Status status = OH_JSVM_CreateSnapshot(vm, 1, envs, &blobData, &blobSize);
586 ASSERT_EQ(status, JSVM_GENERIC_FAILURE);
587 }
588
589 HWTEST_F(JSVMTest, JSVMCreateEnvFromSnapshot001, TestSize.Level1)
590 {
591 JSVM_Env env2 = nullptr;
592 JSVM_Status status = OH_JSVM_CreateEnvFromSnapshot(vm, 0, &env2);
593 ASSERT_EQ(status, JSVM_GENERIC_FAILURE);
594 }
595
596 HWTEST_F(JSVMTest, JSVMTraceStart001, TestSize.Level1)
597 {
598 JSVM_Status status = OH_JSVM_TraceStart(0, nullptr, "default", 0);
599 ASSERT_EQ(status, JSVM_OK);
600 }
601
602 HWTEST_F(JSVMTest, JSVMTraceStart002, TestSize.Level1)
603 {
604 std::vector<JSVM_TraceCategory> category = {JSVM_TRACE_WASM};
605 JSVM_Status status = OH_JSVM_TraceStart(category.size(), category.data(), "custom", 100);
606 ASSERT_EQ(status, JSVM_OK);
607 }
608
609 HWTEST_F(JSVMTest, JSVMTraceStart003, TestSize.Level1)
610 {
611 std::vector<JSVM_TraceCategory> category(1);
612 *(int *)&category[0] = 100;
613 JSVM_Status status = OH_JSVM_TraceStart(category.size(), category.data(), "invalid", 0);
614 ASSERT_EQ(status, JSVM_INVALID_ARG);
615 }
616
617 HWTEST_F(JSVMTest, JSVMTraceStart004, TestSize.Level1)
618 {
619 std::vector<JSVM_TraceCategory> category = {JSVM_TRACE_WASM};
620 JSVM_Status status = OH_JSVM_TraceStart(0, category.data(), "invalid", 0);
621 ASSERT_EQ(status, JSVM_INVALID_ARG);
622 }
623
624 HWTEST_F(JSVMTest, JSVMTraceStart005, TestSize.Level1)
625 {
626 JSVM_Status status = OH_JSVM_TraceStart(1, nullptr, "invalid", 0);
627 ASSERT_EQ(status, JSVM_INVALID_ARG);
628 }
629
OutputStream(const char * data,int size,void * streamData)630 bool OutputStream(const char *data, int size, void *streamData)
631 {
632 std::string value(data, size);
633 *(std::string *)streamData = std::string(data, size);
634 return true;
635 }
636
637 HWTEST_F(JSVMTest, JSVMTraceStop001, TestSize.Level1)
638 {
639 JSVM_Status status = OH_JSVM_TraceStart(0, nullptr, "default", 0);
640 ASSERT_EQ(status, JSVM_OK);
641 std::string data;
642 status = OH_JSVM_TraceStop(OutputStream, (void *)&data);
643 ASSERT_EQ(status, JSVM_OK);
644 }
645
646 HWTEST_F(JSVMTest, JSVMTraceStop002, TestSize.Level1)
647 {
648 std::string data;
649 JSVM_Status status = OH_JSVM_TraceStop(OutputStream, (void *)&data);
650 ASSERT_EQ(status, JSVM_INVALID_ARG);
651 }
652
653 HWTEST_F(JSVMTest, JSVMTraceStop003, TestSize.Level1)
654 {
655 JSVM_Status status = OH_JSVM_TraceStart(0, nullptr, "default", 0);
656 ASSERT_EQ(status, JSVM_OK);
657 status = OH_JSVM_TraceStop(OutputStream, nullptr);
658 ASSERT_EQ(status, JSVM_INVALID_ARG);
659 }
660
661 HWTEST_F(JSVMTest, JSVMTraceStop004, TestSize.Level1)
662 {
663 JSVM_Status status = OH_JSVM_TraceStart(0, nullptr, "default", 0);
664 ASSERT_EQ(status, JSVM_OK);
665 std::string data;
666 status = OH_JSVM_TraceStop(nullptr, (void *)&data);
667 ASSERT_EQ(status, JSVM_INVALID_ARG);
668 }
669
670 HWTEST_F(JSVMTest, JSVMIsNumberObject001, TestSize.Level1)
671 {
672 JSVM_Value result = jsvm::Run("new Number(42)");
673 bool isNumberObject = false;
674 JSVMTEST_CALL(OH_JSVM_IsNumberObject(env, result, &isNumberObject));
675 ASSERT_TRUE(isNumberObject);
676 }
677
678 HWTEST_F(JSVMTest, JSVMIsBooleanObject001, TestSize.Level1)
679 {
680 JSVM_Value result = jsvm::Run("new Boolean(true)");
681 bool isBooleanObject = false;
682 JSVMTEST_CALL(OH_JSVM_IsBooleanObject(env, result, &isBooleanObject));
683 ASSERT_TRUE(isBooleanObject);
684 }
685
686 HWTEST_F(JSVMTest, JSVMIsBigIntObject001, TestSize.Level1)
687 {
688 JSVM_Value result = jsvm::Run("new Object(42n)");
689 bool isBigIntObject = false;
690 JSVMTEST_CALL(OH_JSVM_IsBigIntObject(env, result, &isBigIntObject));
691 ASSERT_TRUE(isBigIntObject);
692 }
693
694 HWTEST_F(JSVMTest, JSVMIsStringObject001, TestSize.Level1)
695 {
696 JSVM_Value result = jsvm::Run("new String(\"test\")");
697 bool isStringObject = false;
698 JSVMTEST_CALL(OH_JSVM_IsStringObject(env, result, &isStringObject));
699 ASSERT_TRUE(isStringObject);
700 }
701
702 HWTEST_F(JSVMTest, JSVMIsSymbolObject001, TestSize.Level1)
703 {
704 JSVM_Value result = jsvm::Run("Object(Symbol('foo'))");
705 bool isSymbolObject = false;
706 JSVMTEST_CALL(OH_JSVM_IsSymbolObject(env, result, &isSymbolObject));
707 ASSERT_TRUE(isSymbolObject);
708 }
709
710 HWTEST_F(JSVMTest, JSVMToStringTag001, TestSize.Level1)
711 {
712 JSVM_Value result;
713 JSVMTEST_CALL(OH_JSVM_GetSymbolToStringTag(env, &result));
714 ASSERT_TRUE(jsvm::StrictEquals(result, jsvm::Run("Symbol.toStringTag")));
715 }
716
717 HWTEST_F(JSVMTest, JSVMToPrimitive001, TestSize.Level1)
718 {
719 JSVM_Value result;
720 JSVMTEST_CALL(OH_JSVM_GetSymbolToPrimitive(env, &result));
721 ASSERT_TRUE(jsvm::StrictEquals(result, jsvm::Run("Symbol.toPrimitive")));
722 }
723
724 HWTEST_F(JSVMTest, JSVMSplit001, TestSize.Level1)
725 {
726 JSVM_Value result;
727 JSVMTEST_CALL(OH_JSVM_GetSymbolSplit(env, &result));
728 ASSERT_TRUE(jsvm::StrictEquals(result, jsvm::Run("Symbol.split")));
729 }
730
731 HWTEST_F(JSVMTest, JSVMSearch001, TestSize.Level1)
732 {
733 JSVM_Value result;
734 JSVMTEST_CALL(OH_JSVM_GetSymbolSearch(env, &result));
735 ASSERT_TRUE(jsvm::StrictEquals(result, jsvm::Run("Symbol.search")));
736 }
737
738 HWTEST_F(JSVMTest, JSVMReplace001, TestSize.Level1)
739 {
740 JSVM_Value result;
741 JSVMTEST_CALL(OH_JSVM_GetSymbolReplace(env, &result));
742 ASSERT_TRUE(jsvm::StrictEquals(result, jsvm::Run("Symbol.replace")));
743 }
744
745 HWTEST_F(JSVMTest, JSVMMatch001, TestSize.Level1)
746 {
747 JSVM_Value result;
748 JSVMTEST_CALL(OH_JSVM_GetSymbolMatch(env, &result));
749 ASSERT_TRUE(jsvm::StrictEquals(result, jsvm::Run("Symbol.match")));
750 }
751
752 HWTEST_F(JSVMTest, JSVMIsConcatSpreadable001, TestSize.Level1)
753 {
754 JSVM_Value result;
755 JSVMTEST_CALL(OH_JSVM_GetSymbolIsConcatSpreadable(env, &result));
756 ASSERT_TRUE(jsvm::StrictEquals(result, jsvm::Run("Symbol.isConcatSpreadable")));
757 }
758
759 HWTEST_F(JSVMTest, CreateProxy, TestSize.Level1)
760 {
761 std::string registerObject = R"JS(
762 target = {
763 message1: "hello",
764 message2: "everyone",
765 };
766
767 handler1 = {};
768 handler2 = {
769 get(target, prop, receiver) {
770 return "world";
771 },
772 };
773 )JS";
774
775 jsvm::Run(registerObject.c_str());
776 auto obj = jsvm::GetProperty(jsvm::Global(), "target");
777 auto handler1 = jsvm::GetProperty(jsvm::Global(), "handler1");
778 auto handler2 = jsvm::GetProperty(jsvm::Global(), "handler2");
779
780 JSVM_Value proxy1 = nullptr;
781 JSVMTEST_CALL(OH_JSVM_CreateProxy(env, obj, handler1, &proxy1));
782
783 JSVM_Value proxy2 = nullptr;
784 JSVMTEST_CALL(OH_JSVM_CreateProxy(env, obj, handler2, &proxy2));
785
786 jsvm::SetProperty(jsvm::Global(), "proxy1", proxy1);
787 jsvm::SetProperty(jsvm::Global(), "proxy2", proxy2);
788
789 std::string checkProxy1 = R"JS(
790 proxy1.message1 == target.message1 && proxy1.message2 == target.message2;
791 )JS";
792
793 auto result = jsvm::Run(checkProxy1.c_str());
794 ASSERT_TRUE(jsvm::IsTrue(result));
795
796 std::string checkProxy2 = R"JS(
797 proxy2.message1 == "world" && proxy2.message2 == "world" &&
798 proxy2.anyProperty == "world";
799 )JS";
800
801 result = jsvm::Run(checkProxy2.c_str());
802 ASSERT_TRUE(jsvm::IsTrue(result));
803 }
804
805 HWTEST_F(JSVMTest, IsProxy, TestSize.Level1)
806 {
807 jsvm::Run(R"JS(
808 target = {
809 message1: "hello",
810 message2: "everyone",
811 };
812
813 handler1 = {};
814 proxy1 = new Proxy(target, handler1);
815 )JS");
816
817 bool isProxy = false;
818
819 auto value = jsvm::GetProperty(jsvm::Global(), "target");
820 JSVMTEST_CALL(OH_JSVM_IsProxy(env, value, &isProxy));
821 ASSERT_TRUE(!isProxy && "target is not JS Proxy");
822
823 value = jsvm::GetProperty(jsvm::Global(), "handler1");
824 JSVMTEST_CALL(OH_JSVM_IsProxy(env, value, &isProxy));
825 ASSERT_TRUE(!isProxy && "handler1 is not JS Proxy");
826
827 value = jsvm::GetProperty(jsvm::Global(), "proxy1");
828 JSVMTEST_CALL(OH_JSVM_IsProxy(env, value, &isProxy));
829 ASSERT_TRUE(isProxy && "proxy1 is JS Proxy");
830 }
831
832 HWTEST_F(JSVMTest, GetProxyTarget, TestSize.Level1)
833 {
834 jsvm::Run(R"JS(
835 target = {
836 message1: "hello",
837 message2: "everyone",
838 };
839
840 handler1 = {};
841 proxy1 = new Proxy(target, handler1);
842 )JS");
843
844 auto target = jsvm::GetProperty(jsvm::Global(), "target");
845 auto proxy1 = jsvm::GetProperty(jsvm::Global(), "proxy1");
846
847 JSVM_Value result = nullptr;
848 JSVMTEST_CALL(OH_JSVM_ProxyGetTarget(env, proxy1, &result));
849
850 ASSERT_TRUE(jsvm::StrictEquals(target, result));
851 }
852
853 static std::string g_scriptEvalMicrotask = R"JS(
854 evaluateMicrotask = false;
855 Promise.resolve().then(()=>{
856 evaluateMicrotask = true;
857 });
858 evaluateMicrotask
859 )JS";
860
861 // Default microtask policy is JSVM_MICROTASK_AUTO
862 HWTEST_F(JSVMTest, MicrotaskPolicyDefault, TestSize.Level1)
863 {
864 auto result = jsvm::Run(g_scriptEvalMicrotask.c_str());
865 ASSERT_TRUE(jsvm::IsFalse(result));
866 result = jsvm::GetProperty(jsvm::Global(), "evaluateMicrotask");
867 ASSERT_TRUE(jsvm::IsTrue(result));
868 }
869
870 // Test Set Microtask Policy to explicit
871 HWTEST_F(JSVMTest, MicrotaskPolicyExplict, TestSize.Level1)
872 {
873 OH_JSVM_SetMicrotaskPolicy(vm, JSVM_MicrotaskPolicy::JSVM_MICROTASK_EXPLICIT);
874 auto result = jsvm::Run(g_scriptEvalMicrotask.c_str());
875 ASSERT_TRUE(jsvm::IsFalse(result));
876 result = jsvm::GetProperty(jsvm::Global(), "evaluateMicrotask");
877 ASSERT_TRUE(jsvm::IsFalse(result));
878 OH_JSVM_PerformMicrotaskCheckpoint(vm);
879 result = jsvm::GetProperty(jsvm::Global(), "evaluateMicrotask");
880 ASSERT_TRUE(jsvm::IsTrue(result));
881 }
882
883 // Test Set Microtask Policy to auto
884 HWTEST_F(JSVMTest, MicrotaskPolicyAuto, TestSize.Level1)
885 {
886 OH_JSVM_SetMicrotaskPolicy(vm, JSVM_MicrotaskPolicy::JSVM_MICROTASK_EXPLICIT);
887 OH_JSVM_SetMicrotaskPolicy(vm, JSVM_MicrotaskPolicy::JSVM_MICROTASK_AUTO);
888 auto result = jsvm::Run(g_scriptEvalMicrotask.c_str());
889 ASSERT_TRUE(jsvm::IsFalse(result));
890 result = jsvm::GetProperty(jsvm::Global(), "evaluateMicrotask");
891 ASSERT_TRUE(jsvm::IsTrue(result));
892 }
893
894 HWTEST_F(JSVMTest, MicrotaskInvalidPolicy, TestSize.Level1)
895 {
896 JSVM_MicrotaskPolicy invalidPolicy = (JSVM_MicrotaskPolicy)2;
897 auto status = OH_JSVM_SetMicrotaskPolicy(vm, invalidPolicy);
898 ASSERT_TRUE(status != JSVM_OK);
899 }
900
901 static std::string g_defineFunction = R"JS(
902 var x1 = 0;
903 var x2 = 0;
904 function f1(x) {
905 x1 = x;
906 return x + 1;
907 }
908 function f2(x) {
909 x2 = x;
910 return x + 1;
911 }
912 )JS";
913
914 static std::string g_init = R"JS(
915 x1 = 0;
916 x2 = 0;
917 )JS";
918
919 HWTEST_F(JSVMTest, PromiseThen, TestSize.Level1)
920 {
921 JSVM_Value promise = nullptr;
922 JSVM_Deferred deffered;
923
924 JSVMTEST_CALL(OH_JSVM_CreatePromise(env, &deffered, &promise));
925 jsvm::Run(g_defineFunction.c_str());
926
927 JSVM_Value f1 = jsvm::GetProperty(jsvm::Global(), "f1");
928
929 JSVMTEST_CALL(OH_JSVM_PromiseRegisterHandler(env, promise, f1, nullptr, nullptr));
930
931 auto x1 = jsvm::GetProperty(jsvm::Global(), "x1");
932 auto x2 = jsvm::GetProperty(jsvm::Global(), "x2");
933 ASSERT_TRUE(jsvm::Equals(x1, jsvm::Int32(0)));
934 ASSERT_TRUE(jsvm::Equals(x2, jsvm::Int32(0)));
935
936 OH_JSVM_ResolveDeferred(env, deffered, jsvm::Int32(2));
937 deffered = nullptr;
938
939 x1 = jsvm::GetProperty(jsvm::Global(), "x1");
940 x2 = jsvm::GetProperty(jsvm::Global(), "x2");
941 ASSERT_TRUE(jsvm::Equals(x1, jsvm::Int32(2)));
942 ASSERT_TRUE(jsvm::Equals(x2, jsvm::Int32(0)));
943 }
944
945 HWTEST_F(JSVMTest, PromiseThen2, TestSize.Level1)
946 {
947 jsvm::Run(g_defineFunction.c_str());
948
949 JSVM_Value f1 = jsvm::GetProperty(jsvm::Global(), "f1");
950 auto f2 = jsvm::GetProperty(jsvm::Global(), "f2");
951
952 JSVM_Value promise;
953 JSVM_Deferred deffered;
954
955 // Resolve
956 JSVMTEST_CALL(OH_JSVM_CreatePromise(env, &deffered, &promise));
957 JSVMTEST_CALL(OH_JSVM_PromiseRegisterHandler(env, promise, f1, f2, nullptr));
958
959 auto x1 = jsvm::GetProperty(jsvm::Global(), "x1");
960 auto x2 = jsvm::GetProperty(jsvm::Global(), "x2");
961 ASSERT_TRUE(jsvm::Equals(x1, jsvm::Int32(0)));
962 ASSERT_TRUE(jsvm::Equals(x2, jsvm::Int32(0)));
963
964 OH_JSVM_ResolveDeferred(env, deffered, jsvm::Int32(2));
965 deffered = nullptr;
966
967 x1 = jsvm::GetProperty(jsvm::Global(), "x1");
968 x2 = jsvm::GetProperty(jsvm::Global(), "x2");
969 ASSERT_TRUE(jsvm::Equals(x1, jsvm::Int32(2)));
970 ASSERT_TRUE(jsvm::Equals(x2, jsvm::Int32(0)));
971
972 jsvm::Run(g_init.c_str());
973 // Reject
974 JSVMTEST_CALL(OH_JSVM_CreatePromise(env, &deffered, &promise));
975 JSVMTEST_CALL(OH_JSVM_PromiseRegisterHandler(env, promise, f1, f2, nullptr));
976
977 x1 = jsvm::GetProperty(jsvm::Global(), "x1");
978 x2 = jsvm::GetProperty(jsvm::Global(), "x2");
979 ASSERT_TRUE(jsvm::Equals(x1, jsvm::Int32(0)));
980 ASSERT_TRUE(jsvm::Equals(x2, jsvm::Int32(0)));
981
982 OH_JSVM_RejectDeferred(env, deffered, jsvm::Int32(3));
983 deffered = nullptr;
984
985 x1 = jsvm::GetProperty(jsvm::Global(), "x1");
986 x2 = jsvm::GetProperty(jsvm::Global(), "x2");
987 ASSERT_TRUE(jsvm::Equals(x1, jsvm::Int32(0)));
988 ASSERT_TRUE(jsvm::Equals(x2, jsvm::Int32(3)));
989 }
990
991 HWTEST_F(JSVMTest, PromiseThenChain, TestSize.Level1)
992 {
993 jsvm::Run(g_defineFunction.c_str());
994
995 JSVM_Value f1 = jsvm::GetProperty(jsvm::Global(), "f1");
996 auto f2 = jsvm::GetProperty(jsvm::Global(), "f2");
997
998 JSVM_Value promise, promise1, x1, x2;
999 JSVM_Deferred deffered = nullptr;
1000
1001 // Resolve
1002 JSVMTEST_CALL(OH_JSVM_CreatePromise(env, &deffered, &promise));
1003 JSVMTEST_CALL(OH_JSVM_PromiseRegisterHandler(env, promise, f1, nullptr, &promise1));
1004 JSVMTEST_CALL(OH_JSVM_PromiseRegisterHandler(env, promise1, f2, nullptr, nullptr));
1005
1006 x1 = jsvm::GetProperty(jsvm::Global(), "x1");
1007 x2 = jsvm::GetProperty(jsvm::Global(), "x2");
1008 ASSERT_TRUE(jsvm::Equals(x1, jsvm::Int32(0)));
1009 ASSERT_TRUE(jsvm::Equals(x2, jsvm::Int32(0)));
1010
1011 OH_JSVM_ResolveDeferred(env, deffered, jsvm::Int32(2));
1012 deffered = nullptr;
1013
1014 x1 = jsvm::GetProperty(jsvm::Global(), "x1");
1015 x2 = jsvm::GetProperty(jsvm::Global(), "x2");
1016 ASSERT_TRUE(jsvm::Equals(x1, jsvm::Int32(2)));
1017 ASSERT_TRUE(jsvm::Equals(x2, jsvm::Int32(3)));
1018 }
1019
1020 HWTEST_F(JSVMTest, PromiseCatch, TestSize.Level1)
1021 {
1022 jsvm::Run(g_defineFunction.c_str());
1023
1024 JSVM_Value f1 = jsvm::GetProperty(jsvm::Global(), "f1");
1025
1026 JSVM_Value promise;
1027 JSVM_Value promise1;
1028 JSVM_Deferred deffered = nullptr;
1029
1030 // Resolve
1031 JSVMTEST_CALL(OH_JSVM_CreatePromise(env, &deffered, &promise));
1032 JSVMTEST_CALL(OH_JSVM_PromiseRegisterHandler(env, promise, nullptr, f1, &promise1));
1033
1034 auto x1 = jsvm::GetProperty(jsvm::Global(), "x1");
1035 auto x2 = jsvm::GetProperty(jsvm::Global(), "x2");
1036 ASSERT_TRUE(jsvm::Equals(x1, jsvm::Int32(0)));
1037 ASSERT_TRUE(jsvm::Equals(x2, jsvm::Int32(0)));
1038
1039 JSVMTEST_CALL(OH_JSVM_RejectDeferred(env, deffered, jsvm::Int32(2)));
1040 deffered = nullptr;
1041
1042 x1 = jsvm::GetProperty(jsvm::Global(), "x1");
1043 x2 = jsvm::GetProperty(jsvm::Global(), "x2");
1044 ASSERT_TRUE(jsvm::Equals(x1, jsvm::Int32(2)));
1045 ASSERT_TRUE(jsvm::Equals(x2, jsvm::Int32(0)));
1046 }
1047
1048 HWTEST_F(JSVMTest, JSVMHasInstance001, TestSize.Level1)
1049 {
1050 JSVM_Value result;
1051 JSVMTEST_CALL(OH_JSVM_GetSymbolHasInstance(env, &result));
1052 ASSERT_TRUE(jsvm::StrictEquals(result, jsvm::Run("Symbol.hasInstance")));
1053 }
1054
1055 HWTEST_F(JSVMTest, JSVMUnscopables001, TestSize.Level1)
1056 {
1057 JSVM_Value result;
1058 JSVMTEST_CALL(OH_JSVM_GetSymbolUnscopables(env, &result));
1059 ASSERT_TRUE(jsvm::StrictEquals(result, jsvm::Run("Symbol.unscopables")));
1060 }
1061
1062 HWTEST_F(JSVMTest, JSVMAsyncIterator001, TestSize.Level1)
1063 {
1064 JSVM_Value result;
1065 JSVMTEST_CALL(OH_JSVM_GetSymbolAsyncIterator(env, &result));
1066 ASSERT_TRUE(jsvm::StrictEquals(result, jsvm::Run("Symbol.asyncIterator")));
1067 }
1068
1069 HWTEST_F(JSVMTest, JSVMIterator001, TestSize.Level1)
1070 {
1071 JSVM_Value result;
1072 JSVMTEST_CALL(OH_JSVM_GetSymbolIterator(env, &result));
1073 ASSERT_TRUE(jsvm::StrictEquals(result, jsvm::Run("Symbol.iterator")));
1074 }
1075
1076 static jmp_buf g_buf;
1077 static bool g_beforeFlag1 = false;
1078 static bool g_beforeFlag2 = false;
1079 static bool g_beforeFlag3 = false;
1080 static bool g_afterFlag1 = false;
1081 static bool g_afterFlag2 = false;
1082 static int g_nativeValue = 2024;
1083
OnBeforeGC(JSVM_VM vm,JSVM_GCType gcType,JSVM_GCCallbackFlags flags,void * data)1084 void OnBeforeGC(JSVM_VM vm, JSVM_GCType gcType, JSVM_GCCallbackFlags flags, void *data)
1085 {
1086 g_beforeFlag1 = true;
1087 }
1088
OnBeforeGC2(JSVM_VM vm,JSVM_GCType gcType,JSVM_GCCallbackFlags flags,void * data)1089 void OnBeforeGC2(JSVM_VM vm, JSVM_GCType gcType, JSVM_GCCallbackFlags flags, void *data)
1090 {
1091 if (*(int*)data == g_nativeValue) {
1092 g_beforeFlag2 = true;
1093 }
1094 }
1095
OnBeforeGC3(JSVM_VM vm,JSVM_GCType gcType,JSVM_GCCallbackFlags flags,void * data)1096 void OnBeforeGC3(JSVM_VM vm, JSVM_GCType gcType, JSVM_GCCallbackFlags flags, void *data)
1097 {
1098 g_beforeFlag3 = true;
1099 }
1100
OnAfterGC(JSVM_VM vm,JSVM_GCType gcType,JSVM_GCCallbackFlags flags,void * data)1101 void OnAfterGC(JSVM_VM vm, JSVM_GCType gcType, JSVM_GCCallbackFlags flags, void *data)
1102 {
1103 g_afterFlag1 = true;
1104 }
1105
OnAfterGC2(JSVM_VM vm,JSVM_GCType gcType,JSVM_GCCallbackFlags flags,void * data)1106 void OnAfterGC2(JSVM_VM vm, JSVM_GCType gcType, JSVM_GCCallbackFlags flags, void *data)
1107 {
1108 g_afterFlag2 = true;
1109 }
1110
1111 HWTEST_F(JSVMTest, JSVMForwardUsageApplicationScenariosOfGCCB, TestSize.Level1)
1112 {
1113 g_beforeFlag1 = false;
1114 g_beforeFlag2 = false;
1115 g_beforeFlag3 = false;
1116 g_afterFlag1 = false;
1117 g_afterFlag2 = false;
1118 int data = g_nativeValue;
1119 JSVMTEST_CALL(OH_JSVM_AddHandlerForGC(vm, JSVM_CB_TRIGGER_BEFORE_GC, OnBeforeGC, JSVM_GC_TYPE_ALL, NULL));
1120 JSVMTEST_CALL(OH_JSVM_AddHandlerForGC(vm, JSVM_CB_TRIGGER_BEFORE_GC,
1121 OnBeforeGC2, JSVM_GC_TYPE_ALL, (void*)(&data)));
1122 JSVMTEST_CALL(OH_JSVM_AddHandlerForGC(vm, JSVM_CB_TRIGGER_BEFORE_GC, OnBeforeGC3, JSVM_GC_TYPE_SCAVENGE, NULL));
1123 JSVMTEST_CALL(OH_JSVM_AddHandlerForGC(vm, JSVM_CB_TRIGGER_AFTER_GC, OnAfterGC, JSVM_GC_TYPE_ALL, NULL));
1124 JSVMTEST_CALL(OH_JSVM_AddHandlerForGC(vm, JSVM_CB_TRIGGER_AFTER_GC, OnAfterGC2, JSVM_GC_TYPE_ALL, NULL));
1125
1126 JSVMTEST_CALL(OH_JSVM_RemoveHandlerForGC(vm, JSVM_CB_TRIGGER_AFTER_GC, OnAfterGC2, NULL));
1127
1128 // can not remove handler that has not been added.
1129 ASSERT_TRUE(OH_JSVM_RemoveHandlerForGC(vm, JSVM_CB_TRIGGER_AFTER_GC, OnAfterGC2, new int(12)) == JSVM_INVALID_ARG);
1130
1131 jsvm::TryTriggerGC();
1132 ASSERT_TRUE(g_beforeFlag1);
1133 ASSERT_TRUE(g_beforeFlag2);
1134 ASSERT_FALSE(g_beforeFlag3);
1135 ASSERT_TRUE(g_afterFlag1);
1136 ASSERT_FALSE(g_afterFlag2);
1137 }
1138
1139 HWTEST_F(JSVMTest, JSVMNegativeApplicationScenariosOfGCCB, TestSize.Level1) {
1140 JSVMTEST_CALL(OH_JSVM_AddHandlerForGC(vm, JSVM_CB_TRIGGER_BEFORE_GC, OnBeforeGC, JSVM_GC_TYPE_ALL, NULL));
1141 // 1. Repeatedly register the same handler and native-data.
1142 ASSERT_TRUE(OH_JSVM_AddHandlerForGC(vm, JSVM_CB_TRIGGER_BEFORE_GC, OnBeforeGC, JSVM_GC_TYPE_ALL, NULL)
1143 == JSVM_INVALID_ARG);
1144 // 2. Register an empty handler.
1145 ASSERT_TRUE(OH_JSVM_AddHandlerForGC(vm, JSVM_CB_TRIGGER_BEFORE_GC, NULL, JSVM_GC_TYPE_ALL, NULL)
1146 == JSVM_INVALID_ARG);
1147 // 3. Remove unregistered handlers.
1148 ASSERT_TRUE(OH_JSVM_RemoveHandlerForGC(vm, JSVM_CB_TRIGGER_BEFORE_GC, OnBeforeGC2, NULL) == JSVM_INVALID_ARG);
1149 // 4. Remove the same handler and native-data repeatedly.
1150 ASSERT_TRUE(OH_JSVM_RemoveHandlerForGC(vm, JSVM_CB_TRIGGER_BEFORE_GC, OnBeforeGC, NULL) == JSVM_OK);
1151 ASSERT_TRUE(OH_JSVM_RemoveHandlerForGC(vm, JSVM_CB_TRIGGER_BEFORE_GC, OnBeforeGC, NULL) == JSVM_INVALID_ARG);
1152 }
1153
1154 static bool g_oomHandlerFinished = false;
1155 static bool g_fatalHandlerFinished = false;
1156 static bool g_fatalHandlerFinished2 = false;
1157 static bool g_promiseRejectFinished = false;
1158
OnOOMError(const char * location,const char * detail,bool isHeapOOM)1159 void OnOOMError(const char *location, const char *detail, bool isHeapOOM)
1160 {
1161 g_oomHandlerFinished = true;
1162 longjmp(g_buf, 1);
1163 }
1164
OnFatalError(const char * location,const char * message)1165 void OnFatalError(const char *location, const char *message)
1166 {
1167 g_fatalHandlerFinished = true;
1168 longjmp(g_buf, 1);
1169 }
1170
OnFatalError2(const char * location,const char * message)1171 void OnFatalError2(const char *location, const char *message)
1172 {
1173 g_fatalHandlerFinished2 = true;
1174 longjmp(g_buf, 1);
1175 }
1176
1177
OnPromiseReject(JSVM_Env env,JSVM_PromiseRejectEvent rejectEvent,JSVM_Value rejectInfo)1178 void OnPromiseReject(JSVM_Env env, JSVM_PromiseRejectEvent rejectEvent, JSVM_Value rejectInfo)
1179 {
1180 ASSERT_TRUE(jsvm::IsObject(rejectInfo));
1181 auto promise = jsvm::GetProperty(rejectInfo, "promise");
1182 ASSERT_TRUE(jsvm::IsPromise(promise));
1183 auto value = jsvm::GetProperty(rejectInfo, "value");
1184 ASSERT_TRUE(jsvm::IsNumber(value));
1185 g_promiseRejectFinished = true;
1186 }
1187
1188 HWTEST_F(JSVMTest, JSVMOOM, TestSize.Level1)
1189 {
1190 g_oomHandlerFinished = false;
1191 JSVMTEST_CALL(OH_JSVM_SetHandlerForOOMError(vm, OnOOMError));
1192 static bool oomed = false;
1193 setjmp(g_buf);
1194 if (!oomed) {
1195 oomed = true;
1196 jsvm::TryTriggerOOM();
1197 }
1198 ASSERT_TRUE(jsvm::ToNumber(jsvm::Run("42")) == 42);
1199 ASSERT_TRUE(g_oomHandlerFinished);
1200 }
1201
1202 HWTEST_F(JSVMTest, JSVMFatalError, TestSize.Level1)
1203 {
1204 g_fatalHandlerFinished = false;
1205 JSVMTEST_CALL(OH_JSVM_SetHandlerForFatalError(vm, OnFatalError));
1206 static bool fataled = false;
1207 setjmp(g_buf);
1208 if (!fataled) {
1209 fataled = true;
1210 jsvm::TryTriggerFatalError(vm);
1211 }
1212 ASSERT_TRUE(jsvm::ToNumber(jsvm::Run("42")) == 42);
1213 ASSERT_TRUE(g_fatalHandlerFinished);
1214 }
1215
1216 HWTEST_F(JSVMTest, JSVMPromiseReject, TestSize.Level1)
1217 {
1218 JSVMTEST_CALL(OH_JSVM_SetHandlerForPromiseReject(vm, OnPromiseReject));
1219 jsvm::Run("new Promise((resolve, reject) => { reject(42); })");
1220 }
1221
1222 HWTEST_F(JSVMTest, JSVMCheckHandler, TestSize.Level1)
1223 {
1224 ASSERT_TRUE(g_oomHandlerFinished);
1225 ASSERT_TRUE(g_fatalHandlerFinished);
1226 ASSERT_TRUE(g_promiseRejectFinished);
1227 }
1228
1229 static bool g_callAsFunctionFlag = false;
1230 static bool g_setNamedPropertyFlag = false;
1231 static bool g_callAsConstructorFlag = false;
1232 static bool g_propertiesFlag = false;
1233
SetNamedPropertyCbInfo2(JSVM_Env env,JSVM_Value name,JSVM_Value property,JSVM_Value thisArg,JSVM_Value data)1234 static JSVM_Value SetNamedPropertyCbInfo2(JSVM_Env env, JSVM_Value name, JSVM_Value property, JSVM_Value thisArg,
1235 JSVM_Value data)
1236 {
1237 g_setNamedPropertyFlag = true;
1238 return property;
1239 }
1240
Add(JSVM_Env env,JSVM_CallbackInfo info)1241 static JSVM_Value Add(JSVM_Env env, JSVM_CallbackInfo info)
1242 {
1243 g_propertiesFlag = true;
1244 size_t argc = 2;
1245 JSVM_Value args[2];
1246 OH_JSVM_GetCbInfo(env, info, &argc, args, NULL, NULL);
1247 double num1, num2;
1248 OH_JSVM_GetValueDouble(env, args[0], &num1);
1249 OH_JSVM_GetValueDouble(env, args[1], &num2);
1250 JSVM_Value sum = nullptr;
1251 OH_JSVM_CreateDouble(env, num1 + num2, &sum);
1252 return sum;
1253 }
1254
GenerateParentClass(JSVM_Env env)1255 JSVM_Value GenerateParentClass(JSVM_Env env)
1256 {
1257 JSVM_Value parentClass = nullptr;
1258 JSVM_CallbackStruct *parentClassConstructor = new JSVM_CallbackStruct;
1259 parentClassConstructor->data = nullptr;
1260 parentClassConstructor->callback = [](JSVM_Env env, JSVM_CallbackInfo info) -> JSVM_Value {
1261 JSVM_Value thisVar = nullptr;
1262 OH_JSVM_GetCbInfo(env, info, nullptr, nullptr, &thisVar, nullptr);
1263 return thisVar;
1264 };
1265 JSVM_Value fooVal = jsvm::Str("bar");
1266 JSVM_PropertyDescriptor des[2];
1267 des[0] = {
1268 .utf8name = "foo",
1269 .value = fooVal,
1270 };
1271 JSVM_CallbackStruct *addMethod = new JSVM_CallbackStruct;
1272 addMethod->data = nullptr;
1273 addMethod->callback = Add;
1274 des[1] = {
1275 .utf8name = "add",
1276 .method = addMethod,
1277 };
1278 JSVM_DefineClassOptions options[1];
1279 options[0].id = JSVM_DEFINE_CLASS_WITH_COUNT;
1280 options[0].content.num = JSVM_OBJECT_INTERFAIELD_COUNT;
1281 JSVMTEST_CALL(OH_JSVM_DefineClassWithOptions(env, "parentClass", JSVM_AUTO_LENGTH,
1282 parentClassConstructor, JSVM_PARENT_CLASS_DES_COUNT, des,
1283 nullptr, 1, options, &parentClass));
1284 return parentClass;
1285 }
1286
GenerateSubClass(JSVM_Env env,JSVM_Value parentClass)1287 JSVM_Value GenerateSubClass(JSVM_Env env, JSVM_Value parentClass)
1288 {
1289 JSVM_Value subClass = nullptr;
1290 JSVM_CallbackStruct *subClassConstructor = new JSVM_CallbackStruct;
1291 subClassConstructor->data = nullptr;
1292 subClassConstructor->callback = [](JSVM_Env env, JSVM_CallbackInfo info) -> JSVM_Value {
1293 JSVM_Value thisVar = nullptr;
1294 g_callAsConstructorFlag = true;
1295 OH_JSVM_GetCbInfo(env, info, nullptr, nullptr, &thisVar, nullptr);
1296 return thisVar;
1297 };
1298 JSVM_DefineClassOptions subOptions[2];
1299 JSVM_CallbackStruct *callAsFuncParam = new JSVM_CallbackStruct;
1300 callAsFuncParam->data = nullptr;
1301 callAsFuncParam->callback = [](JSVM_Env env, JSVM_CallbackInfo info) -> JSVM_Value {
1302 JSVM_Value thisVar = nullptr;
1303 g_callAsFunctionFlag = true;
1304 OH_JSVM_GetCbInfo(env, info, nullptr, nullptr, &thisVar, nullptr);
1305 return thisVar;
1306 };
1307 propertyCfg.genericNamedPropertySetterCallback = SetNamedPropertyCbInfo2;
1308 JSVM_PropertyHandler propertyHandler = {
1309 .propertyHandlerCfg = &propertyCfg,
1310 .callAsFunctionCallback = callAsFuncParam,
1311 };
1312 subOptions[0].id = JSVM_DEFINE_CLASS_WITH_COUNT;
1313 subOptions[0].content.num = JSVM_OBJECT_INTERFAIELD_COUNT;
1314 subOptions[1].id = JSVM_DEFINE_CLASS_WITH_PROPERTY_HANDLER;
1315 subOptions[1].content.ptr = &propertyHandler;
1316 JSVMTEST_CALL(OH_JSVM_DefineClassWithOptions(env, "subClass", JSVM_AUTO_LENGTH, subClassConstructor, 0, nullptr,
1317 parentClass, JSVM_DEFINE_CLASS_OPTIONS_COUNT, subOptions, &subClass));
1318 return subClass;
1319 }
1320
1321 /**
1322 * @brief Verify the validity of the following parameters in the OH_JSVM_DefineClassWithOptions interface:
1323 * 'consturctor' | 'properties' | 'parentClass' | 'options'
1324 */
1325 HWTEST_F(JSVMTest, JSVMTestParentClassWithCount, TestSize.Level1)
1326 {
1327 g_callAsFunctionFlag = false;
1328 g_setNamedPropertyFlag = false;
1329 g_callAsConstructorFlag = false;
1330 g_propertiesFlag = false;
1331 // 1. Define parent-class.
1332 JSVM_Value parentClass = GenerateParentClass(env);
1333 // 2. Define sub-class.
1334 JSVM_Value subClass = GenerateSubClass(env, parentClass);
1335 // 3. Verify the validity of 'constructor'.
1336 JSVM_Value subInstance;
1337 ASSERT_FALSE(g_callAsConstructorFlag);
1338 JSVMTEST_CALL(OH_JSVM_NewInstance(env, subClass, 0, nullptr, &subInstance));
1339 ASSERT_TRUE(g_callAsConstructorFlag);
1340
1341 JSVM_Value globalVal;
1342 OH_JSVM_GetGlobal(env, &globalVal);
1343 OH_JSVM_SetNamedProperty(env, globalVal, "obj", subInstance);
1344
1345 // 4. Verify the validity of 'parentClass'.
1346 JSVM_Value subRes = nullptr;
1347 JSVMTEST_CALL(OH_JSVM_GetNamedProperty(env, subInstance, "foo", &subRes));
1348 ASSERT_TRUE(jsvm::ToString(subRes).compare("bar") == 0);
1349 // 5. Verify the validity of 'properties'.
1350 ASSERT_FALSE(g_propertiesFlag);
1351 jsvm::Run("obj.add(3, 4);");
1352 ASSERT_TRUE(g_propertiesFlag);
1353 // 6. Verify the validity of 'options'.
1354 ASSERT_FALSE(g_callAsFunctionFlag);
1355 jsvm::Run("obj()");
1356 ASSERT_TRUE(g_callAsFunctionFlag);
1357 ASSERT_FALSE(g_setNamedPropertyFlag);
1358 jsvm::Run("obj.x = 123;");
1359 ASSERT_TRUE(g_setNamedPropertyFlag);
1360 propertyCfg.genericNamedPropertySetterCallback = nullptr;
1361 }
1362
1363 /**
1364 * @brief If parentClass is not an APIFunction, the status code is JSVM_INVALID_ARG.
1365 */
1366 HWTEST_F(JSVMTest, NonAPIFunction, TestSize.Level1) {
1367 JSVM_Value script = jsvm::Str("return 2 + 3;");
1368 JSVM_Value nonAPIFunction = nullptr;
1369 JSVMTEST_CALL(OH_JSVM_CreateFunctionWithScript(env, nullptr, 0, 0,
1370 nullptr, script, &nonAPIFunction));
1371
1372 JSVM_Value subClass = nullptr;
1373 JSVM_CallbackStruct constructor;
1374 constructor.data = nullptr;
__anon13abbe8e0a02(JSVM_Env env, JSVM_CallbackInfo info) 1375 constructor.callback = [](JSVM_Env env, JSVM_CallbackInfo info) -> JSVM_Value {
1376 JSVM_Value thisVar = nullptr;
1377 OH_JSVM_GetCbInfo(env, info, nullptr, nullptr, &thisVar, nullptr);
1378 return thisVar;
1379 };
1380 JSVM_Status status = OH_JSVM_DefineClassWithOptions(env, "subClass", JSVM_AUTO_LENGTH, &constructor, 0, nullptr,
1381 nonAPIFunction, 0, nullptr, &subClass);
1382 ASSERT_TRUE(status == JSVM_INVALID_ARG);
1383 }
1384
LogFunc(JSVM_Env env,JSVM_CallbackInfo info)1385 static JSVM_Value LogFunc(JSVM_Env env, JSVM_CallbackInfo info)
1386 {
1387 size_t argc = 1;
1388 JSVM_Value argv[1];
1389 JSVMTEST_CALL(OH_JSVM_GetCbInfo(env, info, &argc, argv, NULL, NULL));
1390 return jsvm::Str("log");
1391 }
1392
1393 HWTEST_F(JSVMTest, test_function_private, TestSize.Level1)
1394 {
1395 JSVM_Data key;
1396 JSVMTEST_CALL(OH_JSVM_CreatePrivate(env, nullptr, &key));
1397 auto obj = jsvm::Object();
1398 JSVMTEST_CALL(OH_JSVM_SetPrivate(env, obj, key, jsvm::Str("a")));
1399 static JSVM_CallbackStruct cb = {LogFunc, NULL};
1400 JSVM_Value log;
1401 JSVMTEST_CALL(OH_JSVM_CreateFunction(env, "log", JSVM_AUTO_LENGTH, &cb, &log));
1402 JSVMTEST_CALL(OH_JSVM_SetPrivate(env, obj, key, log));
1403 JSVM_Value result;
1404 JSVMTEST_CALL(OH_JSVM_GetPrivate(env, obj, key, &result));
1405 auto ret = jsvm::Call(result);
1406 ASSERT_TRUE(jsvm::Equals(ret, jsvm::Str("log")));
1407 }
1408
1409 HWTEST_F(JSVMTest, test_str_private, TestSize.Level1)
1410 {
1411 JSVM_Data key;
1412 JSVMTEST_CALL(OH_JSVM_CreatePrivate(env, nullptr, &key));
1413 auto obj = jsvm::Object();
1414 JSVMTEST_CALL(OH_JSVM_SetPrivate(env, obj, key, jsvm::Str("a")));
1415 JSVMTEST_CALL(OH_JSVM_SetPrivate(env, obj, key, jsvm::Str("log")));
1416 JSVM_Value result;
1417 JSVMTEST_CALL(OH_JSVM_GetPrivate(env, obj, key, &result));
1418 ASSERT_TRUE(jsvm::Equals(result, jsvm::Str("log")));
1419 }
1420
1421 HWTEST_F(JSVMTest, test_different_private_with_same_key, TestSize.Level1)
1422 {
1423 JSVM_Data key;
1424 JSVMTEST_CALL(OH_JSVM_CreatePrivate(env, jsvm::Str("a"), &key));
1425 JSVM_Data key1;
1426 JSVMTEST_CALL(OH_JSVM_CreatePrivate(env, jsvm::Str("a"), &key1));
1427 auto obj = jsvm::Object();
1428 JSVMTEST_CALL(OH_JSVM_SetPrivate(env, obj, key, jsvm::Str("a")));
1429 JSVMTEST_CALL(OH_JSVM_SetPrivate(env, obj, key1, jsvm::Str("b")));
1430 JSVM_Value result;
1431 JSVMTEST_CALL(OH_JSVM_GetPrivate(env, obj, key, &result));
1432 JSVM_Value result1;
1433 JSVMTEST_CALL(OH_JSVM_GetPrivate(env, obj, key1, &result1));
1434 ASSERT_TRUE(!jsvm::Equals(result, result1));
1435 }
1436
1437 HWTEST_F(JSVMTest, test_set_private_with_nullptr_key, TestSize.Level1)
1438 {
1439 JSVM_Data key = nullptr;
1440 auto obj = jsvm::Object();
1441 auto status = OH_JSVM_SetPrivate(env, obj, key, jsvm::Str("a"));
1442 ASSERT_TRUE(status == JSVM_INVALID_ARG);
1443 }
1444
1445 HWTEST_F(JSVMTest, test_set_private_with_nullptr_value, TestSize.Level1)
1446 {
1447 JSVM_Data key = nullptr;
1448 auto obj = jsvm::Object();
1449 JSVMTEST_CALL(OH_JSVM_CreatePrivate(env, jsvm::Str("a"), &key));
1450 auto status = OH_JSVM_SetPrivate(env, obj, key, nullptr);
1451 ASSERT_TRUE(status == JSVM_INVALID_ARG);
1452 }
1453
1454 HWTEST_F(JSVMTest, test_set_private_with_non_object, TestSize.Level1)
1455 {
1456 JSVM_Data key = nullptr;
1457 auto obj = jsvm::True();
1458 JSVMTEST_CALL(OH_JSVM_CreatePrivate(env, jsvm::Str("a"), &key));
1459 auto status = OH_JSVM_SetPrivate(env, obj, key, jsvm::Str("a"));
1460 ASSERT_TRUE(status == JSVM_OBJECT_EXPECTED);
1461 }
1462
1463 HWTEST_F(JSVMTest, test_set_private_with_non_private, TestSize.Level1)
1464 {
1465 JSVM_Data key = nullptr;
1466 auto obj = jsvm::Object();
1467 JSVMTEST_CALL(OH_JSVM_CreateSymbol(env, jsvm::Str("a"), (JSVM_Value *)&key));
1468 auto status = OH_JSVM_SetPrivate(env, obj, key, jsvm::Str("a"));
1469 ASSERT_TRUE(status == JSVM_INVALID_ARG);
1470 }
1471
1472 HWTEST_F(JSVMTest, test_get_non_exist_private, TestSize.Level1)
1473 {
1474 JSVM_Data key;
1475 JSVMTEST_CALL(OH_JSVM_CreatePrivate(env, nullptr, &key));
1476 auto obj = jsvm::Object();
1477 JSVM_Value result;
1478 JSVMTEST_CALL(OH_JSVM_GetPrivate(env, obj, key, &result));
1479 ASSERT_TRUE(jsvm::Equals(result, jsvm::Undefined()));
1480 }
1481
1482 HWTEST_F(JSVMTest, test_get_private_with_nullptr_key, TestSize.Level1)
1483 {
1484 JSVM_Data key = nullptr;
1485 auto obj = jsvm::Object();
1486 JSVM_Value value;
1487 auto status = OH_JSVM_GetPrivate(env, obj, key, &value);
1488 ASSERT_TRUE(status == JSVM_INVALID_ARG);
1489 }
1490
1491 HWTEST_F(JSVMTest, test_get_private_with_nullptr_value, TestSize.Level1)
1492 {
1493 JSVM_Data key = nullptr;
1494 auto obj = jsvm::Object();
1495 JSVMTEST_CALL(OH_JSVM_CreatePrivate(env, jsvm::Str("a"), &key));
1496 auto status = OH_JSVM_GetPrivate(env, obj, key, nullptr);
1497 ASSERT_TRUE(status == JSVM_INVALID_ARG);
1498 }
1499
1500 HWTEST_F(JSVMTest, test_get_private_with_non_object, TestSize.Level1)
1501 {
1502 JSVM_Data key = nullptr;
1503 auto obj = jsvm::True();
1504 JSVMTEST_CALL(OH_JSVM_CreatePrivate(env, jsvm::Str("a"), &key));
1505 JSVM_Value value;
1506 auto status = OH_JSVM_GetPrivate(env, obj, key, &value);
1507 ASSERT_TRUE(status == JSVM_OBJECT_EXPECTED);
1508 }
1509
1510 HWTEST_F(JSVMTest, test_get_private_with_non_private, TestSize.Level1)
1511 {
1512 JSVM_Data key = nullptr;
1513 auto obj = jsvm::Object();
1514 JSVMTEST_CALL(OH_JSVM_CreateSymbol(env, jsvm::Str("a"), (JSVM_Value *)&key));
1515 JSVM_Value value;
1516 auto status = OH_JSVM_GetPrivate(env, obj, key, &value);
1517 ASSERT_TRUE(status == JSVM_INVALID_ARG);
1518 }
1519
1520 HWTEST_F(JSVMTest, test_delete_non_exist_private, TestSize.Level1)
1521 {
1522 JSVM_Data key;
1523 JSVMTEST_CALL(OH_JSVM_CreatePrivate(env, nullptr, &key));
1524 auto obj = jsvm::Object();
1525 JSVMTEST_CALL(OH_JSVM_DeletePrivate(env, obj, key));
1526 }
1527
1528 HWTEST_F(JSVMTest, test_delete_nullptr_key, TestSize.Level1)
1529 {
1530 JSVM_Data key = nullptr;
1531 auto obj = jsvm::Object();
1532 auto status = OH_JSVM_DeletePrivate(env, obj, key);
1533 ASSERT_TRUE(status == JSVM_INVALID_ARG);
1534 }
1535
1536 HWTEST_F(JSVMTest, test_delete_with_non_object, TestSize.Level1)
1537 {
1538 JSVM_Data key = nullptr;
1539 auto obj = jsvm::True();
1540 JSVMTEST_CALL(OH_JSVM_CreatePrivate(env, jsvm::Str("a"), &key));
1541 auto status = OH_JSVM_DeletePrivate(env, obj, key);
1542 ASSERT_TRUE(status == JSVM_OBJECT_EXPECTED);
1543 }
1544
1545 HWTEST_F(JSVMTest, test_delete_private_with_non_private, TestSize.Level1)
1546 {
1547 JSVM_Data key = nullptr;
1548 auto obj = jsvm::Object();
1549 JSVMTEST_CALL(OH_JSVM_CreateSymbol(env, jsvm::Str("a"), (JSVM_Value *)&key));
1550 auto status = OH_JSVM_DeletePrivate(env, obj, key);
1551 ASSERT_TRUE(status == JSVM_INVALID_ARG);
1552 }
1553