1 /*
2 * Copyright (c) 2023 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 #include "napi/native_node_api.h"
19 #include "utils/log.h"
20 #include "worker.h"
21
22 #define ASSERT_CHECK_CALL(call) \
23 { \
24 ASSERT_EQ(call, napi_ok); \
25 }
26
27 #define ASSERT_CHECK_VALUE_TYPE(env, value, type) \
28 { \
29 napi_valuetype valueType = napi_undefined; \
30 ASSERT_TRUE(value != nullptr); \
31 ASSERT_CHECK_CALL(napi_typeof(env, value, &valueType)); \
32 ASSERT_EQ(valueType, type); \
33 }
34
35 using namespace Commonlibrary::Concurrent::WorkerModule;
36
37 // worker constructor
Worker_Constructor(napi_env env,napi_value global)38 napi_value Worker_Constructor(napi_env env, napi_value global)
39 {
40 std::string funcName = "WorkerConstructor";
41 napi_value cb = nullptr;
42 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::WorkerConstructor, nullptr, &cb);
43
44 napi_value result = nullptr;
45 napi_value argv[2] = { nullptr };
46
47 std::string script = "entry/ets/workers/worker.ts";
48 napi_create_string_utf8(env, script.c_str(), script.length(), &argv[0]);
49 std::string type = "classic";
50 std::string name = "WorkerThread";
51 napi_value typeValue = nullptr;
52 napi_value nameValue = nullptr;
53 napi_create_string_utf8(env, name.c_str(), name.length(), &nameValue);
54 napi_create_string_utf8(env, type.c_str(), type.length(), &typeValue);
55
56 napi_value object = nullptr;
57 napi_create_object(env, &object);
58
59 napi_set_named_property(env, object, "name", nameValue);
60 napi_set_named_property(env, object, "type", typeValue);
61 argv[1] = object;
62
63 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
64 napi_env newEnv = nullptr;
65 napi_create_runtime(env, &newEnv);
66 return result;
67 }
68
69 // worker terminate
Worker_Terminate(napi_env env,napi_value global)70 napi_value Worker_Terminate(napi_env env, napi_value global)
71 {
72 std::string funcName = "Terminate";
73 napi_value cb = nullptr;
74 napi_value result = nullptr;
75 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::Terminate, nullptr, &cb);
76 napi_call_function(env, global, cb, 0, nullptr, &result);
77 return result;
78 }
79
80 // worker WorkerConstructor
81 HWTEST_F(NativeEngineTest, WorkerConstructorTest001, testing::ext::TestSize.Level0)
82 {
83 napi_env env = (napi_env)engine_;
84 napi_value global;
85 napi_get_global(env, &global);
86
87 napi_value result = nullptr;
88 result = Worker_Constructor(env, global);
89
90 Worker* worker = nullptr;
91 napi_unwrap(env, result, reinterpret_cast<void**>(&worker));
92 std::string nameResult = worker->GetName();
93 ASSERT_EQ(nameResult, "WorkerThread");
94 std::string scriptResult = worker->GetScript();
95 ASSERT_EQ(scriptResult, "entry/ets/workers/worker.ts");
96
97 result = Worker_Terminate(env, global);
98
99 ASSERT_TRUE(result != nullptr);
100 }
101
102 //worker PostMessage
103 HWTEST_F(NativeEngineTest, PostMessageTest001, testing::ext::TestSize.Level0)
104 {
105 napi_env env = (napi_env)engine_;
106 napi_value global;
107 napi_get_global(env, &global);
108
109 napi_value result = nullptr;
110 result = Worker_Constructor(env, global);
111
112 Worker* worker = nullptr;
113 napi_unwrap(env, result, reinterpret_cast<void**>(&worker));
114 bool status = worker->UpdateWorkerState(Worker::RunnerState::RUNNING);
115
116 napi_value argv[1] = { nullptr };
117 std::string message = "host";
118 napi_create_string_utf8(env, message.c_str(), message.length(), &argv[0]);
119 std::string funcName = "PostMessage";
120 napi_value cb = nullptr;
121 if (status) {
122 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::PostMessage, worker, &cb);
123 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
124 }
125 result = Worker_Terminate(env, global);
126 ASSERT_TRUE(result != nullptr);
127 }
128
129 //worker PostMessage
130 HWTEST_F(NativeEngineTest, PostMessageTest002, testing::ext::TestSize.Level0)
131 {
132 napi_env env = (napi_env)engine_;
133 napi_value global;
134 napi_get_global(env, &global);
135
136 napi_value result = nullptr;
137 result = Worker_Constructor(env, global);
138
139 napi_value argv[1] = { nullptr };
140 std::string message = "host";
141 napi_create_string_utf8(env, message.c_str(), message.length(), &argv[0]);
142
143 std::string funcName = "PostMessage";
144 napi_value cb = nullptr;
145
146 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::PostMessage, nullptr, &cb);
147 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
148
149 result = Worker_Terminate(env, global);
150 ASSERT_TRUE(result != nullptr);
151 }
152
153 //worker PostMessage
154 HWTEST_F(NativeEngineTest, PostMessageTest003, testing::ext::TestSize.Level0)
155 {
156 napi_env env = (napi_env)engine_;
157 napi_value global;
158 napi_get_global(env, &global);
159
160 napi_value result = nullptr;
161 result = Worker_Constructor(env, global);
162
163 Worker* worker = nullptr;
164 napi_unwrap(env, result, reinterpret_cast<void**>(&worker));
165 worker->UpdateWorkerState(Worker::RunnerState::TERMINATED);
166
167 napi_value argv[1] = { nullptr };
168 std::string message = "host";
169 napi_create_string_utf8(env, message.c_str(), message.length(), &argv[0]);
170 std::string funcName = "PostMessage";
171 napi_value cb = nullptr;
172 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::PostMessage, worker, &cb);
173 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
174
175 uv_async_t* req = new uv_async_t;
176 req->data = worker;
177 Worker::WorkerOnMessage(req);
178
179 result = Worker_Terminate(env, global);
180 ASSERT_TRUE(result != nullptr);
181 }
182
183 //worker PostMessage
184 HWTEST_F(NativeEngineTest, PostMessageToHostTest001, testing::ext::TestSize.Level0)
185 {
186 napi_env env = (napi_env)engine_;
187 napi_value global;
188 napi_get_global(env, &global);
189
190 napi_value result = nullptr;
191 result = Worker_Constructor(env, global);
192
193 Worker* worker = nullptr;
194 napi_unwrap(env, result, reinterpret_cast<void**>(&worker));
195 bool status = worker->UpdateWorkerState(Worker::RunnerState::RUNNING);
196 napi_value argv[1] = { nullptr };
197 std::string message = "host";
198 napi_create_string_utf8(env, message.c_str(), message.length(), &argv[0]);
199
200 std::string funcName = "PostMessageToHost";
201 napi_value cb = nullptr;
202 if (status) {
203 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::PostMessageToHost, worker, &cb);
204 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
205 }
206 uv_async_t* req = new uv_async_t;
207 req->data = worker;
208 Worker::HostOnMessage(req);
209
210 result = Worker_Terminate(env, global);
211 ASSERT_TRUE(result != nullptr);
212 }
213
214 //worker PostMessageToHost
215 HWTEST_F(NativeEngineTest, PostMessageToHostTest002, testing::ext::TestSize.Level0)
216 {
217 napi_env env = (napi_env)engine_;
218 napi_value global;
219 napi_get_global(env, &global);
220
221 napi_value result = nullptr;
222 result = Worker_Constructor(env, global);
223
224 napi_value argv[1] = { nullptr };
225 std::string message = "host";
226 napi_create_string_utf8(env, message.c_str(), message.length(), &argv[0]);
227
228 std::string funcName = "PostMessageToHost";
229 napi_value cb = nullptr;
230 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::PostMessageToHost, nullptr, &cb);
231 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
232
233 result = Worker_Terminate(env, global);
234 ASSERT_TRUE(result != nullptr);
235 }
236
237 //worker PostMessageToHost
238 HWTEST_F(NativeEngineTest, PostMessageToHostTest003, testing::ext::TestSize.Level0)
239 {
240 napi_env env = (napi_env)engine_;
241 napi_value global;
242 napi_get_global(env, &global);
243
244 napi_value arrayresult = nullptr;
245 ASSERT_CHECK_CALL(napi_create_object(env, &arrayresult));
246 ASSERT_CHECK_VALUE_TYPE(env, arrayresult, napi_object);
247 const char testStr[] = "1234567";
248 napi_value strAttribute = nullptr;
249 ASSERT_CHECK_CALL(napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
250 ASSERT_CHECK_VALUE_TYPE(env, strAttribute, napi_string);
251 ASSERT_CHECK_CALL(napi_set_named_property(env, arrayresult, "strAttribute", strAttribute));
252
253 napi_value retStrAttribute = nullptr;
254 ASSERT_CHECK_CALL(napi_get_named_property(env, arrayresult, "strAttribute", &retStrAttribute));
255 ASSERT_CHECK_VALUE_TYPE(env, retStrAttribute, napi_string);
256
257 int32_t testNumber = 12345; // 12345 : indicates any number
258 napi_value numberAttribute = nullptr;
259 ASSERT_CHECK_CALL(napi_create_int32(env, testNumber, &numberAttribute));
260 ASSERT_CHECK_VALUE_TYPE(env, numberAttribute, napi_number);
261 ASSERT_CHECK_CALL(napi_set_named_property(env, arrayresult, "numberAttribute", numberAttribute));
262
263 napi_value propNames = nullptr;
264 ASSERT_CHECK_CALL(napi_get_property_names(env, arrayresult, &propNames));
265 ASSERT_CHECK_VALUE_TYPE(env, propNames, napi_object);
266
267 napi_value result = nullptr;
268 result = Worker_Constructor(env, global);
269
270 Worker* worker = nullptr;
271 napi_unwrap(env, result, reinterpret_cast<void**>(&worker));
272 bool status = worker->UpdateWorkerState(Worker::RunnerState::RUNNING);
273 napi_value argv[2] = { nullptr };
274 std::string message = "";
275 napi_create_string_utf8(env, message.c_str(), message.length(), &argv[0]);
276 std::string funcName = "PostMessageToHost";
277 argv[1] = propNames;
278 napi_value cb = nullptr;
279 if (status) {
280 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::PostMessageToHost, worker, &cb);
281 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
282 }
283 result = Worker_Terminate(env, global);
284 ASSERT_TRUE(result != nullptr);
285 }
286
287 //worker EventListener
288 HWTEST_F(NativeEngineTest, EventListenerTest001, testing::ext::TestSize.Level0)
289 {
290 napi_env env = (napi_env)engine_;
291 napi_value global;
292 napi_get_global(env, &global);
293 napi_value result = nullptr;
294 result = Worker_Constructor(env, global);
295 Worker* worker = nullptr;
296 napi_unwrap(env, result, reinterpret_cast<void**>(&worker));
297
298 napi_value argv[2] = {nullptr};
299 std::string message = "host";
300 napi_create_string_utf8(env, message.c_str(), message.length(), &argv[0]);
__anon0f9cdc950102(napi_env env, napi_callback_info info) 301 auto func = [](napi_env env, napi_callback_info info) -> napi_value {
302 return nullptr;
303 };
304 napi_value funcValue = nullptr;
305 napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
306 argv[1] = funcValue;
307
308 std::string funcName = "On";
309 napi_value cb = nullptr;
310 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::On, worker, &cb);
311 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
312
313 funcName = "Once";
314 cb = nullptr;
315 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::Once, worker, &cb);
316 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
317
318 funcName = "AddEventListener";
319 cb = nullptr;
320 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::AddEventListener, worker, &cb);
321 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
322
323 funcName = "RemoveEventListener";
324 cb = nullptr;
325 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::RemoveEventListener, worker, &cb);
326 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
327
328 funcName = "Off";
329 cb = nullptr;
330 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::Off, worker, &cb);
331 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
332
333 result = Worker_Terminate(env, global);
334 ASSERT_TRUE(result != nullptr);
335 }
336
337 //worker EventListener
338 HWTEST_F(NativeEngineTest, EventListenerTest002, testing::ext::TestSize.Level0)
339 {
340 napi_env env = (napi_env)engine_;
341 napi_value global;
342 napi_get_global(env, &global);
343 napi_value result = nullptr;
344 result = Worker_Constructor(env, global);
345 Worker* worker = nullptr;
346 napi_unwrap(env, result, reinterpret_cast<void**>(&worker));
347
348 napi_value argv[3] = {nullptr};
349 std::string message = "host";
350 napi_create_string_utf8(env, message.c_str(), message.length(), &argv[0]);
__anon0f9cdc950202(napi_env env, napi_callback_info info) 351 auto func = [](napi_env env, napi_callback_info info) -> napi_value {
352 return nullptr;
353 };
354 napi_value funcValue = nullptr;
355 napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
356 argv[1] = funcValue;
357 std::string funcName = "On";
358 napi_value cb = nullptr;
359 funcName = "Once";
360 cb = nullptr;
361 napi_value myobject = nullptr;
362 napi_create_object(env, &myobject);
363
364 argv[2] = myobject;
365 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::Once, worker, &cb);
366 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
367 result = Worker_Terminate(env, global);
368 ASSERT_TRUE(result != nullptr);
369 }
370
371 //worker DispatchEvent
372 HWTEST_F(NativeEngineTest, DispatchEventTest001, testing::ext::TestSize.Level0)
373 {
374 napi_env env = (napi_env)engine_;
375 napi_value global;
376 napi_get_global(env, &global);
377 napi_value result = nullptr;
378 result = Worker_Constructor(env, global);
379 Worker* worker = nullptr;
380 napi_unwrap(env, result, reinterpret_cast<void**>(&worker));
381
382
383 napi_value argv1[2] = {nullptr};
384 std::string message = "host";
385 napi_create_string_utf8(env, message.c_str(), message.length(), &argv1[0]);
__anon0f9cdc950302(napi_env env, napi_callback_info info) 386 auto func = [](napi_env env, napi_callback_info info) -> napi_value {
387 return nullptr;
388 };
389 napi_value funcValue = nullptr;
390 napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
391 argv1[1] = funcValue;
392
393 std::string funcName = "Once";
394 napi_value cb = nullptr;
395 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::Once, worker, &cb);
396 napi_call_function(env, global, cb, sizeof(argv1) / sizeof(argv1[0]), argv1, &result);
397 napi_value argv[1] = {nullptr};
398
399 napi_value typeValue = nullptr;
400 std::string type = "zhangsan";
401 napi_create_string_utf8(env, type.c_str(), type.length(), &typeValue);
402
403 napi_value object = nullptr;
404 napi_create_object(env, &object);
405 napi_set_named_property(env, object, "type", typeValue);
406 argv[0] = object;
407
408 funcName = "DispatchEvent";
409 cb = nullptr;
410 napi_create_function(env, funcName.c_str(), funcName.size(), Worker::DispatchEvent, worker, &cb);
411 napi_call_function(env, global, cb, sizeof(argv) / sizeof(argv[0]), argv, &result);
412
413 result = Worker_Terminate(env, global);
414 ASSERT_TRUE(result != nullptr);
415 }
416
417 //worker ParentPortAddEventListener
418 HWTEST_F(NativeEngineTest, ParentPortAddEventListenerTest001, testing::ext::TestSize.Level0)
419 {
420 napi_env env = (napi_env)engine_;
421 napi_value global;
422 napi_get_global(env, &global);
423 napi_value result = nullptr;
424 result = Worker_Constructor(env, global);
425 Worker* worker = nullptr;
426 napi_unwrap(env, result, reinterpret_cast<void**>(&worker));
427 bool status = worker->UpdateWorkerState(Worker::RunnerState::RUNNING);
428 // ------- workerEnv---------
429 napi_env workerEnv = nullptr;
430 napi_create_runtime(env, &workerEnv);
431 napi_value workerGlobal = nullptr;
432 napi_get_global(workerEnv, &workerGlobal);
433
434 napi_value argv[3] = {nullptr};
435 std::string message = "host";
436 napi_create_string_utf8(workerEnv, message.c_str(), message.length(), &argv[0]);
__anon0f9cdc950402(napi_env env, napi_callback_info info) 437 auto func = [](napi_env env, napi_callback_info info) -> napi_value {
438 return nullptr;
439 };
440
441 std::string funcName = "ParentPortAddEventListener";
442 napi_value cb = nullptr;
443 napi_value funcValue = nullptr;
444 napi_create_function(workerEnv, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
445 argv[1] = funcValue;
446 napi_value myobject = nullptr;
447 napi_create_object(workerEnv, &myobject);
448 argv[2] = myobject;
449 napi_value callResult = nullptr;
450 if (status) {
451 napi_create_function(workerEnv, funcName.c_str(), funcName.size(),
452 Worker::ParentPortAddEventListener, worker, &cb);
453 napi_call_function(workerEnv, workerGlobal, cb, sizeof(argv) / sizeof(argv[0]), argv, &callResult);
454 }
455 // ------- workerEnv---------
456 result = Worker_Terminate(env, global);
457 ASSERT_TRUE(result != nullptr);
458 }
459
460 //worker ParentPortRemoveAllListener
461 HWTEST_F(NativeEngineTest, ParentPortRemoveAllListenerTest001, testing::ext::TestSize.Level0)
462 {
463 napi_env env = (napi_env)engine_;
464 napi_value global;
465 napi_get_global(env, &global);
466 napi_value result = nullptr;
467 result = Worker_Constructor(env, global);
468 Worker* worker = nullptr;
469 napi_unwrap(env, result, reinterpret_cast<void**>(&worker));
470 bool status = worker->UpdateWorkerState(Worker::RunnerState::RUNNING);
471
472 // ------- workerEnv---------
473 napi_env workerEnv = nullptr;
474 napi_create_runtime(env, &workerEnv);
475 napi_value workerGlobal = nullptr;
476 napi_get_global(workerEnv, &workerGlobal);
477 napi_value argv[1] = {nullptr};
478 std::string message = "host";
479 napi_create_string_utf8(workerEnv, message.c_str(), message.length(), &argv[0]);
480 std::string funcName = "ParentPortRemoveAllListener";
481 napi_value cb = nullptr;
482
483 napi_value callResult = nullptr;
484 if (status) {
485 napi_create_function(workerEnv, funcName.c_str(), funcName.size(),
486 Worker::ParentPortRemoveAllListener, worker, &cb);
487 napi_call_function(workerEnv, workerGlobal, cb, sizeof(argv) / sizeof(argv[0]), argv, &callResult);
488 }
489 // ------- workerEnv---------
490
491 result = Worker_Terminate(env, global);
492 ASSERT_TRUE(result != nullptr);
493 }
494
495 //worker ParentPortDispatchEvent
496 HWTEST_F(NativeEngineTest, ParentPortDispatchEventTest001, testing::ext::TestSize.Level0)
497 {
498 napi_env env = (napi_env)engine_;
499 napi_value global;
500 napi_get_global(env, &global);
501 napi_value result = nullptr;
502 result = Worker_Constructor(env, global);
503 Worker* worker = nullptr;
504 napi_unwrap(env, result, reinterpret_cast<void**>(&worker));
505 bool status = worker->UpdateWorkerState(Worker::RunnerState::RUNNING);
506
507 // ------- workerEnv---------
508 napi_env workerEnv = nullptr;
509 napi_create_runtime(env, &workerEnv);
510 napi_value workerGlobal = nullptr;
511 napi_get_global(workerEnv, &workerGlobal);
512
513 napi_value argv[1] = {nullptr};
514 napi_value objresult = nullptr;
515 napi_create_object(workerEnv, &objresult);
516 napi_value cb = nullptr;
517 std::string funcName = "ParentPortDispatchEvent";
518 napi_value messageKey = nullptr;
519 const char* messageKeyStr = "type";
520 napi_create_string_latin1(workerEnv, messageKeyStr, strlen(messageKeyStr), &messageKey);
521 napi_value messageValue = nullptr;
522 const char* messageValueStr = "message";
523 napi_create_string_latin1(workerEnv, messageValueStr, strlen(messageValueStr), &messageValue);
524 napi_set_property(workerEnv, objresult, messageKey, messageValue);
525 argv[0] = objresult;
526 napi_value callResult = nullptr;
527 if (status) {
528 napi_create_function(workerEnv, funcName.c_str(), funcName.size(),
529 Worker::ParentPortDispatchEvent, worker, &cb);
530 napi_call_function(workerEnv, workerGlobal, cb, sizeof(argv) / sizeof(argv[0]), argv, &callResult);
531 }
532 // ------- workerEnv---------
533
534 result = Worker_Terminate(env, global);
535 ASSERT_TRUE(result != nullptr);
536 }
537
538 //worker ParentPortRemoveEventListener
539 HWTEST_F(NativeEngineTest, ParentPortRemoveEventListenerTest001, testing::ext::TestSize.Level0)
540 {
541 napi_env env = (napi_env)engine_;
542 napi_value global;
543 napi_get_global(env, &global);
544 napi_value result = nullptr;
545 result = Worker_Constructor(env, global);
546 Worker* worker = nullptr;
547 napi_unwrap(env, result, reinterpret_cast<void**>(&worker));
548 bool status = worker->UpdateWorkerState(Worker::RunnerState::RUNNING);
549
550 // ------- workerEnv---------
551 napi_env workerEnv = nullptr;
552 napi_create_runtime(env, &workerEnv);
553 napi_value workerGlobal = nullptr;
554 napi_get_global(workerEnv, &workerGlobal);
555
556 napi_value argv[2] = {nullptr};
557 std::string message = "host";
558 napi_create_string_utf8(workerEnv, message.c_str(), message.length(), &argv[0]);
__anon0f9cdc950502(napi_env env, napi_callback_info info) 559 auto func = [](napi_env env, napi_callback_info info) -> napi_value {
560 return nullptr;
561 };
562 std::string funcName = "ParentPortRemoveEventListener";
563 napi_value cb = nullptr;
564 napi_value funcValue = nullptr;
565 napi_create_function(workerEnv, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
566 argv[1] = funcValue;
567
568 napi_value callResult = nullptr;
569 if (status) {
570 napi_create_function(workerEnv, funcName.c_str(), funcName.size(),
571 Worker::ParentPortAddEventListener, worker, &cb);
572 napi_call_function(workerEnv, workerGlobal, cb, sizeof(argv) / sizeof(argv[0]), argv, &callResult);
573 }
574 // ------- workerEnv---------
575
576 result = Worker_Terminate(env, global);
577 ASSERT_TRUE(result != nullptr);
578 }