1 /*
2 * Copyright (c) 2021 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 #include "napi/native_api.h"
16 #include "hilog/log.h"
17 #include "c/task.h"
18 #include "c/type_def.h"
19 #include "c/condition_variable.h"
20 #include "c/mutex.h"
21 #include "c/queue.h"
22 #include "c/sleep.h"
23 #include <mutex>
24 #include <thread>
25 #include <string>
26 #include <unistd.h>
27 #include <pthread.h>
28
OnePlusForTest(void * arg)29 void OnePlusForTest(void* arg)
30 {
31 (*static_cast<int*>(arg)) += 1;
32 }
33
MultipleForTest(void * arg)34 void MultipleForTest(void* arg)
35 {
36 (*static_cast<int*>(arg)) *= 10;
37 }
38
SubForTest(void * arg)39 void SubForTest(void* arg)
40 {
41 (*static_cast<int*>(arg)) -= 1;
42 }
43
OnePlusSleepForTest(void * arg)44 void OnePlusSleepForTest(void* arg)
45 {
46 ffrt_usleep(2000 * 1000);
47 (*static_cast<int*>(arg)) += 1;
48 }
49
50 typedef struct {
51 ffrt_cond_t* cond;
52 int* a;
53 int* b;
54 ffrt_mutex_t* lock_;
55 int* dur;
56 int* ret;
57 } CvMutex;
58
FuncWait1(void * arg)59 void FuncWait1(void* arg)
60 {
61 CvMutex* t = static_cast<CvMutex*>(arg);
62 int ret = ffrt_mutex_lock(t->lock_);
63 if (ret != ffrt_success) {
64 *t->ret = 1;
65 }
66
67 while (*t->a != 1) {
68 ret = ffrt_cond_wait(t->cond, t->lock_);
69 if (ret != ffrt_success) {
70 *t->ret = 2;
71 }
72 }
73 *t->b += 1;
74 ret = ffrt_mutex_unlock(t->lock_);
75 if (ret != ffrt_success) {
76 *t->ret = 3;
77 }
78 }
79
FuncWait2(void * arg)80 void FuncWait2(void* arg)
81 {
82 CvMutex* t = static_cast<CvMutex*>(arg);
83 int ret = ffrt_mutex_lock(t->lock_);
84 if (ret != ffrt_success) {
85 *t->ret = 1;
86 }
87
88 while (*t->a != 1) {
89 ret = ffrt_cond_wait(t->cond, t->lock_);
90 if (ret != ffrt_success) {
91 *t->ret = 2;
92 }
93 }
94 *t->b += 1;
95 ret = ffrt_mutex_unlock(t->lock_);
96 if (ret != ffrt_success) {
97 *t->ret = 3;
98 }
99 }
100
FuncWaitTimeout(void * arg)101 void FuncWaitTimeout(void* arg)
102 {
103 CvMutex* t = static_cast<CvMutex*>(arg);
104 int ret = ffrt_mutex_lock(t->lock_);
105 if (ret != ffrt_success) {
106 *t->ret = 1;
107 }
108 timespec ts;
109 clock_gettime(CLOCK_MONOTONIC, &ts);
110 ts.tv_sec += 1;
111
112 ret = ffrt_cond_timedwait(t->cond, t->lock_, &ts);
113 *t->ret = ret;
114 if (ret == ffrt_success) {
115 *(t->a) *= 10;
116 }
117 ret = ffrt_mutex_unlock(t->lock_);
118 }
119
FuncSignal(void * arg)120 void FuncSignal(void* arg)
121 {
122 ffrt_usleep(30000);
123 CvMutex* t = static_cast<CvMutex*>(arg);
124 int ret = ffrt_mutex_lock(t->lock_);
125 if (ret != ffrt_success) {
126 *t->ret = 1;
127 }
128 *(t->a) = 1;
129 ret = ffrt_cond_signal(t->cond);
130 if (ret != ffrt_success) {
131 *t->ret = 2;
132 }
133 ret = ffrt_mutex_unlock(t->lock_);
134 if (ret != ffrt_success) {
135 *t->ret = 3;
136 }
137 }
138
FuncBroadcast(void * arg)139 void FuncBroadcast(void* arg)
140 {
141 ffrt_usleep(100000);
142 CvMutex* t = static_cast<CvMutex*>(arg);
143 int ret = ffrt_mutex_lock(t->lock_);
144 if (ret != ffrt_success) {
145 *t->ret = 1;
146 }
147 *(t->a) = 1;
148 ret = ffrt_cond_broadcast(t->cond);
149 if (ret != ffrt_success) {
150 *t->ret = 2;
151 }
152 ret = ffrt_mutex_unlock(t->lock_);
153 if (ret != ffrt_success) {
154 *t->ret = 3;
155 }
156 }
157
FuncSignalApi(void * arg)158 void FuncSignalApi(void* arg)
159 {
160 ffrt_usleep(30000);
161 CvMutex* t = static_cast<CvMutex*>(arg);
162 int ret = ffrt_mutex_lock(t->lock_);
163 if (ret != ffrt_success) {
164 *t->ret = 1;
165 }
166 *(t->a) = 1;
167 ret = ffrt_cond_signal(nullptr);
168 if (ret != ffrt_error_inval) {
169 *t->ret = 4;
170 }
171 ret = ffrt_cond_signal(t->cond);
172 if (ret != ffrt_success) {
173 *t->ret = 2;
174 }
175 ret = ffrt_mutex_unlock(t->lock_);
176 if (ret != ffrt_success) {
177 *t->ret = 3;
178 }
179 }
180
FuncBroadcastApi(void * arg)181 void FuncBroadcastApi(void* arg)
182 {
183 ffrt_usleep(100000);
184 CvMutex* t = static_cast<CvMutex*>(arg);
185 int ret = ffrt_mutex_lock(t->lock_);
186 if (ret != ffrt_success) {
187 *t->ret = 1;
188 }
189 *(t->a) = 1;
190 ret = ffrt_cond_broadcast(nullptr);
191 if (ret != ffrt_error_inval) {
192 *t->ret = 4;
193 }
194 ret = ffrt_cond_broadcast(t->cond);
195 if (ret != ffrt_success) {
196 *t->ret = 2;
197 }
198 ret = ffrt_mutex_unlock(t->lock_);
199 if (ret != ffrt_success) {
200 *t->ret = 3;
201 }
202 }
203
FuncWaitApi(void * arg)204 void FuncWaitApi(void* arg)
205 {
206 CvMutex* t = static_cast<CvMutex*>(arg);
207 int ret = ffrt_mutex_lock(t->lock_);
208 if (ret != ffrt_success) {
209 *t->ret = 1;
210 }
211
212 ret = ffrt_cond_wait(nullptr, t->lock_);
213 if (ret != ffrt_error_inval) {
214 *t->ret = 4;
215 }
216 ret = ffrt_cond_wait(t->cond, nullptr);
217 if (ret != ffrt_error_inval) {
218 *t->ret = 5;
219 }
220 while (*t->a != 1) {
221 ret = ffrt_cond_wait(t->cond, t->lock_);
222 if (ret != ffrt_success) {
223 *t->ret = 2;
224 }
225 }
226 *t->b += 1;
227 ret = ffrt_mutex_unlock(t->lock_);
228 if (ret != ffrt_success) {
229 *t->ret = 3;
230 }
231 }
232
FuncWaitTimeoutApi(void * arg)233 void FuncWaitTimeoutApi(void* arg)
234 {
235 CvMutex* t = static_cast<CvMutex*>(arg);
236 int ret = ffrt_mutex_lock(t->lock_);
237 if (ret != ffrt_success) {
238 *t->ret = 1;
239 }
240 timespec ts;
241 clock_gettime(CLOCK_MONOTONIC, &ts);
242 ts.tv_sec += *t->dur;
243
244 ret = ffrt_cond_timedwait(nullptr, t->lock_, &ts);
245 if (ret != ffrt_error_inval) {
246 *t->ret = 4;
247 }
248 ret = ffrt_cond_timedwait(t->cond, nullptr, &ts);
249 if (ret != ffrt_error_inval) {
250 *t->ret = 5;
251 }
252 ret = ffrt_cond_timedwait(t->cond, t->lock_, nullptr);
253 if (ret != ffrt_error_inval) {
254 *t->ret = 6;
255 }
256 clock_gettime(CLOCK_MONOTONIC, &ts);
257 ts.tv_sec += *t->dur;
258 ret = ffrt_cond_timedwait(t->cond, t->lock_, &ts);
259 *t->ret = ret;
260 if (ret == ffrt_success) {
261 *(t->a) *= 10;
262 }
263 ret = ffrt_mutex_unlock(t->lock_);
264 if (ret != ffrt_success) {
265 *t->ret = 3;
266 }
267 }
268
269 typedef struct {
270 ffrt_function_header_t header;
271 ffrt_function_t func;
272 ffrt_function_t after_func;
273 void* arg;
274 } CFunction;
275
FfrtExecFunctionWrapper(void * t)276 static void FfrtExecFunctionWrapper(void* t)
277 {
278 CFunction* f = static_cast<CFunction*>(t);
279 if (f->func) {
280 f->func(f->arg);
281 }
282 }
283
FfrtDestroyFunctionWrapper(void * t)284 static void FfrtDestroyFunctionWrapper(void* t)
285 {
286 CFunction* f = static_cast<CFunction*>(t);
287 if (f->after_func) {
288 f->after_func(f->arg);
289 }
290 }
291
292 #define FFRT_STATIC_ASSERT(cond, msg) int x(int static_assertion_##msg[(cond) ? 1 : -1])
ffrt_create_function_wrapper(const ffrt_function_t func,const ffrt_function_t after_func,void * arg,ffrt_function_kind_t kind_t=ffrt_function_kind_general)293 static inline ffrt_function_header_t* ffrt_create_function_wrapper(const ffrt_function_t func,
294 const ffrt_function_t after_func, void* arg, ffrt_function_kind_t kind_t = ffrt_function_kind_general)
295 {
296 FFRT_STATIC_ASSERT(sizeof(CFunction) <= ffrt_auto_managed_function_storage_size,
297 size_of_function_must_be_less_than_ffrt_auto_managed_function_storage_size);
298 CFunction* f = static_cast<CFunction*>(ffrt_alloc_auto_managed_function_storage_base(kind_t));
299 f->header.exec = FfrtExecFunctionWrapper;
300 f->header.destroy = FfrtDestroyFunctionWrapper;
301 f->func = func;
302 f->after_func = after_func;
303 f->arg = arg;
304 return reinterpret_cast<ffrt_function_header_t*>(f);
305 }
306
307 template<class T>
308 struct Function {
309 template<class CT>
FunctionFunction310 Function(ffrt_function_header_t h, CT&& c) : header(h), closure(std::forward<CT>(c)) {}
311 ffrt_function_header_t header;
312 T closure;
313 };
314
315 template<class T>
ExecFunctionWrapper(void * t)316 void ExecFunctionWrapper(void* t)
317 {
318 auto f = reinterpret_cast<Function<std::decay_t<T>>*>(t);
319 f->closure();
320 }
321
322 template<class T>
DestroyFunctionWrapper(void * t)323 void DestroyFunctionWrapper(void* t)
324 {
325 auto f = reinterpret_cast<Function<std::decay_t<T>>*>(t);
326 f->closure = nullptr;
327 }
328
329 template<class T>
create_function_wrapper(T && func,ffrt_function_kind_t kind=ffrt_function_kind_general)330 static inline ffrt_function_header_t* create_function_wrapper(T&& func,
331 ffrt_function_kind_t kind = ffrt_function_kind_general)
332 {
333 using function_type = Function<std::decay_t<T>>;
334 auto p = ffrt_alloc_auto_managed_function_storage_base(kind);
335 auto f =
336 new (p)function_type({ ExecFunctionWrapper<T>, DestroyFunctionWrapper<T>, { 0 } }, std::forward<T>(func));
337 return reinterpret_cast<ffrt_function_header_t*>(f);
338 }
339
ConditionVariableTest001(napi_env env,napi_callback_info info)340 static napi_value ConditionVariableTest001(napi_env env, napi_callback_info info)
341 {
342 int resultEnd = 0;
343 //验证ffrt_cond_signal唤醒一个wait功能是否正确
344 ffrt_cond_t cond;
345 int ret = ffrt_cond_init(&cond, nullptr);
346 if (ret != ffrt_success) {
347 resultEnd = 7;
348 }
349
350 int a = 0;
351 int b = 0;
352 ffrt_mutex_t lock_;
353 CvMutex t = {&cond, &a, &b, &lock_, nullptr, nullptr};
354 ret = ffrt_mutex_init(&lock_, nullptr);
355 if (ret != ffrt_success) {
356 resultEnd = 8;
357 }
358
359 std::function<void()>&& FfrtFunc1 = [&t]() { FuncWait1(static_cast<void*>(&t)); };
360 ffrt_function_header_t* ffrt_func1 = create_function_wrapper((FfrtFunc1));
361 ffrt_submit_base(ffrt_func1, nullptr, nullptr, nullptr);
362 std::function<void()>&& FfrtFunc2 = [&t]() { FuncSignal(static_cast<void*>(&t)); };
363 ffrt_function_header_t* ffrt_func2 = create_function_wrapper((FfrtFunc2));
364 ffrt_submit_base(ffrt_func2, nullptr, nullptr, nullptr);
365 ffrt_wait();
366 if (*(t.b) != 1) {
367 resultEnd = 9;
368 }
369 if (t.ret != nullptr) {
370 resultEnd = *(t.ret);
371 }
372 ffrt_cond_destroy(&cond);
373 ffrt_mutex_destroy(&lock_);
374 napi_value flag = nullptr;
375 napi_create_double(env, resultEnd, &flag);
376 return flag;
377 }
378
ConditionVariableTest002(napi_env env,napi_callback_info info)379 static napi_value ConditionVariableTest002(napi_env env, napi_callback_info info)
380 {
381 int resultEnd = 0;
382 // 验证ffrt_cond_broadcast唤醒一个wait功能是否正确
383 ffrt_cond_t cond;
384 int ret = ffrt_cond_init(&cond, nullptr);
385 if (ret != ffrt_success) {
386 resultEnd = 7;
387 }
388
389 int a = 0;
390 int b = 0;
391 ffrt_mutex_t lock_;
392 CvMutex t = {&cond, &a, &b, &lock_, nullptr, nullptr};
393 ret = ffrt_mutex_init(&lock_, nullptr);
394 if (ret != ffrt_success) {
395 resultEnd = 8;
396 }
397
398 std::function<void()>&& FfrtFunc1 = [&t]() { FuncWait1(static_cast<void*>(&t)); };
399 ffrt_function_header_t* ffrt_func1 = create_function_wrapper((FfrtFunc1));
400 ffrt_submit_base(ffrt_func1, nullptr, nullptr, nullptr);
401 std::function<void()>&& FfrtFunc3 = [&t]() { FuncBroadcast(static_cast<void*>(&t)); };
402 ffrt_function_header_t* ffrt_func3 = create_function_wrapper((FfrtFunc3));
403 ffrt_submit_base(ffrt_func3, nullptr, nullptr, nullptr);
404 ffrt_wait();
405 if (*(t.b) != 1) {
406 resultEnd = 9;
407 }
408 if (t.ret != nullptr) {
409 resultEnd = *(t.ret);
410 }
411 ffrt_cond_destroy(&cond);
412 ffrt_mutex_destroy(&lock_);
413 napi_value flag = nullptr;
414 napi_create_double(env, resultEnd, &flag);
415 return flag;
416 }
417
ConditionVariableTest003(napi_env env,napi_callback_info info)418 static napi_value ConditionVariableTest003(napi_env env, napi_callback_info info)
419 {
420 int resultEnd = 0;
421 // 验证ffrt_cond_broadcast唤醒多个wait功能是否正确
422 ffrt_cond_t cond;
423 int ret = ffrt_cond_init(&cond, nullptr);
424 if (ret != ffrt_success) {
425 resultEnd = 7;
426 }
427
428 int a = 0;
429 int b = 0;
430 ffrt_mutex_t lock_;
431 CvMutex t = {&cond, &a, &b, &lock_, nullptr, nullptr};
432 ret = ffrt_mutex_init(&lock_, nullptr);
433 if (ret != ffrt_success) {
434 resultEnd = 8;
435 }
436
437 std::function<void()>&& FfrtFunc1 = [&t]() { FuncWait1(static_cast<void*>(&t)); };
438 ffrt_function_header_t* ffrt_func1 = create_function_wrapper((FfrtFunc1));
439 ffrt_submit_base(ffrt_func1, nullptr, nullptr, nullptr);
440 std::function<void()>&& FfrtFunc2 = [&t]() { FuncWait2(static_cast<void*>(&t)); };
441 ffrt_function_header_t* ffrt_func2 = create_function_wrapper((FfrtFunc2));
442 ffrt_submit_base(ffrt_func2, nullptr, nullptr, nullptr);
443 std::function<void()>&& FfrtFunc3 = [&t]() { FuncBroadcast(static_cast<void*>(&t)); };
444 ffrt_function_header_t* ffrt_func3 = create_function_wrapper((FfrtFunc3));
445 ffrt_submit_base(ffrt_func3, nullptr, nullptr, nullptr);
446 ffrt_wait();
447 if (*(t.b) != 2) {
448 resultEnd = 9;
449 }
450 if (t.ret != nullptr) {
451 resultEnd = *(t.ret);
452 }
453 ffrt_cond_destroy(&cond);
454 ffrt_mutex_destroy(&lock_);
455 napi_value flag = nullptr;
456 napi_create_double(env, resultEnd, &flag);
457 return flag;
458 }
459
ConditionVariableTest004(napi_env env,napi_callback_info info)460 static napi_value ConditionVariableTest004(napi_env env, napi_callback_info info)
461 {
462 int resultEnd = 0;
463 // 验证ffrt_cond_signal只能唤醒一个wait功能正确
464 ffrt_cond_t cond;
465 int ret = ffrt_cond_init(&cond, nullptr);
466 if (ret != ffrt_success) {
467 resultEnd = 7;
468 }
469
470 int a = 0;
471 int b = 0;
472 ffrt_mutex_t lock_;
473 CvMutex t = {&cond, &a, &b, &lock_, nullptr, nullptr};
474 ret = ffrt_mutex_init(&lock_, nullptr);
475 if (ret != ffrt_success) {
476 resultEnd = 8;
477 }
478
479 std::function<void()>&& FfrtFunc1 = [&t]() { FuncWait1(static_cast<void*>(&t)); };
480 ffrt_function_header_t* ffrt_func1 = create_function_wrapper((FfrtFunc1));
481 ffrt_submit_base(ffrt_func1, nullptr, nullptr, nullptr);
482 std::function<void()>&& FfrtFunc2 = [&t]() { FuncWait2(static_cast<void*>(&t)); };
483 ffrt_function_header_t* ffrt_func2 = create_function_wrapper((FfrtFunc2));
484 ffrt_submit_base(ffrt_func2, nullptr, nullptr, nullptr);
485 std::function<void()>&& FfrtFunc3 = [&t]() { FuncSignal(static_cast<void*>(&t)); };
486 ffrt_function_header_t* ffrt_func3 = create_function_wrapper((FfrtFunc3));
487 ffrt_task_handle_t task3 = ffrt_submit_h_base(ffrt_func3, nullptr, nullptr, nullptr);
488 const std::vector<ffrt_dependence_t> wait_deps = {{ffrt_dependence_task, task3}};
489 ffrt_deps_t wait{static_cast<uint32_t>(wait_deps.size()), wait_deps.data()};
490 ffrt_wait_deps(&wait);
491 ffrt_usleep(100000);
492 if (*(t.b) != 1) {
493 resultEnd = 10;
494 }
495
496 ffrt_func3 = create_function_wrapper((FfrtFunc3));
497 ffrt_submit_base(ffrt_func3, nullptr, nullptr, nullptr);
498 ffrt_wait();
499 if (*(t.b) != 2) {
500 resultEnd = 9;
501 }
502 if (t.ret != nullptr) {
503 resultEnd = *(t.ret);
504 }
505
506 ffrt_cond_destroy(&cond);
507 ffrt_mutex_destroy(&lock_);
508 ffrt_task_handle_destroy(task3);
509 napi_value flag = nullptr;
510 napi_create_double(env, resultEnd, &flag);
511 return flag;
512 }
513
ConditionVariableApiTest001(napi_env env,napi_callback_info info)514 static napi_value ConditionVariableApiTest001(napi_env env, napi_callback_info info)
515 {
516 int resultEnd = 0;
517 //验证ffrt_cond_init接口异常参数
518 ffrt_cond_t cond;
519 int ret = ffrt_cond_init(nullptr, nullptr);
520 if (ret != ffrt_error_inval) {
521 resultEnd = 7;
522 }
523 ffrt_condattr_t attr;
524 ret = ffrt_cond_init(&cond, &attr);
525 if (ret != ffrt_success) {
526 resultEnd = 8;
527 }
528
529 int a = 0;
530 int b = 0;
531 ffrt_mutex_t lock_;
532 CvMutex t = {&cond, &a, &b, &lock_, nullptr, nullptr};
533 ret = ffrt_mutex_init(&lock_, nullptr);
534 if (ret != ffrt_success) {
535 resultEnd = 9;
536 }
537
538 std::function<void()>&& FfrtFunc1 = [&t]() { FuncWait1(static_cast<void*>(&t)); };
539 ffrt_function_header_t* ffrt_func1 = create_function_wrapper((FfrtFunc1));
540 ffrt_submit_base(ffrt_func1, nullptr, nullptr, nullptr);
541 std::function<void()>&& FfrtFunc2 = [&t]() { FuncSignal(static_cast<void*>(&t)); };
542 ffrt_function_header_t* ffrt_func2 = create_function_wrapper((FfrtFunc2));
543 ffrt_submit_base(ffrt_func2, nullptr, nullptr, nullptr);
544 ffrt_wait();
545 if (*(t.b) != 1) {
546 resultEnd = 10;
547 }
548 if (t.ret != nullptr) {
549 resultEnd = *(t.ret);
550 }
551 ffrt_cond_destroy(&cond);
552 ffrt_mutex_destroy(&lock_);
553 napi_value flag = nullptr;
554 napi_create_double(env, resultEnd, &flag);
555 return flag;
556 }
557
ConditionVariableApiTest002(napi_env env,napi_callback_info info)558 static napi_value ConditionVariableApiTest002(napi_env env, napi_callback_info info)
559 {
560 int resultEnd = 0;
561 //验证ffrt_cond_signal接口异常参数
562 ffrt_cond_t cond;
563 int ret = ffrt_cond_init(&cond, nullptr);
564 if (ret != ffrt_success) {
565 resultEnd = 7;
566 }
567
568 int a = 0;
569 int b = 0;
570 ffrt_mutex_t lock_;
571 CvMutex t = {&cond, &a, &b, &lock_, nullptr, nullptr};
572 ret = ffrt_mutex_init(&lock_, nullptr);
573 if (ret != ffrt_success) {
574 resultEnd = 8;
575 }
576
577 std::function<void()>&& FfrtFunc1 = [&t]() { FuncWait1(static_cast<void*>(&t)); };
578 ffrt_function_header_t* ffrt_func1 = create_function_wrapper((FfrtFunc1));
579 ffrt_submit_base(ffrt_func1, nullptr, nullptr, nullptr);
580 std::function<void()>&& FfrtFunc2 = [&t]() { FuncSignalApi(static_cast<void*>(&t)); };
581 ffrt_function_header_t* ffrt_func2 = create_function_wrapper((FfrtFunc2));
582 ffrt_submit_base(ffrt_func2, nullptr, nullptr, nullptr);
583 ffrt_wait();
584 if (*(t.b) != 1) {
585 resultEnd = 10;
586 }
587 if (t.ret != nullptr) {
588 resultEnd = *(t.ret);
589 }
590 ffrt_cond_destroy(&cond);
591 ffrt_mutex_destroy(&lock_);
592 napi_value flag = nullptr;
593 napi_create_double(env, resultEnd, &flag);
594 return flag;
595 }
596
ConditionVariableApiTest003(napi_env env,napi_callback_info info)597 static napi_value ConditionVariableApiTest003(napi_env env, napi_callback_info info)
598 {
599 int resultEnd = 0;
600 // 验证ffrt_cond_broadcast接口异常参数
601 ffrt_cond_t cond;
602 int ret = ffrt_cond_init(&cond, nullptr);
603 if (ret != ffrt_success) {
604 resultEnd = 7;
605 }
606
607 int a = 0;
608 int b = 0;
609 ffrt_mutex_t lock_;
610 CvMutex t = {&cond, &a, &b, &lock_, nullptr, nullptr};
611 ret = ffrt_mutex_init(&lock_, nullptr);
612 if (ret != ffrt_success) {
613 resultEnd = 8;
614 }
615
616 std::function<void()>&& FfrtFunc1 = [&t]() { FuncWait1(static_cast<void*>(&t)); };
617 ffrt_function_header_t* ffrt_func1 = create_function_wrapper((FfrtFunc1));
618 ffrt_submit_base(ffrt_func1, nullptr, nullptr, nullptr);
619 std::function<void()>&& FfrtFunc3 = [&t]() { FuncBroadcastApi(static_cast<void*>(&t)); };
620 ffrt_function_header_t* ffrt_func3 = create_function_wrapper((FfrtFunc3));
621 ffrt_submit_base(ffrt_func3, nullptr, nullptr, nullptr);
622 ffrt_wait();
623 if (*(t.b) != 1) {
624 resultEnd = 10;
625 }
626 if (t.ret != nullptr) {
627 resultEnd = *(t.ret);
628 }
629 ffrt_cond_destroy(&cond);
630 ffrt_mutex_destroy(&lock_);
631 napi_value flag = nullptr;
632 napi_create_double(env, resultEnd, &flag);
633 return flag;
634 }
635
ConditionVariableApiTest004(napi_env env,napi_callback_info info)636 static napi_value ConditionVariableApiTest004(napi_env env, napi_callback_info info)
637 {
638 int resultEnd = 0;
639 //验证ffrt_cond_wait接口异常参数
640 ffrt_cond_t cond;
641 int ret = ffrt_cond_init(&cond, nullptr);
642 if (ret != ffrt_success) {
643 resultEnd = 7;
644 }
645
646 int a = 0;
647 int b = 0;
648 ffrt_mutex_t lock_;
649 CvMutex t = {&cond, &a, &b, &lock_, nullptr, nullptr};
650 ret = ffrt_mutex_init(&lock_, nullptr);
651 if (ret != ffrt_success) {
652 resultEnd = 8;
653 }
654
655 std::function<void()>&& FfrtFunc1 = [&t]() { FuncWaitApi(static_cast<void*>(&t)); };
656 ffrt_function_header_t* ffrt_func1 = create_function_wrapper((FfrtFunc1));
657 ffrt_submit_base(ffrt_func1, nullptr, nullptr, nullptr);
658 std::function<void()>&& FfrtFunc2 = [&t]() { FuncSignal(static_cast<void*>(&t)); };
659 ffrt_function_header_t* ffrt_func2 = create_function_wrapper((FfrtFunc2));
660 ffrt_submit_base(ffrt_func2, nullptr, nullptr, nullptr);
661 ffrt_wait();
662 if (*(t.b) != 1) {
663 resultEnd = 10;
664 }
665 if (t.ret != nullptr) {
666 resultEnd = *(t.ret);
667 }
668 ffrt_cond_destroy(&cond);
669 ffrt_mutex_destroy(&lock_);
670 napi_value flag = nullptr;
671 napi_create_double(env, resultEnd, &flag);
672 return flag;
673 }
674
DelayCTest001(napi_env env,napi_callback_info info)675 static napi_value DelayCTest001(napi_env env, napi_callback_info info)
676 {
677 int result = 0;
678 // 验证delay的set和get c接口
679 int a = 0;
680 ffrt_task_attr_t task_attr;
681 (void)ffrt_task_attr_init(&task_attr);
682 ffrt_task_attr_set_delay(&task_attr, 5000);
683
684 double t;
685 auto start = std::chrono::high_resolution_clock::now();
686 std::function<void()>&& OnePlusFunc = [&a]() { a += 1; };
687 ffrt_task_handle_t task = ffrt_submit_h_base(create_function_wrapper(OnePlusFunc), {}, {}, &task_attr);
688 const std::vector<ffrt_dependence_t> wait_deps = {{ffrt_dependence_task, task}};
689 ffrt_deps_t wait{static_cast<uint32_t>(wait_deps.size()), wait_deps.data()};
690 ffrt_wait_deps(&wait);
691 auto end = std::chrono::high_resolution_clock::now();
692 std::chrono::duration<double, std::micro> elapsed = end-start;
693 t = elapsed.count();
694 if (a != 1) {
695 result = 1;
696 }
697 if (t <= 5000 || t >= 20000) {
698 result = 2;
699 }
700
701 uint64_t delay = ffrt_task_attr_get_delay(&task_attr);
702 if (delay != 5000) {
703 result = 3;
704 }
705 ffrt_task_attr_destroy(&task_attr);
706 ffrt_task_handle_destroy(task);
707 napi_value flag = nullptr;
708 napi_create_double(env, result, &flag);
709 return flag;
710 }
711
FfrtYieldC0001(napi_env env,napi_callback_info info)712 static napi_value FfrtYieldC0001(napi_env env, napi_callback_info info)
713 {
714 int result = 0;
715 int x = 0;
716 pthread_mutex_t lock;
717 int ret = (pthread_mutex_init(&lock, nullptr));
718 if (ret != 0) {
719 result = 1;
720 }
721 std::function<void()>&& func1 = [&]() {
722 while (true) {
723 pthread_mutex_lock(&lock);
724 if (x == 1) {
725 pthread_mutex_unlock(&lock);
726 return;
727 } else {
728 pthread_mutex_unlock(&lock);
729 usleep(1000);
730 ffrt_yield();
731 }
732 }
733 };
734 std::function<void()>&& func2 = [&]() {
735 pthread_mutex_lock(&lock);
736 x++;
737 pthread_mutex_unlock(&lock);
738 };
739 ffrt_task_handle_t task = ffrt_submit_h_base(create_function_wrapper(func1), nullptr, nullptr, nullptr);
740 for (int i = 0; i < 20; i++) {
741 ffrt_submit_base(create_function_wrapper(func1), nullptr, nullptr, nullptr);
742 }
743 ffrt_submit_base(create_function_wrapper(func2), nullptr, nullptr, nullptr);
744 const std::vector<ffrt_dependence_t> wait_deps = {{ffrt_dependence_task, task}};
745 ffrt_deps_t wait{static_cast<uint32_t>(wait_deps.size()), wait_deps.data()};
746 ffrt_wait_deps(&wait);
747 if (x != 1) {
748 result = 7;
749 }
750 ffrt_wait();
751 if (x != 1) {
752 result = 8;
753 }
754 ffrt_task_handle_destroy(task);
755 pthread_mutex_destroy(&lock);
756 napi_value flag = nullptr;
757 napi_create_double(env, result, &flag);
758 return flag;
759 }
760
MutexAbnormalParamTest001(napi_env env,napi_callback_info info)761 static napi_value MutexAbnormalParamTest001(napi_env env, napi_callback_info info)
762 {
763 int result = 0;
764 ffrt_mutex_t mtx;
765 ffrt_mutexattr_t attr;
766 int ret = ffrt_mutex_init(NULL, &attr);
767 if (ret != ffrt_error_inval) {
768 result = 1;
769 }
770 ret = ffrt_mutex_init(&mtx, &attr);
771 if (ret != ffrt_error) {
772 result = 2;
773 }
774 ret = ffrt_mutex_init(&mtx, nullptr);
775 if (ret != ffrt_success) {
776 result = 3;
777 }
778 ret = ffrt_mutex_destroy(NULL);
779 if (ret != ffrt_error_inval) {
780 result = 4;
781 }
782 ret = ffrt_mutex_destroy(&mtx);
783 if (ret != ffrt_success) {
784 result = 5;
785 }
786 napi_value flag = nullptr;
787 napi_create_double(env, result, &flag);
788 return flag;
789 }
790
MutexAbnormalParamTest002(napi_env env,napi_callback_info info)791 static napi_value MutexAbnormalParamTest002(napi_env env, napi_callback_info info)
792 {
793 int result = 0;
794 ffrt_mutex_t mtx;
795 int ret = ffrt_mutex_init(&mtx, nullptr);
796 if (ret != ffrt_success) {
797 result = 1;
798 }
799 std::function<void()>&& func = [&]() {
800 ret = ffrt_mutex_lock(NULL);
801 if (ret != ffrt_error_inval) {
802 result = 2;
803 }
804 ret = ffrt_mutex_lock(&mtx);
805 ret = ffrt_mutex_unlock(NULL);
806 if (ret != ffrt_error_inval) {
807 result = 3;
808 }
809 ret = ffrt_mutex_trylock(NULL);
810 if (ret != ffrt_error_inval) {
811 result = 4;
812 }
813 ret = ffrt_mutex_trylock(&mtx); // 没抢到锁
814 if (ret != ffrt_error_busy) {
815 result = 5;
816 }
817 ret = ffrt_mutex_destroy(NULL);
818 if (ret != ffrt_error_inval) {
819 result = 6;
820 }
821 ret = ffrt_mutex_unlock(&mtx);
822 if (ret != ffrt_success) {
823 result = 7;
824 }
825 };
826 ffrt_submit_base(create_function_wrapper(func), nullptr, nullptr, nullptr);
827 ffrt_wait();
828 ret = ffrt_mutex_destroy(&mtx);
829 if (ret != ffrt_success) {
830 result = 8;
831 }
832 napi_value flag = nullptr;
833 napi_create_double(env, result, &flag);
834 return flag;
835 }
836
MutexTest006(napi_env env,napi_callback_info info)837 static napi_value MutexTest006(napi_env env, napi_callback_info info)
838 {
839 int resultEnd = 0;
840 int x = 0;
841 ffrt_mutex_t lock;
842 int ret = ffrt_mutex_init(&lock, nullptr);
843 if (ret != ffrt_success) {
844 resultEnd = 1;
845 }
846 std::function<void()>&& func1 = [&]() {
847 ffrt_usleep(50 * 1000);
848 int res = ffrt_mutex_lock(&lock);
849 if (res != ffrt_success) {
850 resultEnd = 2;
851 }
852 x = x * 2;
853 res = ffrt_mutex_unlock(&lock);
854 if (res != ffrt_success) {
855 resultEnd = 3;
856 }
857 };
858 std::function<void()>&& func2 = [&]() {
859 int res = ffrt_mutex_lock(&lock);
860 if (res != ffrt_success) {
861 resultEnd = 4;
862 }
863 ffrt_usleep(100 * 1000);
864 x++;
865 res = ffrt_mutex_unlock(&lock);
866 if (res != ffrt_success) {
867 resultEnd = 5;
868 }
869 };
870 ffrt_submit_base(create_function_wrapper(func1), nullptr, nullptr, nullptr);
871 ffrt_submit_base(create_function_wrapper(func2), nullptr, nullptr, nullptr);
872 ffrt_wait();
873 if (x != 2) {
874 resultEnd = 6;
875 }
876 ffrt_mutex_destroy(&lock);
877 napi_value flag = nullptr;
878 napi_create_double(env, resultEnd, &flag);
879 return flag;
880 }
881
MutexTest007(napi_env env,napi_callback_info info)882 static napi_value MutexTest007(napi_env env, napi_callback_info info)
883 {
884 int resultEnd = 0;
885 int x = 0;
886 ffrt_mutex_t lock;
887 int ret = ffrt_mutex_init(&lock, nullptr);
888 if (ret != ffrt_success) {
889 resultEnd = 1;
890 }
891 std::function<void()>&& func1 = [&]() {
892 ffrt_usleep(50 * 1000);
893 int res = ffrt_mutex_lock(&lock);
894 if (res != ffrt_success) {
895 resultEnd = 2;
896 }
897 x = x * 2;
898 res = ffrt_mutex_unlock(&lock);
899 if (res != ffrt_success) {
900 resultEnd = 3;
901 }
902 };
903 std::function<void()>&& func2 = [&]() {
904 int res = ffrt_mutex_lock(&lock);
905 if (res != ffrt_success) {
906 resultEnd = 4;
907 }
908 x++;
909 res = ffrt_mutex_unlock(&lock);
910 if (res != ffrt_success) {
911 resultEnd = 5;
912 }
913 };
914 ffrt_submit_base(create_function_wrapper(func1), nullptr, nullptr, nullptr);
915 ffrt_submit_base(create_function_wrapper(func2), nullptr, nullptr, nullptr);
916 ffrt_wait();
917 ffrt_mutex_destroy(&lock);
918 napi_value flag = nullptr;
919 napi_create_double(env, resultEnd, &flag);
920 return flag;
921 }
922
MutexTest008(napi_env env,napi_callback_info info)923 static napi_value MutexTest008(napi_env env, napi_callback_info info)
924 {
925 int resultEnd = 0;
926 int x = 0;
927 int y = 0;
928 ffrt_mutex_t lock;
929 int ret = ffrt_mutex_init(&lock, nullptr);
930 if (ret != ffrt_success) {
931 resultEnd = 1;
932 }
933 std::function<void()>&& func1 = [&]() {
934 usleep(30 * 1000);
935 while (ffrt_mutex_trylock(&lock)) {
936 y++;
937 usleep(20 * 1000);
938 }
939 x = x * 2;
940 int res = ffrt_mutex_unlock(&lock);
941 if (res != ffrt_success) {
942 resultEnd = 2;
943 }
944 return;
945 };
946 std::function<void()>&& func2 = [&]() {
947 int res = ffrt_mutex_lock(&lock);
948 if (res != ffrt_success) {
949 resultEnd = 3;
950 }
951 usleep(100 * 1000);
952 x++;
953 res = ffrt_mutex_unlock(&lock);
954 if (res != ffrt_success) {
955 resultEnd = 4;
956 }
957 };
958 ffrt_submit_base(create_function_wrapper(func1), nullptr, nullptr, nullptr);
959 ffrt_submit_base(create_function_wrapper(func2), nullptr, nullptr, nullptr);
960 ffrt_wait();
961 if (x != 2) {
962 resultEnd = 5;
963 }
964 if (y == 0) {
965 resultEnd = 6;
966 }
967 ffrt_mutex_destroy(&lock);
968 napi_value flag = nullptr;
969 napi_create_double(env, resultEnd, &flag);
970 return flag;
971 }
972
QueueApiTest001(napi_env env,napi_callback_info info)973 static napi_value QueueApiTest001(napi_env env, napi_callback_info info)
974 {
975 int result = 0;
976 // ffrt_queue_create接口type为异常值
977 ffrt_queue_attr_t queue_attr;
978 (void)ffrt_queue_attr_init(&queue_attr);
979 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_max, "test_queue", &queue_attr);
980 if (queue_handle != nullptr) {
981 result = 3;
982 }
983
984 // 销毁队列
985 ffrt_queue_attr_destroy(&queue_attr);
986 ffrt_queue_destroy(queue_handle);
987 napi_value flag = nullptr;
988 napi_create_double(env, result, &flag);
989 return flag;
990 }
991
QueueApiTest002(napi_env env,napi_callback_info info)992 static napi_value QueueApiTest002(napi_env env, napi_callback_info info)
993 {
994 int result = 0;
995 // ffrt_queue_create接口name为空
996 ffrt_queue_attr_t queue_attr;
997 (void)ffrt_queue_attr_init(&queue_attr);
998 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, nullptr, &queue_attr);
999 if (queue_handle == nullptr) {
1000 result = 3;
1001 }
1002
1003 int a = 0;
1004 ffrt_queue_submit(queue_handle, ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a,
1005 ffrt_function_kind_queue), nullptr);
1006
1007 sleep(1);
1008 if (a != 1) {
1009 result = 1;
1010 }
1011
1012 // 销毁队列
1013 ffrt_queue_attr_destroy(&queue_attr);
1014 ffrt_queue_destroy(queue_handle);
1015 napi_value flag = nullptr;
1016 napi_create_double(env, result, &flag);
1017 return flag;
1018 }
1019
QueueApiTest003(napi_env env,napi_callback_info info)1020 static napi_value QueueApiTest003(napi_env env, napi_callback_info info)
1021 {
1022 int result = 0;
1023 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", nullptr);
1024 if (queue_handle != nullptr) {
1025 result = 3;
1026 }
1027 napi_value flag = nullptr;
1028 napi_create_double(env, result, &flag);
1029 return flag;
1030 }
1031
QueueApiTest004(napi_env env,napi_callback_info info)1032 static napi_value QueueApiTest004(napi_env env, napi_callback_info info)
1033 {
1034 int result = 0;
1035 (void)ffrt_queue_attr_init(nullptr);
1036 sleep(1);
1037 napi_value flag = nullptr;
1038 napi_create_double(env, result, &flag);
1039 return flag;
1040 }
1041
QueueApiTest005(napi_env env,napi_callback_info info)1042 static napi_value QueueApiTest005(napi_env env, napi_callback_info info)
1043 {
1044 int result = 0;
1045 // ffrt_queue_attr_destroy接口attr为异常值
1046 ffrt_queue_attr_t queue_attr;
1047 (void)ffrt_queue_attr_init(&queue_attr);
1048 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1049 if (queue_handle == nullptr) {
1050 result = 3;
1051 }
1052
1053 int a = 0;
1054 ffrt_queue_submit(queue_handle, ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a,
1055 ffrt_function_kind_queue), nullptr);
1056 sleep(1);
1057 if (a != 1) {
1058 result = 1;
1059 }
1060
1061 // 销毁队列
1062 ffrt_queue_attr_destroy(nullptr);
1063 ffrt_queue_attr_destroy(&queue_attr);
1064 ffrt_queue_destroy(queue_handle);
1065 napi_value flag = nullptr;
1066 napi_create_double(env, result, &flag);
1067 return flag;
1068 }
1069
QueueApiTest006(napi_env env,napi_callback_info info)1070 static napi_value QueueApiTest006(napi_env env, napi_callback_info info)
1071 {
1072 int result = 0;
1073 // ffrt_queue_attr_set_qos接口attr为异常值
1074 ffrt_queue_attr_t queue_attr;
1075 (void)ffrt_queue_attr_init(&queue_attr);
1076 ffrt_queue_attr_set_qos(nullptr, static_cast<ffrt_qos_t>(ffrt_qos_utility));
1077 ffrt_qos_t qos = ffrt_queue_attr_get_qos(&queue_attr);
1078 if (qos != static_cast<int>(ffrt_qos_default)) {
1079 result = 2;
1080 }
1081 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1082 if (queue_handle == nullptr) {
1083 result = 3;
1084 }
1085
1086 int a = 0;
1087 ffrt_queue_submit(queue_handle, ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a,
1088 ffrt_function_kind_queue), nullptr);
1089
1090 sleep(1);
1091 if (a != 1) {
1092 result = 1;
1093 }
1094
1095 // 销毁队列
1096 ffrt_queue_attr_destroy(&queue_attr);
1097 ffrt_queue_destroy(queue_handle);
1098 napi_value flag = nullptr;
1099 napi_create_double(env, result, &flag);
1100 return flag;
1101 }
1102
QueueApiTest007(napi_env env,napi_callback_info info)1103 static napi_value QueueApiTest007(napi_env env, napi_callback_info info)
1104 {
1105 int result = 0;
1106 // ffrt_queue_attr_set_qos接口qos为异常值
1107 // 设置qos为-1
1108 ffrt_queue_attr_t queue_attr;
1109 ffrt_queue_t queue_handle;
1110 (void)ffrt_queue_attr_init(&queue_attr);
1111 ffrt_queue_attr_set_qos(&queue_attr, static_cast<ffrt_qos_t>(ffrt_qos_inherit));
1112 ffrt_qos_t ret = ffrt_queue_attr_get_qos(&queue_attr);
1113 if (ret != static_cast<int>(ffrt_qos_inherit)) {
1114 result = 1;
1115 }
1116 queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1117
1118 int a = 0;
1119 ffrt_task_handle_t handle = ffrt_queue_submit_h(queue_handle,
1120 ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a, ffrt_function_kind_queue), nullptr);
1121
1122 ffrt_queue_wait(handle);
1123 if (a != 1) {
1124 result = 2;
1125 }
1126
1127 ffrt_task_handle_destroy(handle);
1128 ffrt_queue_destroy(queue_handle);
1129
1130 // 设置qos为-2
1131 ffrt_queue_attr_set_qos(&queue_attr, static_cast<ffrt_qos_t>(-2));
1132 ret = ffrt_queue_attr_get_qos(&queue_attr);
1133 if (ret != static_cast<int>(ffrt_qos_inherit)) {
1134 result = 1;
1135 }
1136 queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1137
1138 handle = ffrt_queue_submit_h(queue_handle,
1139 ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a, ffrt_function_kind_queue), nullptr);
1140
1141 usleep(2000);
1142 ffrt_queue_wait(handle);
1143 if (a != 2) {
1144 result = 3;
1145 }
1146
1147 ffrt_queue_attr_destroy(&queue_attr);
1148 ffrt_task_handle_destroy(handle);
1149 ffrt_queue_destroy(queue_handle);
1150 napi_value flag = nullptr;
1151 napi_create_double(env, result, &flag);
1152 return flag;
1153 }
1154
QueueApiTest008(napi_env env,napi_callback_info info)1155 static napi_value QueueApiTest008(napi_env env, napi_callback_info info)
1156 {
1157 int result = 0;
1158 // ffrt_queue_attr_get_qos接口attr为异常值
1159 ffrt_queue_attr_t queue_attr;
1160 (void)ffrt_queue_attr_init(&queue_attr);
1161 ffrt_queue_attr_set_qos(&queue_attr, static_cast<ffrt_qos_t>(ffrt_qos_utility));
1162 ffrt_qos_t ret = ffrt_queue_attr_get_qos(nullptr);
1163 if (ret != static_cast<int>(ffrt_qos_default)) {
1164 result = 2;
1165 }
1166 ret = ffrt_queue_attr_get_qos(&queue_attr);
1167 if (ret != static_cast<int>(ffrt_qos_utility)) {
1168 result = 1;
1169 }
1170 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1171 if (queue_handle == nullptr) {
1172 result = 3;
1173 }
1174
1175 int a = 0;
1176 ffrt_queue_submit(queue_handle, ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a,
1177 ffrt_function_kind_queue), nullptr);
1178 sleep(1);
1179 if (a != 1) {
1180 result = 1;
1181 }
1182
1183 // 销毁队列
1184 ffrt_queue_attr_destroy(&queue_attr);
1185 ffrt_queue_destroy(queue_handle);
1186 napi_value flag = nullptr;
1187 napi_create_double(env, result, &flag);
1188 return flag;
1189 }
1190
QueueApiTest009(napi_env env,napi_callback_info info)1191 static napi_value QueueApiTest009(napi_env env, napi_callback_info info)
1192 {
1193 int result = 0;
1194 // ffrt_queue_destroy接口queue为异常值
1195 ffrt_queue_attr_t queue_attr;
1196 (void)ffrt_queue_attr_init(&queue_attr);
1197 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1198 if (queue_handle == nullptr) {
1199 result = 3;
1200 }
1201
1202 int a = 0;
1203 ffrt_queue_submit(queue_handle, ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a,
1204 ffrt_function_kind_queue), nullptr);
1205 sleep(1);
1206 if (a != 1) {
1207 result = 1;
1208 }
1209
1210 // 销毁队列
1211 ffrt_queue_attr_destroy(&queue_attr);
1212 ffrt_queue_destroy(nullptr);
1213 ffrt_queue_destroy(queue_handle);
1214 napi_value flag = nullptr;
1215 napi_create_double(env, result, &flag);
1216 return flag;
1217 }
1218
QueueApiTest010(napi_env env,napi_callback_info info)1219 static napi_value QueueApiTest010(napi_env env, napi_callback_info info)
1220 {
1221 int result = 0;
1222 // ffrt_queue_submit接口queue或f为异常值
1223 ffrt_queue_attr_t queue_attr;
1224 (void)ffrt_queue_attr_init(&queue_attr);
1225 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1226 if (queue_handle == nullptr) {
1227 result = 3;
1228 }
1229
1230 int a = 0;
1231 ffrt_queue_submit(nullptr, ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a,
1232 ffrt_function_kind_queue), nullptr);
1233 ffrt_queue_submit(queue_handle, nullptr, nullptr);
1234 ffrt_queue_submit(queue_handle, ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a,
1235 ffrt_function_kind_queue), nullptr);
1236
1237 sleep(1);
1238 if (a != 1) {
1239 result = 1;
1240 }
1241
1242 // 销毁队列
1243 ffrt_queue_attr_destroy(&queue_attr);
1244 ffrt_queue_destroy(queue_handle);
1245 napi_value flag = nullptr;
1246 napi_create_double(env, result, &flag);
1247 return flag;
1248 }
1249
QueueApiTest011(napi_env env,napi_callback_info info)1250 static napi_value QueueApiTest011(napi_env env, napi_callback_info info)
1251 {
1252 int result = 0;
1253 // ffrt_queue_submit_h接口queue或f为异常值
1254 ffrt_queue_attr_t queue_attr;
1255 (void)ffrt_queue_attr_init(&queue_attr);
1256 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1257 if (queue_handle == nullptr) {
1258 result = 3;
1259 }
1260
1261 int a = 0;
1262 ffrt_task_handle_t handle = ffrt_queue_submit_h(nullptr,
1263 ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a, ffrt_function_kind_queue), nullptr);
1264 if (handle != nullptr) {
1265 result = 1;
1266 }
1267 handle = ffrt_queue_submit_h(queue_handle, nullptr, nullptr);
1268 if (handle != nullptr) {
1269 result = 2;
1270 }
1271 handle = ffrt_queue_submit_h(queue_handle,
1272 ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a, ffrt_function_kind_queue), nullptr);
1273
1274 ffrt_queue_wait(handle);
1275 if (a != 1) {
1276 result = 1;
1277 }
1278
1279 // 销毁队列
1280 ffrt_queue_attr_destroy(&queue_attr);
1281 ffrt_task_handle_destroy(handle);
1282 ffrt_queue_destroy(queue_handle);
1283 napi_value flag = nullptr;
1284 napi_create_double(env, result, &flag);
1285 return flag;
1286 }
1287
QueueApiTest012(napi_env env,napi_callback_info info)1288 static napi_value QueueApiTest012(napi_env env, napi_callback_info info)
1289 {
1290 int result = 0;
1291 // ffrt_queue_wait接口handle为异常值
1292 ffrt_queue_attr_t queue_attr;
1293 (void)ffrt_queue_attr_init(&queue_attr);
1294 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1295 if (queue_handle == nullptr) {
1296 result = 3;
1297 }
1298
1299 int a = 0;
1300 ffrt_task_handle_t handle = ffrt_queue_submit_h(queue_handle,
1301 ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a, ffrt_function_kind_queue), nullptr);
1302
1303 ffrt_queue_wait(nullptr);
1304 ffrt_queue_wait(handle);
1305 if (a != 1) {
1306 result = 1;
1307 }
1308
1309 // 销毁队列
1310 ffrt_queue_attr_destroy(&queue_attr);
1311 ffrt_task_handle_destroy(handle);
1312 ffrt_queue_destroy(queue_handle);
1313 napi_value flag = nullptr;
1314 napi_create_double(env, result, &flag);
1315 return flag;
1316 }
1317
QueueApiTest013(napi_env env,napi_callback_info info)1318 static napi_value QueueApiTest013(napi_env env, napi_callback_info info)
1319 {
1320 int result = 0;
1321 // ffrt_queue_cancel接口handle为异常值
1322 ffrt_queue_attr_t queue_attr;
1323 (void)ffrt_queue_attr_init(&queue_attr);
1324 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1325
1326 int a = 0;
1327 ffrt_task_attr_t task_attr;
1328 (void)ffrt_task_attr_init(&task_attr);
1329 ffrt_task_attr_set_delay(&task_attr, 1000000); // 设置任务1s后才执行
1330 ffrt_task_handle_t task1 = ffrt_queue_submit_h(queue_handle,
1331 ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a, ffrt_function_kind_queue), &task_attr);
1332
1333 int ret = ffrt_queue_cancel(nullptr);
1334 if (ret != -1) {
1335 result = 1;
1336 }
1337 ret = ffrt_queue_cancel(task1);
1338 if (ret != 0) {
1339 result = 2;
1340 }
1341 if (a != 0) {
1342 result = 3;
1343 }
1344
1345 ffrt_task_attr_destroy(&task_attr);
1346 ffrt_task_handle_destroy(task1);
1347
1348 // 销毁队列
1349 ffrt_queue_attr_destroy(&queue_attr);
1350 ffrt_queue_destroy(queue_handle);
1351 if (a != 0) {
1352 result = 4;
1353 }
1354 napi_value flag = nullptr;
1355 napi_create_double(env, result, &flag);
1356 return flag;
1357 }
1358
QueueCancelTest001(napi_env env,napi_callback_info info)1359 static napi_value QueueCancelTest001(napi_env env, napi_callback_info info)
1360 {
1361 int result = 0;
1362 // cancel一个delay的未执行task
1363 ffrt_queue_attr_t queue_attr;
1364 (void)ffrt_queue_attr_init(&queue_attr);
1365 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1366
1367 int a = 0;
1368 ffrt_task_attr_t task_attr;
1369 (void)ffrt_task_attr_init(&task_attr);
1370 ffrt_task_attr_set_delay(&task_attr, 1000000); // 设置任务1s后才执行
1371 ffrt_task_handle_t task1 = ffrt_queue_submit_h(queue_handle,
1372 ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a, ffrt_function_kind_queue), &task_attr);
1373
1374 int ret = ffrt_queue_cancel(task1);
1375 if (ret != 0) {
1376 result = 2;
1377 }
1378 if (a != 0) {
1379 result = 3;
1380 }
1381
1382 ffrt_task_attr_destroy(&task_attr);
1383 ffrt_task_handle_destroy(task1);
1384
1385 // 销毁队列
1386 ffrt_queue_attr_destroy(&queue_attr);
1387 ffrt_queue_destroy(queue_handle);
1388 if (a != 0) {
1389 result = 4;
1390 }
1391 napi_value flag = nullptr;
1392 napi_create_double(env, result, &flag);
1393 return flag;
1394 }
1395
QueueCancelTest003(napi_env env,napi_callback_info info)1396 static napi_value QueueCancelTest003(napi_env env, napi_callback_info info)
1397 {
1398 int result = 0;
1399 // cancel一个执行中task,ffrt的sleep
1400 ffrt_queue_attr_t queue_attr;
1401 (void)ffrt_queue_attr_init(&queue_attr);
1402 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1403
1404 int a = 0;
1405 ffrt_task_handle_t task1 = ffrt_queue_submit_h(queue_handle,
1406 ffrt_create_function_wrapper(OnePlusSleepForTest, nullptr, &a, ffrt_function_kind_queue), nullptr);
1407
1408 usleep(2000);
1409 int ret = ffrt_queue_cancel(task1);
1410 if (ret != 1) {
1411 result = 2;
1412 }
1413 if (a != 0) {
1414 result = 3;
1415 }
1416 ffrt_task_handle_destroy(task1);
1417 if (a != 0) {
1418 result = 4;
1419 }
1420
1421 // 销毁队列
1422 ffrt_queue_attr_destroy(&queue_attr);
1423 ffrt_queue_destroy(queue_handle);
1424 if (a != 1) {
1425 result = 5;
1426 }
1427 napi_value flag = nullptr;
1428 napi_create_double(env, result, &flag);
1429 return flag;
1430 }
1431
QueueCancelTest004(napi_env env,napi_callback_info info)1432 static napi_value QueueCancelTest004(napi_env env, napi_callback_info info)
1433 {
1434 int result = 0;
1435 // cancel一个已执行的task
1436 ffrt_queue_attr_t queue_attr;
1437 (void)ffrt_queue_attr_init(&queue_attr);
1438 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1439
1440 int a = 0;
1441 ffrt_task_handle_t task1 = ffrt_queue_submit_h(queue_handle,
1442 ffrt_create_function_wrapper(OnePlusForTest, nullptr, &a, ffrt_function_kind_queue), nullptr);
1443 ffrt_task_handle_t task2 = ffrt_queue_submit_h(queue_handle,
1444 ffrt_create_function_wrapper(OnePlusSleepForTest, nullptr, &a, ffrt_function_kind_queue), nullptr);
1445
1446 ffrt_queue_wait(task1);
1447 int ret = ffrt_queue_cancel(task1);
1448 if (ret != 1) {
1449 result = 2;
1450 }
1451 if (a != 1) {
1452 result = 3;
1453 }
1454 ffrt_queue_wait(task2);
1455 if (a != 2) {
1456 result = 4;
1457 }
1458 ffrt_task_handle_destroy(task1);
1459 ffrt_task_handle_destroy(task2);
1460
1461 // 销毁队列
1462 ffrt_queue_attr_destroy(&queue_attr);
1463 ffrt_queue_destroy(queue_handle);
1464 napi_value flag = nullptr;
1465 napi_create_double(env, result, &flag);
1466 return flag;
1467 }
1468
QueueDelayTest001(napi_env env,napi_callback_info info)1469 static napi_value QueueDelayTest001(napi_env env, napi_callback_info info)
1470 {
1471 int resultEnd = 0;
1472 // 验证delay时间的正确性，先提交一个非延时task，再提交一个delay 5s的task，再提交一个delay 2s的task
1473 int result = 0;
1474 ffrt_task_attr_t task_attr1;
1475 ffrt_task_attr_t task_attr2;
1476 (void)ffrt_task_attr_init(&task_attr1);
1477 (void)ffrt_task_attr_init(&task_attr2);
1478 ffrt_task_attr_set_delay(&task_attr1, 5000000);
1479 ffrt_task_attr_set_delay(&task_attr2, 2000000);
1480
1481 std::function<void()>&& MultipleFunc = [&result]() { MultipleForTest(static_cast<void*>(&result)); };
1482 ffrt_queue_attr_t queue_attr;
1483 (void)ffrt_queue_attr_init(&queue_attr);
1484 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1485 ffrt_queue_submit(queue_handle, create_function_wrapper(MultipleFunc, ffrt_function_kind_queue), nullptr);
1486 double t;
1487 auto start = std::chrono::high_resolution_clock::now();
1488 std::function<void()>&& OnePlusFunc = [&result]() { OnePlusForTest(static_cast<void*>(&result)); };
1489 std::function<void()>&& OneSubFunc = [&result]() { SubForTest(static_cast<void*>(&result)); };
1490 ffrt_task_handle_t handle1 = ffrt_queue_submit_h(queue_handle,
1491 create_function_wrapper(OneSubFunc, ffrt_function_kind_queue), &task_attr1);
1492 ffrt_task_handle_t handle2 = ffrt_queue_submit_h(queue_handle,
1493 create_function_wrapper(OnePlusFunc, ffrt_function_kind_queue), &task_attr2);
1494
1495 ffrt_queue_wait(handle2);
1496 auto end = std::chrono::high_resolution_clock::now();
1497 std::chrono::duration<double, std::milli> elapsed = end-start;
1498 t = elapsed.count();
1499 if (result != 1) {
1500 resultEnd = 1;
1501 }
1502 if (t <= 2000 || t >= 3000) {
1503 resultEnd = 2;
1504 }
1505
1506 ffrt_queue_wait(handle1);
1507 end = std::chrono::high_resolution_clock::now();
1508 elapsed = end-start;
1509 t = elapsed.count();
1510 if (result != 0) {
1511 resultEnd = 3;
1512 }
1513 if (t <= 5000 || t >= 6000) {
1514 resultEnd = 4;
1515 }
1516 ffrt_task_handle_destroy(handle1);
1517 ffrt_task_handle_destroy(handle2);
1518 ffrt_queue_attr_destroy(&queue_attr);
1519 ffrt_queue_destroy(queue_handle);
1520 napi_value flag = nullptr;
1521 napi_create_double(env, resultEnd, &flag);
1522 return flag;
1523 }
1524
QueueDelayTest002(napi_env env,napi_callback_info info)1525 static napi_value QueueDelayTest002(napi_env env, napi_callback_info info)
1526 {
1527 int result = 0;
1528 // 验证delay时间的正确性，提交一个delay 5ms的task
1529 ffrt_queue_attr_t queue_attr;
1530 (void)ffrt_queue_attr_init(&queue_attr);
1531 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1532
1533 int a = 0;
1534 ffrt_task_attr_t task_attr;
1535 (void)ffrt_task_attr_init(&task_attr);
1536 ffrt_task_attr_set_delay(&task_attr, 5000); // 设置任务5ms后才执行
1537
1538 double t;
1539 auto start = std::chrono::high_resolution_clock::now();
1540 std::function<void()>&& OnePlusFunc = [&a]() { OnePlusForTest((void *)(&a)); };
1541 ffrt_task_handle_t task1 = ffrt_queue_submit_h(queue_handle,
1542 create_function_wrapper(OnePlusFunc, ffrt_function_kind_queue), &task_attr);
1543 ffrt_queue_wait(task1);
1544 auto end = std::chrono::high_resolution_clock::now();
1545 std::chrono::duration<double, std::micro> elapsed = end-start;
1546 t = elapsed.count();
1547 if (a != 1) {
1548 result = 1;
1549 }
1550 if (t <= 5000 || t >= 10000) {
1551 result = 2;
1552 }
1553 uint64_t delay = ffrt_task_attr_get_delay(&task_attr);
1554 if (delay != 5000) {
1555 result = 3;
1556 }
1557 ffrt_task_attr_destroy(&task_attr);
1558 ffrt_task_handle_destroy(task1);
1559 ffrt_queue_attr_destroy(&queue_attr);
1560 ffrt_queue_destroy(queue_handle);
1561 napi_value flag = nullptr;
1562 napi_create_double(env, result, &flag);
1563 return flag;
1564 }
1565
QueueDelayTest005(napi_env env,napi_callback_info info)1566 static napi_value QueueDelayTest005(napi_env env, napi_callback_info info)
1567 {
1568 int result = 0;
1569 // 等待delay任务时提交一个task可以快速调度
1570 ffrt_queue_attr_t queue_attr;
1571 (void)ffrt_queue_attr_init(&queue_attr);
1572 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1573
1574 int a = 0;
1575 ffrt_task_attr_t task_attr;
1576 (void)ffrt_task_attr_init(&task_attr);
1577 ffrt_task_attr_set_delay(&task_attr, 5000000);
1578 std::function<void()>&& MultipleFunc = [&a]() { MultipleForTest(static_cast<void*>(&a)); };
1579 ffrt_task_handle_t task1 = ffrt_queue_submit_h(queue_handle,
1580 create_function_wrapper(MultipleFunc, ffrt_function_kind_queue), &task_attr);
1581
1582 sleep(1);
1583 double t;
1584 auto start = std::chrono::high_resolution_clock::now();
1585 std::function<void()>&& OnePlusFunc = [&a]() { OnePlusForTest(static_cast<void*>(&a)); };
1586 ffrt_task_handle_t task2 = ffrt_queue_submit_h(queue_handle,
1587 create_function_wrapper(OnePlusFunc, ffrt_function_kind_queue), nullptr);
1588 ffrt_queue_wait(task2);
1589 auto end = std::chrono::high_resolution_clock::now();
1590 std::chrono::duration<double, std::milli> elapsed = end-start;
1591 t = elapsed.count();
1592 if (a != 1) {
1593 result = 1;
1594 }
1595 if (t >= 5) {
1596 result = 2;
1597 }
1598
1599 ffrt_queue_wait(task1);
1600 if (a != 10) {
1601 result = 3;
1602 }
1603 uint64_t delay = ffrt_task_attr_get_delay(&task_attr);
1604 if (delay != 5000000) {
1605 result = 4;
1606 }
1607 ffrt_task_attr_destroy(&task_attr);
1608 ffrt_task_handle_destroy(task1);
1609 ffrt_task_handle_destroy(task2);
1610
1611 // 销毁队列
1612 ffrt_queue_attr_destroy(&queue_attr);
1613 ffrt_queue_destroy(queue_handle);
1614 napi_value flag = nullptr;
1615 napi_create_double(env, result, &flag);
1616 return flag;
1617 }
1618
QueueDfxTest001(napi_env env,napi_callback_info info)1619 static napi_value QueueDfxTest001(napi_env env, napi_callback_info info)
1620 {
1621 int result = 0;
1622 // ffrt_queue_attr_set_timeout接口attr为异常值
1623 ffrt_queue_attr_t queue_attr;
1624 (void)ffrt_queue_attr_init(&queue_attr);
1625 ffrt_queue_attr_set_timeout(nullptr, 10000);
1626 uint64_t time = ffrt_queue_attr_get_timeout(&queue_attr);
1627 if (time != 0) {
1628 result = 1;
1629 }
1630 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1631 if (queue_handle == nullptr) {
1632 result = 2;
1633 }
1634 // 销毁队列
1635 ffrt_queue_attr_destroy(&queue_attr);
1636 ffrt_queue_destroy(queue_handle);
1637 napi_value flag = nullptr;
1638 napi_create_double(env, result, &flag);
1639 return flag;
1640 }
1641
QueueDfxTest002(napi_env env,napi_callback_info info)1642 static napi_value QueueDfxTest002(napi_env env, napi_callback_info info)
1643 {
1644 int result = 0;
1645 // ffrt_queue_attr_get_timeout接口attr为异常值
1646 ffrt_queue_attr_t queue_attr;
1647 (void)ffrt_queue_attr_init(&queue_attr);
1648 ffrt_queue_attr_set_timeout(&queue_attr, 10000);
1649 uint64_t time = ffrt_queue_attr_get_timeout(nullptr);
1650 if (time != 0) {
1651 result = 1;
1652 }
1653 time = ffrt_queue_attr_get_timeout(&queue_attr);
1654 if (time != 10000) {
1655 result = 2;
1656 }
1657 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1658 if (queue_handle == nullptr) {
1659 result = 3;
1660 }
1661
1662 // 销毁队列
1663 ffrt_queue_attr_destroy(&queue_attr);
1664 ffrt_queue_destroy(queue_handle);
1665 napi_value flag = nullptr;
1666 napi_create_double(env, result, &flag);
1667 return flag;
1668 }
1669
QueueDfxTest003(napi_env env,napi_callback_info info)1670 static napi_value QueueDfxTest003(napi_env env, napi_callback_info info)
1671 {
1672 int result = 0;
1673 // ffrt_queue_attr_set_callback接口attr为异常值
1674 int end = 0;
1675 std::function<void()> cbOne = [&end]() {
1676 end++;
1677 };
1678 ffrt_queue_attr_t queue_attr;
1679 (void)ffrt_queue_attr_init(&queue_attr);
1680 ffrt_queue_attr_set_callback(nullptr, create_function_wrapper(cbOne, ffrt_function_kind_queue));
1681 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1682 if (queue_handle == nullptr) {
1683 result = 3;
1684 }
1685
1686 // 销毁队列
1687 ffrt_queue_attr_destroy(&queue_attr);
1688 ffrt_queue_destroy(queue_handle);
1689 napi_value flag = nullptr;
1690 napi_create_double(env, result, &flag);
1691 return flag;
1692 }
1693
QueueDfxTest004(napi_env env,napi_callback_info info)1694 static napi_value QueueDfxTest004(napi_env env, napi_callback_info info)
1695 {
1696 int result = 0;
1697 int end = 0;
1698 std::function<void()> cbOne = [&end]() {
1699 end++;
1700 };
1701 ffrt_queue_attr_t queue_attr;
1702 (void)ffrt_queue_attr_init(&queue_attr);
1703 ffrt_queue_attr_set_callback(&queue_attr, create_function_wrapper(cbOne, ffrt_function_kind_queue));
1704 ffrt_function_header_t* func = ffrt_queue_attr_get_callback(nullptr);
1705 if (func != nullptr) {
1706 result = 1;
1707 }
1708 func = ffrt_queue_attr_get_callback(&queue_attr);
1709 if (func == nullptr) {
1710 result = 2;
1711 }
1712 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1713 if (queue_handle == nullptr) {
1714 result = 3;
1715 }
1716
1717 // 销毁队列
1718 ffrt_queue_destroy(queue_handle);
1719 ffrt_queue_attr_destroy(&queue_attr);
1720 napi_value flag = nullptr;
1721 napi_create_double(env, result, &flag);
1722 return flag;
1723 }
1724
QueueDfxTest005(napi_env env,napi_callback_info info)1725 static napi_value QueueDfxTest005(napi_env env, napi_callback_info info)
1726 {
1727 int resultEnd = 0;
1728 int x = 0;
1729 int end = 0;
1730 std::function<void()> cbOne = [&end]() {
1731 end++;
1732 };
1733 ffrt_queue_attr_t queue_attr;
1734 (void)ffrt_queue_attr_init(&queue_attr);
1735 ffrt_queue_attr_set_timeout(&queue_attr, 10000);
1736 ffrt_queue_attr_set_callback(&queue_attr, create_function_wrapper(cbOne, ffrt_function_kind_queue));
1737 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1738 std::function<void()>&& basicFunc1 = [&] {
1739 x++;
1740 usleep(500 * 1000);
1741 };
1742 ffrt_task_handle_t handle = ffrt_queue_submit_h(queue_handle,
1743 create_function_wrapper(basicFunc1, ffrt_function_kind_queue), nullptr);
1744 ffrt_queue_wait(handle);
1745 if (x != 1) {
1746 resultEnd = 1;
1747 }
1748 if (end != 1) {
1749 resultEnd = 2;
1750 }
1751
1752 std::function<void()>&& basicFunc2 = [&] {
1753 x++;
1754 ffrt_usleep(500 * 1000);
1755 };
1756 ffrt_task_handle_t handle1 = ffrt_queue_submit_h(queue_handle,
1757 create_function_wrapper(basicFunc2, ffrt_function_kind_queue), nullptr);
1758 ffrt_queue_wait(handle1);
1759 if (x != 2) {
1760 resultEnd = 3;
1761 }
1762 if (end != 2) {
1763 resultEnd = 4;
1764 }
1765
1766 ffrt_task_handle_destroy(handle);
1767 ffrt_task_handle_destroy(handle1);
1768 ffrt_queue_attr_destroy(&queue_attr);
1769 ffrt_queue_destroy(queue_handle);
1770 napi_value flag = nullptr;
1771 napi_create_double(env, resultEnd, &flag);
1772 return flag;
1773 }
1774
QueueDfxTest006(napi_env env,napi_callback_info info)1775 static napi_value QueueDfxTest006(napi_env env, napi_callback_info info)
1776 {
1777 int resultEnd = 0;
1778 int x = 0;
1779 int end = 0;
1780 std::function<void()> cbOne = [&end]() {
1781 end++;
1782 };
1783 ffrt_queue_attr_t queue_attr;
1784 (void)ffrt_queue_attr_init(&queue_attr);
1785 ffrt_queue_attr_set_timeout(&queue_attr, 10000);
1786 ffrt_queue_attr_set_callback(&queue_attr, create_function_wrapper(cbOne, ffrt_function_kind_queue));
1787 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1788
1789 ffrt_task_handle_t handle[5];
1790 std::function<void()>&& basicFunc = [&] {
1791 x++;
1792 };
1793 for (int i = 0; i < 5; ++i) {
1794 handle[i] = ffrt_queue_submit_h(queue_handle,
1795 create_function_wrapper(basicFunc, ffrt_function_kind_queue), nullptr);
1796 }
1797 ffrt_queue_wait(handle[4]);
1798 if (x != 5) {
1799 resultEnd = 1;
1800 }
1801 if (end != 0) {
1802 resultEnd = 2;
1803 }
1804 for (int i = 0; i < 5; i++) {
1805 ffrt_task_handle_destroy(handle[i]);
1806 }
1807 ffrt_queue_attr_destroy(&queue_attr);
1808 ffrt_queue_destroy(queue_handle);
1809 napi_value flag = nullptr;
1810 napi_create_double(env, resultEnd, &flag);
1811 return flag;
1812 }
1813
QueueTest001(napi_env env,napi_callback_info info)1814 static napi_value QueueTest001(napi_env env, napi_callback_info info)
1815 {
1816 ffrt_queue_attr_t queue_attr;
1817 (void)ffrt_queue_attr_init(&queue_attr);
1818 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1819 int result = 0;
1820 ffrt_queue_submit(queue_handle, ffrt_create_function_wrapper(OnePlusForTest, nullptr, &result,
1821 ffrt_function_kind_queue), nullptr);
1822 ffrt_queue_submit(queue_handle, ffrt_create_function_wrapper(MultipleForTest, nullptr, &result,
1823 ffrt_function_kind_queue), nullptr);
1824 ffrt_queue_submit(queue_handle, ffrt_create_function_wrapper(SubForTest, nullptr, &result,
1825 ffrt_function_kind_queue), nullptr);
1826 napi_value flag = nullptr;
1827 sleep(2);
1828 napi_create_double(env, result, &flag);
1829 ffrt_queue_attr_destroy(&queue_attr);
1830 ffrt_queue_destroy(queue_handle);
1831 return flag;
1832 }
1833
QueueTest002(napi_env env,napi_callback_info info)1834 static napi_value QueueTest002(napi_env env, napi_callback_info info)
1835 {
1836 const int maxNum = (int)ffrt_qos_user_initiated + 1;
1837 ffrt_queue_attr_t queue_attr[maxNum];
1838 ffrt_queue_t queue_handle[maxNum];
1839 for (int num = 0; num < maxNum; num++) {
1840 (void)ffrt_queue_attr_init(&queue_attr[num]);
1841 ffrt_queue_attr_set_qos(&queue_attr[num], num);
1842 queue_handle[num] = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr[num]);
1843 }
1844
1845 int a = 0;
1846 int result[maxNum] = {0};
1847 ffrt_task_handle_t task[maxNum][10];
1848 for (int i = 0; i < 10; i++) {
1849 for (int num = 0; num < maxNum; num++) {
1850 task[num][i] = ffrt_queue_submit_h(queue_handle[num],
1851 ffrt_create_function_wrapper(OnePlusForTest, NULL, &result[num], ffrt_function_kind_queue), nullptr);
1852 }
1853 }
1854 for (int num = 0; num < maxNum; num++) {
1855 ffrt_queue_wait(task[num][9]);
1856 HiLogPrint(LOG_APP, LOG_INFO, 1, "FFRT QUEUE", "result in queue %{public}d is %{public}d", num, result[num]);
1857 if (result[num] != 10) {
1858 a = 1;
1859 }
1860 }
1861 for (int i = 0; i < 10; i++) {
1862 for (int num = 0; num < maxNum; num++) {
1863 ffrt_task_handle_destroy(task[num][i]);
1864 }
1865 }
1866 for (int num = 0; num < maxNum; num++) {
1867 HiLogPrint(LOG_APP, LOG_INFO, 1, "FFRT QUEUE", "qos in queue task %{public}d is %{public}d", num,
1868 ffrt_queue_attr_get_qos(&queue_attr[num]));
1869 if (ffrt_queue_attr_get_qos(&queue_attr[num]) != num) {
1870 a = 1;
1871 }
1872 ffrt_queue_attr_destroy(&queue_attr[num]);
1873 ffrt_queue_destroy(queue_handle[num]);
1874 }
1875 napi_value flag = nullptr;
1876 napi_create_double(env, a, &flag);
1877 return flag;
1878 }
1879
QueueTest003(napi_env env,napi_callback_info info)1880 static napi_value QueueTest003(napi_env env, napi_callback_info info)
1881 {
1882 int resultEnd = 0;
1883 // 创建多个相同qos队列，分别调度执行task
1884 ffrt_queue_attr_t queue_attr;
1885 (void)ffrt_queue_attr_init(&queue_attr);
1886 ffrt_queue_t queue_handle[10];
1887 for (int num = 0; num < 10; num++) {
1888 queue_handle[num] = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1889 }
1890
1891 int result[10] = {0};
1892 void *addr;
1893 ffrt_task_handle_t task[10][10];
1894 for (int i = 0; i < 10; i++) {
1895 for (int num = 0; num < 10; num++) {
1896 addr = static_cast<void *>(&result[num]);
1897 std::function<void()> basicFunc = [=]() { OnePlusForTest(addr); };
1898 task[num][i] = ffrt_queue_submit_h(queue_handle[num],
1899 create_function_wrapper(basicFunc, ffrt_function_kind_queue), nullptr);
1900 }
1901 }
1902 for (int num = 0; num < 10; num++) {
1903 ffrt_queue_wait(task[num][9]);
1904 if (result[num] != 10) {
1905 resultEnd = num + 1;
1906 }
1907 }
1908
1909 for (int i = 0; i < 10; i++) {
1910 for (int num = 0; num < 10; num++) {
1911 ffrt_task_handle_destroy(task[num][i]);
1912 }
1913 }
1914
1915 ffrt_queue_attr_destroy(&queue_attr);
1916 for (int num = 0; num < 10; num++) {
1917 ffrt_queue_destroy(queue_handle[num]);
1918 }
1919 napi_value flag = nullptr;
1920 napi_create_double(env, resultEnd, &flag);
1921 return flag;
1922 }
1923
QueueWaitTest001(napi_env env,napi_callback_info info)1924 static napi_value QueueWaitTest001(napi_env env, napi_callback_info info)
1925 {
1926 int result = 0;
1927 // wait一个delay的未执行task
1928 ffrt_queue_attr_t queue_attr;
1929 (void)ffrt_queue_attr_init(&queue_attr);
1930 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
1931
1932 int a = 0;
1933 ffrt_task_attr_t task_attr;
1934 (void)ffrt_task_attr_init(&task_attr);
1935 ffrt_task_attr_set_delay(&task_attr, 1000000);
1936 std::function<void()>&& OnePlusFunc = [&a]() { OnePlusForTest(static_cast<void*>(&a)); };
1937 ffrt_task_handle_t task1 = ffrt_queue_submit_h(queue_handle,
1938 create_function_wrapper(OnePlusFunc, ffrt_function_kind_queue), &task_attr);
1939
1940 ffrt_queue_wait(task1);
1941 if (a != 1) {
1942 result = 1;
1943 }
1944
1945 ffrt_task_attr_destroy(&task_attr);
1946 ffrt_task_handle_destroy(task1);
1947
1948 // 销毁队列
1949 ffrt_queue_attr_destroy(&queue_attr);
1950 ffrt_queue_destroy(queue_handle);
1951 napi_value flag = nullptr;
1952 napi_create_double(env, result, &flag);
1953 return flag;
1954 }
1955
SubmitAbnormalTest(napi_env env,napi_callback_info info)1956 static napi_value SubmitAbnormalTest(napi_env env, napi_callback_info info)
1957 {
1958 int result = 0;
1959 int x = 0;
1960 std::function<void()>&& func = [&]() { x = x + 1;};
1961 const std::vector<ffrt_dependence_t> in_deps = {{ffrt_dependence_data, &x}};
1962 ffrt_deps_t in{static_cast<uint32_t>(in_deps.size()), in_deps.data()};
1963 const std::vector<ffrt_dependence_t> out_deps = {{ffrt_dependence_data, &x}};
1964 ffrt_deps_t out{static_cast<uint32_t>(out_deps.size()), out_deps.data()};
1965 ffrt_function_header_t* ffrt_header_t = create_function_wrapper((func));
1966
1967 ffrt_submit_base(nullptr, &in, &out, nullptr);
1968 ffrt_submit_h_base(nullptr, &in, &out, nullptr);
1969 ffrt_task_handle_destroy(nullptr);
1970 ffrt_submit_base(ffrt_header_t, &in, &out, nullptr);
1971 ffrt_wait();
1972 if (x != 1) {
1973 result = 1;
1974 }
1975 napi_value flag = nullptr;
1976 napi_create_double(env, result, &flag);
1977 return flag;
1978 }
1979
SubmitBasicTest001(napi_env env,napi_callback_info info)1980 static napi_value SubmitBasicTest001(napi_env env, napi_callback_info info)
1981 {
1982 int result = 0;
1983 int x = 0;
1984 std::function<void()>&& func = [&]() { x = x + 1;};
1985 const std::vector<ffrt_dependence_t> in_deps = {{ffrt_dependence_data, &x}};
1986 ffrt_deps_t in{static_cast<uint32_t>(in_deps.size()), in_deps.data()};
1987 const std::vector<ffrt_dependence_t> out_deps = {{ffrt_dependence_data, &x}};
1988 ffrt_deps_t out{static_cast<uint32_t>(out_deps.size()), out_deps.data()};
1989 ffrt_function_header_t* ffrt_header_t = create_function_wrapper((func));
1990 ffrt_submit_base(ffrt_header_t, &in, &out, nullptr);
1991 ffrt_wait();
1992 if (x != 1) {
1993 result = 1;
1994 }
1995 napi_value flag = nullptr;
1996 napi_create_double(env, result, &flag);
1997 return flag;
1998 }
1999
SubmitBasicTest002(napi_env env,napi_callback_info info)2000 static napi_value SubmitBasicTest002(napi_env env, napi_callback_info info)
2001 {
2002 int result = 0;
2003 const uint32_t sleepTime = 5 * 1000;
2004 int a = 0;
2005 ffrt_task_attr_t attr;
2006 ffrt_task_attr_init(&attr);
2007 ffrt_submit_base(ffrt_create_function_wrapper(OnePlusForTest, NULL, &a), NULL, NULL, &attr);
2008 ffrt_wait();
2009 usleep(sleepTime);
2010 if (a != 1) {
2011 result = 3;
2012 }
2013 ffrt_task_attr_destroy(&attr);
2014 napi_value flag = nullptr;
2015 napi_create_double(env, result, &flag);
2016 return flag;
2017 }
2018
SubmitInDependEmptyTest(napi_env env,napi_callback_info info)2019 static napi_value SubmitInDependEmptyTest(napi_env env, napi_callback_info info)
2020 {
2021 int result = 0;
2022 const uint32_t sleepTime = 10 * 1000;
2023 int x = 0;
2024 int y = 0;
2025 std::function<void()>&& basic1Func = [&]() {
2026 x = x + 1;
2027 usleep(sleepTime);
2028 };
2029 std::function<void()>&& basic2Func = [&]() {
2030 y = y + 1;
2031 usleep(sleepTime);
2032 };
2033 ffrt_task_attr_t attr1;
2034 ffrt_task_attr_init(&attr1);
2035 ffrt_task_attr_set_qos(&attr1, static_cast<int>(ffrt_qos_background));
2036 ffrt_task_attr_t attr2;
2037 ffrt_task_attr_init(&attr2);
2038 ffrt_task_attr_set_qos(&attr2, static_cast<int>(ffrt_qos_utility));
2039 ffrt_function_header_t* basic1Func_ht = create_function_wrapper((basic1Func));
2040 ffrt_function_header_t* basic2Func_ht = create_function_wrapper((basic2Func));
2041 const std::vector<ffrt_dependence_t> in1_deps = {};
2042 ffrt_deps_t in1{static_cast<uint32_t>(in1_deps.size()), in1_deps.data()};
2043 const std::vector<ffrt_dependence_t> in2_deps = {};
2044 ffrt_deps_t in2{static_cast<uint32_t>(in2_deps.size()), in2_deps.data()};
2045 ffrt_submit_base(basic1Func_ht, &in1, nullptr, &attr1);
2046 ffrt_submit_base(basic2Func_ht, &in2, nullptr, &attr2);
2047 ffrt_wait();
2048 if (x != 1) {
2049 result = 1;
2050 }
2051 if (y != 1) {
2052 result = 2;
2053 }
2054 ffrt_task_attr_destroy(&attr1);
2055 ffrt_task_attr_destroy(&attr2);
2056 napi_value flag = nullptr;
2057 napi_create_double(env, result, &flag);
2058 return flag;
2059 }
2060
SubmitInDependNullptrTest(napi_env env,napi_callback_info info)2061 static napi_value SubmitInDependNullptrTest(napi_env env, napi_callback_info info)
2062 {
2063 int result = 0;
2064 const uint32_t sleepTime = 10 * 1000;
2065 int x = 0;
2066 int y = 0;
2067 std::function<void()>&& basic1Func = [&]() {
2068 x = x + 1;
2069 usleep(sleepTime);
2070 };
2071 std::function<void()>&& basic2Func = [&]() {
2072 y = y + 1;
2073 usleep(sleepTime);
2074 };
2075 ffrt_function_header_t* basic1Func_ht = create_function_wrapper((basic1Func));
2076 ffrt_function_header_t* basic2Func_ht = create_function_wrapper((basic2Func));
2077 const std::vector<ffrt_dependence_t> in1_deps = {{ffrt_dependence_data, NULL}};
2078 ffrt_deps_t in1{static_cast<uint32_t>(in1_deps.size()), in1_deps.data()};
2079 const std::vector<ffrt_dependence_t> in2_deps = {{ffrt_dependence_data, NULL}};
2080 ffrt_deps_t in2{static_cast<uint32_t>(in2_deps.size()), in2_deps.data()};
2081 ffrt_submit_base(basic1Func_ht, &in1, nullptr, nullptr);
2082 ffrt_submit_base(basic2Func_ht, &in2, nullptr, nullptr);
2083 ffrt_wait();
2084 if (x != 1) {
2085 result = 1;
2086 }
2087 if (y != 1) {
2088 result = 2;
2089 }
2090 napi_value flag = nullptr;
2091 napi_create_double(env, result, &flag);
2092 return flag;
2093 }
2094
SubmitOuDependEmptyTest(napi_env env,napi_callback_info info)2095 static napi_value SubmitOuDependEmptyTest(napi_env env, napi_callback_info info)
2096 {
2097 int result = 0;
2098 const uint32_t sleepTime = 10 * 1000;
2099 int x = 0;
2100 int y = 0;
2101 std::function<void()>&& basic1Func = [&]() {
2102 x = x + 1;
2103 usleep(sleepTime);
2104 };
2105 std::function<void()>&& basic2Func = [&]() {
2106 y = y + 1;
2107 usleep(sleepTime);
2108 };
2109 ffrt_function_header_t* basic1Func_ht = create_function_wrapper((basic1Func));
2110 ffrt_function_header_t* basic2Func_ht = create_function_wrapper((basic2Func));
2111 const std::vector<ffrt_dependence_t> in1_deps = {};
2112 ffrt_deps_t in1{static_cast<uint32_t>(in1_deps.size()), in1_deps.data()};
2113 const std::vector<ffrt_dependence_t> in2_deps = {};
2114 ffrt_deps_t in2{static_cast<uint32_t>(in2_deps.size()), in2_deps.data()};
2115 const std::vector<ffrt_dependence_t> ou1_deps = {};
2116 ffrt_deps_t ou1{static_cast<uint32_t>(ou1_deps.size()), ou1_deps.data()};
2117 const std::vector<ffrt_dependence_t> ou2_deps = {};
2118 ffrt_deps_t ou2{static_cast<uint32_t>(ou2_deps.size()), ou2_deps.data()};
2119 ffrt_submit_base(basic1Func_ht, &in1, &ou1, nullptr);
2120 ffrt_submit_base(basic2Func_ht, &in2, &ou2, nullptr);
2121 ffrt_wait();
2122 if (x != 1) {
2123 result = 1;
2124 }
2125 if (y != 1) {
2126 result = 2;
2127 }
2128 napi_value flag = nullptr;
2129 napi_create_double(env, result, &flag);
2130 return flag;
2131 }
2132
SubmitOuDependNullptrTest(napi_env env,napi_callback_info info)2133 static napi_value SubmitOuDependNullptrTest(napi_env env, napi_callback_info info)
2134 {
2135 int result = 0;
2136 const uint32_t sleepTime = 10 * 1000;
2137 int x = 0;
2138 int y = 0;
2139 std::function<void()>&& basic1Func = [&]() {
2140 x = x + 1;
2141 usleep(sleepTime);
2142 if (y != 0) {
2143 result = 1;
2144 }
2145 };
2146 std::function<void()>&& basic2Func = [&]() {
2147 y = y + 1;
2148 usleep(sleepTime);
2149 if (x != 1) {
2150 result = 2;
2151 }
2152 };
2153 ffrt_function_header_t* basic1Func_ht = create_function_wrapper((basic1Func));
2154 ffrt_function_header_t* basic2Func_ht = create_function_wrapper((basic2Func));
2155 const std::vector<ffrt_dependence_t> ou1_deps = {{ffrt_dependence_data, NULL}};
2156 ffrt_deps_t ou1{static_cast<uint32_t>(ou1_deps.size()), ou1_deps.data()};
2157 const std::vector<ffrt_dependence_t> ou2_deps = {{ffrt_dependence_data, NULL}};
2158 ffrt_deps_t ou2{static_cast<uint32_t>(ou2_deps.size()), ou2_deps.data()};
2159 ffrt_submit_base(basic1Func_ht, nullptr, &ou1, nullptr);
2160 ffrt_submit_base(basic2Func_ht, nullptr, &ou2, nullptr);
2161 ffrt_wait();
2162 if (x != 1) {
2163 result = 3;
2164 }
2165 if (y != 1) {
2166 result = 4;
2167 }
2168 napi_value flag = nullptr;
2169 napi_create_double(env, result, &flag);
2170 return flag;
2171 }
2172
SubmitIODependTest001(napi_env env,napi_callback_info info)2173 static napi_value SubmitIODependTest001(napi_env env, napi_callback_info info)
2174 {
2175 int result = 0;
2176 int x = 0;
2177 int y = 0;
2178 int z = 0;
2179 std::function<void()>&& basic1Func = [&]() {
2180 ffrt_usleep(10 * 1000);
2181 x = x + 1;
2182 };
2183 std::function<void()>&& basic2Func = [&]() {
2184 ffrt_usleep(5 * 1000);
2185 y = y + 1;
2186 };
2187 std::function<void()>&& basic3Func = [&]() {
2188 z = x + y;
2189 };
2190 const std::vector<ffrt_dependence_t> in3_deps = {{ffrt_dependence_data, &x}, {ffrt_dependence_data, &y}};
2191 ffrt_deps_t in3{static_cast<uint32_t>(in3_deps.size()), in3_deps.data()};
2192 const std::vector<ffrt_dependence_t> ou1_deps = {{ffrt_dependence_data, &x}};
2193 ffrt_deps_t ou1{static_cast<uint32_t>(ou1_deps.size()), ou1_deps.data()};
2194 const std::vector<ffrt_dependence_t> ou2_deps = {{ffrt_dependence_data, &y}};
2195 ffrt_deps_t ou2{static_cast<uint32_t>(ou2_deps.size()), ou2_deps.data()};
2196 const std::vector<ffrt_dependence_t> ou3_deps = {{ffrt_dependence_data, &z}};
2197 ffrt_deps_t ou3{static_cast<uint32_t>(ou3_deps.size()), ou3_deps.data()};
2198 ffrt_submit_base(create_function_wrapper(basic1Func), nullptr, &ou1, nullptr);
2199 ffrt_submit_base(create_function_wrapper(basic2Func), nullptr, &ou2, nullptr);
2200 ffrt_submit_base(create_function_wrapper(basic3Func), &in3, &ou3, nullptr);
2201 ffrt_wait();
2202 if (z != 2) {
2203 result = 1;
2204 }
2205 napi_value flag = nullptr;
2206 napi_create_double(env, result, &flag);
2207 return flag;
2208 }
2209
SubmitIODependTest002(napi_env env,napi_callback_info info)2210 static napi_value SubmitIODependTest002(napi_env env, napi_callback_info info)
2211 {
2212 int result = 0;
2213 int x = 0;
2214 int y = 0;
2215 int z = 0;
2216 int t = 0;
2217 std::function<void()>&& basic1Func = [&]() {
2218 usleep(10 * 1000);
2219 x = x + 1;
2220 y = y + 1;
2221 };
2222 std::function<void()>&& basic2Func = [&]() {
2223 z = x * 5;
2224 };
2225 std::function<void()>&& basic3Func = [&]() {
2226 t = y * 10;
2227 };
2228 const std::vector<ffrt_dependence_t> in2_deps = {{ffrt_dependence_data, &x}};
2229 ffrt_deps_t in2{static_cast<uint32_t>(in2_deps.size()), in2_deps.data()};
2230 const std::vector<ffrt_dependence_t> in3_deps = {{ffrt_dependence_data, &y}};
2231 ffrt_deps_t in3{static_cast<uint32_t>(in3_deps.size()), in3_deps.data()};
2232 const std::vector<ffrt_dependence_t> ou1_deps = {{ffrt_dependence_data, &x}, {ffrt_dependence_data, &y}};
2233 ffrt_deps_t ou1{static_cast<uint32_t>(ou1_deps.size()), ou1_deps.data()};
2234 const std::vector<ffrt_dependence_t> ou2_deps = {{ffrt_dependence_data, &z}};
2235 ffrt_deps_t ou2{static_cast<uint32_t>(ou2_deps.size()), ou2_deps.data()};
2236 const std::vector<ffrt_dependence_t> ou3_deps = {{ffrt_dependence_data, &t}};
2237 ffrt_deps_t ou3{static_cast<uint32_t>(ou3_deps.size()), ou3_deps.data()};
2238 ffrt_submit_base(create_function_wrapper(basic1Func), nullptr, &ou1, nullptr);
2239 ffrt_submit_base(create_function_wrapper(basic2Func), &in2, &ou2, nullptr);
2240 ffrt_submit_base(create_function_wrapper(basic3Func), &in3, &ou3, nullptr);
2241 ffrt_wait();
2242 if (z != 5) {
2243 result = 1;
2244 }
2245 if (t != 10) {
2246 result = 2;
2247 }
2248 napi_value flag = nullptr;
2249 napi_create_double(env, result, &flag);
2250 return flag;
2251 }
2252
SubmitHIODependTest001(napi_env env,napi_callback_info info)2253 static napi_value SubmitHIODependTest001(napi_env env, napi_callback_info info)
2254 {
2255 int result = 0;
2256 int x = 0;
2257 int y = 0;
2258 int z = 0;
2259 std::function<void()>&& basic1Func = [&]() {
2260 ffrt_usleep(10 * 1000);
2261 x = x + 1;
2262 };
2263 std::function<void()>&& basic2Func = [&]() {
2264 ffrt_usleep(5 * 1000);
2265 y = y + 1;
2266 };
2267 std::function<void()>&& basic3Func = [&]() {
2268 z = x + y;
2269 };
2270 const std::vector<ffrt_dependence_t> in3_deps = {
2271 {ffrt_dependence_data, &x}, {ffrt_dependence_data, &y}};
2272 ffrt_deps_t in3{static_cast<uint32_t>(in3_deps.size()), in3_deps.data()};
2273 const std::vector<ffrt_dependence_t> ou1_deps = {{ffrt_dependence_data, &x}};
2274 ffrt_deps_t ou1{static_cast<uint32_t>(ou1_deps.size()), ou1_deps.data()};
2275 const std::vector<ffrt_dependence_t> ou2_deps = {{ffrt_dependence_data, &y}};
2276 ffrt_deps_t ou2{static_cast<uint32_t>(ou2_deps.size()), ou2_deps.data()};
2277 const std::vector<ffrt_dependence_t> ou3_deps = {{ffrt_dependence_data, &z}};
2278 ffrt_deps_t ou3{static_cast<uint32_t>(ou3_deps.size()), ou3_deps.data()};
2279 ffrt_task_handle_t task1 = ffrt_submit_h_base(
2280 create_function_wrapper(basic1Func), nullptr, &ou1, nullptr);
2281 ffrt_task_handle_t task2 = ffrt_submit_h_base(
2282 create_function_wrapper(basic2Func), nullptr, &ou2, nullptr);
2283 ffrt_task_handle_t task3 = ffrt_submit_h_base(
2284 create_function_wrapper(basic3Func), &in3, &ou3, nullptr);
2285 const std::vector<ffrt_dependence_t> wait_deps = {{ffrt_dependence_task, task3}};
2286 ffrt_deps_t wait{static_cast<uint32_t>(wait_deps.size()), wait_deps.data()};
2287 ffrt_wait_deps(&wait);
2288 if (z != 2) {
2289 result = 1;
2290 }
2291 ffrt_task_handle_destroy(task1);
2292 ffrt_task_handle_destroy(task2);
2293 ffrt_task_handle_destroy(task3);
2294 napi_value flag = nullptr;
2295 napi_create_double(env, result, &flag);
2296 return flag;
2297 }
2298
SubmitHIODependTest002(napi_env env,napi_callback_info info)2299 static napi_value SubmitHIODependTest002(napi_env env, napi_callback_info info)
2300 {
2301 int result = 0;
2302 int x = 0;
2303 int y = 0;
2304 int z = 0;
2305 int t = 0;
2306 std::function<void()>&& basic1Func = [&]() {
2307 usleep(10 * 1000);
2308 x = x + 1;
2309 y = y + 1;
2310 };
2311 std::function<void()>&& basic2Func = [&]() {
2312 z = x * 5;
2313 };
2314 std::function<void()>&& basic3Func = [&]() {
2315 t = y * 10;
2316 };
2317 const std::vector<ffrt_dependence_t> in2_deps = {{ffrt_dependence_data, &x}};
2318 ffrt_deps_t in2{static_cast<uint32_t>(in2_deps.size()), in2_deps.data()};
2319 const std::vector<ffrt_dependence_t> in3_deps = {{ffrt_dependence_data, &y}};
2320 ffrt_deps_t in3{static_cast<uint32_t>(in3_deps.size()), in3_deps.data()};
2321 const std::vector<ffrt_dependence_t> ou1_deps = {{ffrt_dependence_data, &x}, {ffrt_dependence_data, &y}};
2322 ffrt_deps_t ou1{static_cast<uint32_t>(ou1_deps.size()), ou1_deps.data()};
2323 const std::vector<ffrt_dependence_t> ou2_deps = {{ffrt_dependence_data, &z}};
2324 ffrt_deps_t ou2{static_cast<uint32_t>(ou2_deps.size()), ou2_deps.data()};
2325 const std::vector<ffrt_dependence_t> ou3_deps = {{ffrt_dependence_data, &t}};
2326 ffrt_deps_t ou3{static_cast<uint32_t>(ou3_deps.size()), ou3_deps.data()};
2327 ffrt_task_handle_t task1 = ffrt_submit_h_base(create_function_wrapper(basic1Func), nullptr, &ou1, nullptr);
2328 ffrt_task_handle_t task2 = ffrt_submit_h_base(create_function_wrapper(basic2Func), &in2, &ou2, nullptr);
2329 ffrt_task_handle_t task3 = ffrt_submit_h_base(create_function_wrapper(basic3Func), &in3, &ou3, nullptr);
2330 const std::vector<ffrt_dependence_t> wait2_deps = {{ffrt_dependence_task, task2}};
2331 ffrt_deps_t wait2{static_cast<uint32_t>(wait2_deps.size()), wait2_deps.data()};
2332 ffrt_wait_deps(&wait2);
2333 if (z != 5) {
2334 result = 1;
2335 }
2336 const std::vector<ffrt_dependence_t> wait3_deps = {{ffrt_dependence_task, task3}};
2337 ffrt_deps_t wait3{static_cast<uint32_t>(wait3_deps.size()), wait3_deps.data()};
2338 ffrt_wait_deps(&wait3);
2339 if (t != 10) {
2340 result = 2;
2341 }
2342 ffrt_task_handle_destroy(task1);
2343 ffrt_task_handle_destroy(task2);
2344 ffrt_task_handle_destroy(task3);
2345 napi_value flag = nullptr;
2346 napi_create_double(env, result, &flag);
2347 return flag;
2348 }
2349
SubmitIn0Ou0WaitNullTask1Test(napi_env env,napi_callback_info info)2350 static napi_value SubmitIn0Ou0WaitNullTask1Test(napi_env env, napi_callback_info info)
2351 {
2352 int result = 0;
2353 const uint32_t sleepTime = 30 * 1000;
2354 int x = 0;
2355 ffrt_task_attr_t attr;
2356 ffrt_task_attr_init(&attr);
2357 std::function<void()>&& basicFunc = [&]() {
2358 if (x != 0) {
2359 result = 1;
2360 }
2361 usleep(sleepTime);
2362 x = x + 1;
2363 };
2364 ffrt_function_header_t* basicFunc_ht = create_function_wrapper((basicFunc));
2365 const std::vector<ffrt_dependence_t> in_deps = {};
2366 ffrt_deps_t in{static_cast<uint32_t>(in_deps.size()), in_deps.data()};
2367 const std::vector<ffrt_dependence_t> ou_deps = {};
2368 ffrt_deps_t ou{static_cast<uint32_t>(ou_deps.size()), ou_deps.data()};
2369 const std::vector<ffrt_dependence_t> wait_deps = {};
2370 ffrt_deps_t wait{static_cast<uint32_t>(wait_deps.size()), wait_deps.data()};
2371 const ffrt_deps_t *wait_null = nullptr;
2372 ffrt_submit_base(basicFunc_ht, &in, &ou, &attr);
2373 if (x != 0) {
2374 result = 2;
2375 }
2376 ffrt_wait_deps(wait_null);
2377 if (x != 0) {
2378 result = 3;
2379 }
2380 ffrt_wait_deps(&wait);
2381 if (x != 0) {
2382 result = 4;
2383 }
2384 ffrt_wait();
2385 if (x != 1) {
2386 result = 5;
2387 }
2388 ffrt_task_attr_destroy(&attr);
2389 napi_value flag = nullptr;
2390 napi_create_double(env, result, &flag);
2391 return flag;
2392 }
2393
SubmitHBasicTest001(napi_env env,napi_callback_info info)2394 static napi_value SubmitHBasicTest001(napi_env env, napi_callback_info info)
2395 {
2396 int result = 0;
2397 int x = 0;
2398 std::function<void()>&& func = [&]() { x = x + 1;};
2399 const std::vector<ffrt_dependence_t> in_deps = {{ffrt_dependence_data, &x}};
2400 ffrt_deps_t in{static_cast<uint32_t>(in_deps.size()), in_deps.data()};
2401 const std::vector<ffrt_dependence_t> out_deps = {{ffrt_dependence_data, &x}};
2402 ffrt_deps_t out{static_cast<uint32_t>(out_deps.size()), out_deps.data()};
2403 ffrt_function_header_t* ffrt_header_t = create_function_wrapper((func));
2404 ffrt_task_handle_t task = ffrt_submit_h_base(ffrt_header_t, &in, &out, nullptr);
2405 const std::vector<ffrt_dependence_t> wait_deps = {{ffrt_dependence_data, &x}};
2406 ffrt_deps_t wait{static_cast<uint32_t>(wait_deps.size()), wait_deps.data()};
2407 ffrt_wait_deps(&wait);
2408 if (x != 1) {
2409 result = 1;
2410 }
2411 ffrt_task_handle_destroy(task);
2412 napi_value flag = nullptr;
2413 napi_create_double(env, result, &flag);
2414 return flag;
2415 }
2416
SubmitHBasicTest002(napi_env env,napi_callback_info info)2417 static napi_value SubmitHBasicTest002(napi_env env, napi_callback_info info)
2418 {
2419 int result = 0;
2420 const uint32_t sleepTime = 5 * 1000;
2421 int a = 0;
2422 ffrt_task_attr_t attr;
2423 ffrt_task_attr_init(&attr);
2424 ffrt_task_handle_t task = ffrt_submit_h_base(
2425 ffrt_create_function_wrapper(OnePlusForTest, NULL, &a), NULL, NULL, &attr);
2426 const std::vector<ffrt_dependence_t> wait_deps = {{ffrt_dependence_task, task}};
2427 ffrt_deps_t wait{static_cast<uint32_t>(wait_deps.size()), wait_deps.data()};
2428 ffrt_wait_deps(&wait);
2429 usleep(sleepTime);
2430 if (a != 1) {
2431 result = 3;
2432 }
2433 ffrt_task_attr_destroy(&attr);
2434 ffrt_task_handle_destroy(task);
2435 napi_value flag = nullptr;
2436 napi_create_double(env, result, &flag);
2437 return flag;
2438 }
2439
SubmitHInDependEmptyTest(napi_env env,napi_callback_info info)2440 static napi_value SubmitHInDependEmptyTest(napi_env env, napi_callback_info info)
2441 {
2442 int result = 0;
2443 const uint32_t sleepTime = 10 * 1000;
2444 int x = 0;
2445 int y = 0;
2446 std::function<void()>&& basic1Func = [&]() {
2447 x = x + 1;
2448 usleep(sleepTime);
2449 };
2450 std::function<void()>&& basic2Func = [&]() {
2451 y = y + 1;
2452 usleep(sleepTime);
2453 };
2454 ffrt_task_attr_t attr1;
2455 ffrt_task_attr_init(&attr1);
2456 ffrt_task_attr_set_qos(&attr1, static_cast<int>(ffrt_qos_background));
2457 ffrt_task_attr_t attr2;
2458 ffrt_task_attr_init(&attr2);
2459 ffrt_task_attr_set_qos(&attr2, static_cast<int>(ffrt_qos_utility));
2460 ffrt_function_header_t* basic1Func_ht = create_function_wrapper((basic1Func));
2461 ffrt_function_header_t* basic2Func_ht = create_function_wrapper((basic2Func));
2462 const std::vector<ffrt_dependence_t> in1_deps = {};
2463 ffrt_deps_t in1{static_cast<uint32_t>(in1_deps.size()), in1_deps.data()};
2464 const std::vector<ffrt_dependence_t> in2_deps = {};
2465 ffrt_deps_t in2{static_cast<uint32_t>(in2_deps.size()), in2_deps.data()};
2466 ffrt_task_handle_t task1 = ffrt_submit_h_base(basic1Func_ht, &in1, nullptr, &attr1);
2467 ffrt_task_handle_t task2 = ffrt_submit_h_base(basic2Func_ht, &in2, nullptr, &attr2);
2468 const std::vector<ffrt_dependence_t> wait_deps1 = {{ffrt_dependence_task, task1}};
2469 ffrt_deps_t wait1{static_cast<uint32_t>(wait_deps1.size()), wait_deps1.data()};
2470 const std::vector<ffrt_dependence_t> wait_deps2 = {{ffrt_dependence_task, task2}};
2471 ffrt_deps_t wait2{static_cast<uint32_t>(wait_deps2.size()), wait_deps2.data()};
2472 ffrt_wait_deps(&wait1);
2473 if (x != 1) {
2474 result = 1;
2475 }
2476 ffrt_wait_deps(&wait2);
2477 if (y != 1) {
2478 result = 2;
2479 }
2480 ffrt_task_attr_destroy(&attr1);
2481 ffrt_task_attr_destroy(&attr2);
2482 ffrt_task_handle_destroy(task1);
2483 ffrt_task_handle_destroy(task2);
2484 napi_value flag = nullptr;
2485 napi_create_double(env, result, &flag);
2486 return flag;
2487 }
2488
SubmitHInDependNullptrTest(napi_env env,napi_callback_info info)2489 static napi_value SubmitHInDependNullptrTest(napi_env env, napi_callback_info info)
2490 {
2491 int result = 0;
2492 const uint32_t sleepTime = 10 * 1000;
2493 int x = 0;
2494 int y = 0;
2495 std::function<void()>&& basic1Func = [&]() {
2496 x = x + 1;
2497 usleep(sleepTime);
2498 };
2499 std::function<void()>&& basic2Func = [&]() {
2500 y = y + 1;
2501 usleep(sleepTime);
2502 };
2503 ffrt_function_header_t* basic1Func_ht = create_function_wrapper((basic1Func));
2504 ffrt_function_header_t* basic2Func_ht = create_function_wrapper((basic2Func));
2505 const std::vector<ffrt_dependence_t> in1_deps = {{ffrt_dependence_data, NULL}};
2506 ffrt_deps_t in1{static_cast<uint32_t>(in1_deps.size()), in1_deps.data()};
2507 const std::vector<ffrt_dependence_t> in2_deps = {{ffrt_dependence_data, NULL}};
2508 ffrt_deps_t in2{static_cast<uint32_t>(in2_deps.size()), in2_deps.data()};
2509 ffrt_task_handle_t task1 = ffrt_submit_h_base(basic1Func_ht, &in1, nullptr, nullptr);
2510 ffrt_task_handle_t task2 = ffrt_submit_h_base(basic2Func_ht, &in2, nullptr, nullptr);
2511 const std::vector<ffrt_dependence_t> wait_deps1 = {{ffrt_dependence_task, task1}};
2512 ffrt_deps_t wait1{static_cast<uint32_t>(wait_deps1.size()), wait_deps1.data()};
2513 const std::vector<ffrt_dependence_t> wait_deps2 = {{ffrt_dependence_task, task2}};
2514 ffrt_deps_t wait2{static_cast<uint32_t>(wait_deps2.size()), wait_deps2.data()};
2515 ffrt_wait_deps(&wait1);
2516 if (x != 1) {
2517 result = 1;
2518 }
2519 ffrt_wait_deps(&wait2);
2520 if (y != 1) {
2521 result = 2;
2522 }
2523 ffrt_task_handle_destroy(task1);
2524 ffrt_task_handle_destroy(task2);
2525 napi_value flag = nullptr;
2526 napi_create_double(env, result, &flag);
2527 return flag;
2528 }
2529
SubmitHOuDependEmptyTest(napi_env env,napi_callback_info info)2530 static napi_value SubmitHOuDependEmptyTest(napi_env env, napi_callback_info info)
2531 {
2532 int result = 0;
2533 const uint32_t sleepTime = 10 * 1000;
2534 int x = 0;
2535 int y = 0;
2536 std::function<void()>&& basic1Func = [&]() {
2537 x = x + 1;
2538 usleep(sleepTime);
2539 };
2540 std::function<void()>&& basic2Func = [&]() {
2541 y = y + 1;
2542 usleep(sleepTime);
2543 };
2544 ffrt_function_header_t* basic1Func_ht = create_function_wrapper((basic1Func));
2545 ffrt_function_header_t* basic2Func_ht = create_function_wrapper((basic2Func));
2546 const std::vector<ffrt_dependence_t> in1_deps = {};
2547 ffrt_deps_t in1{static_cast<uint32_t>(in1_deps.size()), in1_deps.data()};
2548 const std::vector<ffrt_dependence_t> in2_deps = {};
2549 ffrt_deps_t in2{static_cast<uint32_t>(in2_deps.size()), in2_deps.data()};
2550 const std::vector<ffrt_dependence_t> ou1_deps = {};
2551 ffrt_deps_t ou1{static_cast<uint32_t>(ou1_deps.size()), ou1_deps.data()};
2552 const std::vector<ffrt_dependence_t> ou2_deps = {};
2553 ffrt_deps_t ou2{static_cast<uint32_t>(ou2_deps.size()), ou2_deps.data()};
2554 ffrt_task_handle_t task1 = ffrt_submit_h_base(basic1Func_ht, &in1, &ou1, nullptr);
2555 ffrt_task_handle_t task2 = ffrt_submit_h_base(basic2Func_ht, &in2, &ou2, nullptr);
2556 const std::vector<ffrt_dependence_t> wait_deps1 = {{ffrt_dependence_task, task1}};
2557 ffrt_deps_t wait1{static_cast<uint32_t>(wait_deps1.size()), wait_deps1.data()};
2558 const std::vector<ffrt_dependence_t> wait_deps2 = {{ffrt_dependence_task, task2}};
2559 ffrt_deps_t wait2{static_cast<uint32_t>(wait_deps2.size()), wait_deps2.data()};
2560 ffrt_wait_deps(&wait1);
2561 if (x != 1) {
2562 result = 1;
2563 }
2564 ffrt_wait_deps(&wait2);
2565 if (y != 1) {
2566 result = 2;
2567 }
2568 ffrt_task_handle_destroy(task1);
2569 ffrt_task_handle_destroy(task2);
2570 napi_value flag = nullptr;
2571 napi_create_double(env, result, &flag);
2572 return flag;
2573 }
2574
SubmitHOuDependNullptrTest(napi_env env,napi_callback_info info)2575 static napi_value SubmitHOuDependNullptrTest(napi_env env, napi_callback_info info)
2576 {
2577 int result = 0;
2578 const uint32_t sleepTime = 10 * 1000;
2579 int x = 0;
2580 int y = 0;
2581 std::function<void()>&& basic1Func = [&]() {
2582 x = x + 1;
2583 usleep(sleepTime);
2584 if (y != 0) {
2585 result = 1;
2586 }
2587 };
2588 std::function<void()>&& basic2Func = [&]() {
2589 y = y + 1;
2590 usleep(sleepTime);
2591 if (x != 1) {
2592 result = 2;
2593 }
2594 };
2595 ffrt_function_header_t* basic1Func_ht = create_function_wrapper((basic1Func));
2596 ffrt_function_header_t* basic2Func_ht = create_function_wrapper((basic2Func));
2597 const std::vector<ffrt_dependence_t> ou1_deps = {{ffrt_dependence_data, NULL}};
2598 ffrt_deps_t ou1{static_cast<uint32_t>(ou1_deps.size()), ou1_deps.data()};
2599 const std::vector<ffrt_dependence_t> ou2_deps = {{ffrt_dependence_data, NULL}};
2600 ffrt_deps_t ou2{static_cast<uint32_t>(ou2_deps.size()), ou2_deps.data()};
2601 ffrt_task_handle_t task1 = ffrt_submit_h_base(basic1Func_ht, nullptr, &ou1, nullptr);
2602 ffrt_task_handle_t task2 = ffrt_submit_h_base(basic2Func_ht, nullptr, &ou2, nullptr);
2603 const std::vector<ffrt_dependence_t> wait_deps1 = {{ffrt_dependence_task, task1}};
2604 ffrt_deps_t wait1{static_cast<uint32_t>(wait_deps1.size()), wait_deps1.data()};
2605 const std::vector<ffrt_dependence_t> wait_deps2 = {{ffrt_dependence_task, task2}};
2606 ffrt_deps_t wait2{static_cast<uint32_t>(wait_deps2.size()), wait_deps2.data()};
2607 ffrt_wait_deps(&wait1);
2608 if (x != 1) {
2609 result = 3;
2610 }
2611 ffrt_wait_deps(&wait2);
2612 if (y != 1) {
2613 result = 4;
2614 }
2615 ffrt_task_handle_destroy(task1);
2616 ffrt_task_handle_destroy(task2);
2617 napi_value flag = nullptr;
2618 napi_create_double(env, result, &flag);
2619 return flag;
2620 }
2621
2622
SleepForTest000(napi_env env,napi_callback_info info)2623 static napi_value SleepForTest000(napi_env env, napi_callback_info info)
2624 {
2625 int resultEnd = 0;
2626 // sleep 1ms，验证sleep时间的正确性
2627 double t;
2628 std::function<void()>&& func = [&]() {
2629 auto start = std::chrono::high_resolution_clock::now();
2630 ffrt_usleep(0);
2631 auto end = std::chrono::high_resolution_clock::now();
2632 std::chrono::duration<double, std::milli> elapsed = end-start;
2633 t = elapsed.count();
2634 };
2635 ffrt_submit_base(create_function_wrapper(func), nullptr, nullptr, nullptr);
2636 ffrt_wait();
2637 if (t <= 0 || t > 10) {
2638 resultEnd = 1;
2639 }
2640 napi_value flag = nullptr;
2641 napi_create_double(env, resultEnd, &flag);
2642 return flag;
2643 }
2644
SleepForTest001(napi_env env,napi_callback_info info)2645 static napi_value SleepForTest001(napi_env env, napi_callback_info info)
2646 {
2647 int resultEnd = 0;
2648 // sleep 1ms，验证sleep时间的正确性
2649 double t;
2650 std::function<void()>&& func = [&]() {
2651 auto start = std::chrono::high_resolution_clock::now();
2652 ffrt_usleep(1000);
2653 auto end = std::chrono::high_resolution_clock::now();
2654 std::chrono::duration<double, std::milli> elapsed = end-start;
2655 t = elapsed.count();
2656 };
2657 ffrt_submit_base(create_function_wrapper(func), nullptr, nullptr, nullptr);
2658 ffrt_wait();
2659 if (t <= 1 || t > 10) {
2660 resultEnd = 1;
2661 }
2662 napi_value flag = nullptr;
2663 napi_create_double(env, resultEnd, &flag);
2664 return flag;
2665 }
2666
TaskAttrAbnormalTest(napi_env env,napi_callback_info info)2667 static napi_value TaskAttrAbnormalTest(napi_env env, napi_callback_info info)
2668 {
2669 int result = 0;
2670 ffrt_task_attr_t attr;
2671 int ret = ffrt_task_attr_init(nullptr);
2672 if (ret != -1) {
2673 result = 1;
2674 }
2675 ret = ffrt_task_attr_init(&attr);
2676 ffrt_task_attr_set_qos(nullptr, static_cast<int>(ffrt_qos_default));
2677 ffrt_task_attr_set_name(nullptr, nullptr);
2678 ffrt_task_attr_set_delay(nullptr, 0);
2679 ffrt_qos_t ffrt_qos = ffrt_task_attr_get_qos(nullptr);
2680 if (ffrt_qos != ffrt_qos_default) {
2681 result = 2;
2682 }
2683 const char* name = ffrt_task_attr_get_name(nullptr);
2684 if (name != nullptr) {
2685 result = 3;
2686 }
2687 uint64_t delay = ffrt_task_attr_get_delay(nullptr);
2688 if (delay != 0) {
2689 result = 4;
2690 }
2691 ffrt_task_attr_destroy(nullptr);
2692 ffrt_task_attr_destroy(&attr);
2693 napi_value flag = nullptr;
2694 napi_create_double(env, result, &flag);
2695 return flag;
2696 }
2697
TaskAttrQosIllegalTest(napi_env env,napi_callback_info info)2698 static napi_value TaskAttrQosIllegalTest(napi_env env, napi_callback_info info)
2699 {
2700 int result = 0;
2701 ffrt_task_attr_t attr;
2702 ffrt_task_attr_init(&attr);
2703 int minVal = static_cast<int>(ffrt_qos_inherit) - 1;
2704 ffrt_task_attr_set_qos(&attr, minVal);
2705 int queryVal = int(ffrt_task_attr_get_qos(&attr));
2706 if (queryVal != -1) {
2707 result = 1;
2708 }
2709 ffrt_task_attr_destroy(&attr);
2710 napi_value flag = nullptr;
2711 napi_create_double(env, result, &flag);
2712 return flag;
2713 }
2714
TaskAttrQosQueryTest(napi_env env,napi_callback_info info)2715 static napi_value TaskAttrQosQueryTest(napi_env env, napi_callback_info info)
2716 {
2717 int result = 0;
2718 ffrt_task_attr_t attr;
2719 ffrt_task_attr_get_qos(&attr);
2720 int ret = ffrt_task_attr_init(&attr);
2721 if (ret != 0) {
2722 result = 1;
2723 }
2724 int qosVal = ffrt_task_attr_get_qos(&attr);
2725 if (qosVal != ffrt_qos_default) {
2726 result = 2;
2727 }
2728 ffrt_task_attr_destroy(&attr);
2729 napi_value flag = nullptr;
2730 napi_create_double(env, result, &flag);
2731 return flag;
2732 }
2733
TaskAttrSetNameTest(napi_env env,napi_callback_info info)2734 static napi_value TaskAttrSetNameTest(napi_env env, napi_callback_info info)
2735 {
2736 int result = 0;
2737 ffrt_task_attr_t attr;
2738 (void)ffrt_task_attr_init(&attr);
2739 std::string name(ffrt_task_attr_get_name(&attr));
2740 if (name != "") {
2741 result = 1;
2742 }
2743 ffrt_task_attr_set_name(&attr, "Task Name");
2744 std::string reName(ffrt_task_attr_get_name(&attr));
2745 if (reName != "Task Name") {
2746 result = 2;
2747 }
2748 ffrt_task_attr_destroy(&attr);
2749 std::string desName(ffrt_task_attr_get_name(&attr));
2750 napi_value flag = nullptr;
2751 napi_create_double(env, result, &flag);
2752 return flag;
2753 }
2754
TaskAttrSetQosTest(napi_env env,napi_callback_info info)2755 static napi_value TaskAttrSetQosTest(napi_env env, napi_callback_info info)
2756 {
2757 int result = 0;
2758 ffrt_task_attr_t attr;
2759 ffrt_task_attr_init(&attr);
2760 int minLevel = static_cast<int>(ffrt_qos_inherit);
2761 int maxLevel = static_cast<int>(ffrt_qos_user_initiated);
2762 for (int idx = minLevel; idx <= maxLevel; idx++) {
2763 ffrt_task_attr_set_qos(&attr, idx);
2764 int qosVal = int(ffrt_task_attr_get_qos(&attr));
2765 if (qosVal != idx) {
2766 result = idx + 2;
2767 }
2768 }
2769 ffrt_task_attr_destroy(&attr);
2770 napi_value flag = nullptr;
2771 napi_create_double(env, result, &flag);
2772 return flag;
2773 }
2774
2775 EXTERN_C_START
Init(napi_env env,napi_value exports)2776 static napi_value Init(napi_env env, napi_value exports)
2777 {
2778 napi_property_descriptor desc[] = {
2779 { "conditionVariableTest001", nullptr, ConditionVariableTest001, nullptr, nullptr, nullptr,
2780 napi_default, nullptr },
2781 { "conditionVariableTest002", nullptr, ConditionVariableTest002, nullptr, nullptr, nullptr,
2782 napi_default, nullptr },
2783 { "conditionVariableTest003", nullptr, ConditionVariableTest003, nullptr, nullptr, nullptr,
2784 napi_default, nullptr },
2785 { "conditionVariableTest004", nullptr, ConditionVariableTest004, nullptr, nullptr, nullptr,
2786 napi_default, nullptr },
2787 { "conditionVariableApiTest001", nullptr, ConditionVariableApiTest001, nullptr, nullptr, nullptr,
2788 napi_default, nullptr },
2789 { "conditionVariableApiTest002", nullptr, ConditionVariableApiTest002, nullptr, nullptr, nullptr,
2790 napi_default, nullptr },
2791 { "conditionVariableApiTest003", nullptr, ConditionVariableApiTest003, nullptr, nullptr, nullptr,
2792 napi_default, nullptr },
2793 { "conditionVariableApiTest004", nullptr, ConditionVariableApiTest004, nullptr, nullptr, nullptr,
2794 napi_default, nullptr },
2795 { "delayCTest001", nullptr, DelayCTest001, nullptr, nullptr, nullptr, napi_default, nullptr },
2796 { "ffrtYieldC0001", nullptr, FfrtYieldC0001, nullptr, nullptr, nullptr, napi_default, nullptr },
2797 { "mutexAbnormalParamTest001", nullptr, MutexAbnormalParamTest001, nullptr, nullptr, nullptr, napi_default, nullptr },
2798 { "mutexAbnormalParamTest002", nullptr, MutexAbnormalParamTest002, nullptr, nullptr, nullptr, napi_default, nullptr },
2799 { "mutexTest006", nullptr, MutexTest006, nullptr, nullptr, nullptr, napi_default, nullptr },
2800 { "mutexTest007", nullptr, MutexTest007, nullptr, nullptr, nullptr, napi_default, nullptr },
2801 { "mutexTest008", nullptr, MutexTest008, nullptr, nullptr, nullptr, napi_default, nullptr },
2802 { "queueApiTest001", nullptr, QueueApiTest001, nullptr, nullptr, nullptr, napi_default, nullptr },
2803 { "queueApiTest002", nullptr, QueueApiTest002, nullptr, nullptr, nullptr, napi_default, nullptr },
2804 { "queueApiTest003", nullptr, QueueApiTest003, nullptr, nullptr, nullptr, napi_default, nullptr },
2805 { "queueApiTest004", nullptr, QueueApiTest004, nullptr, nullptr, nullptr, napi_default, nullptr },
2806 { "queueApiTest005", nullptr, QueueApiTest005, nullptr, nullptr, nullptr, napi_default, nullptr },
2807 { "queueApiTest006", nullptr, QueueApiTest006, nullptr, nullptr, nullptr, napi_default, nullptr },
2808 { "queueApiTest007", nullptr, QueueApiTest007, nullptr, nullptr, nullptr, napi_default, nullptr },
2809 { "queueApiTest008", nullptr, QueueApiTest008, nullptr, nullptr, nullptr, napi_default, nullptr },
2810 { "queueApiTest009", nullptr, QueueApiTest009, nullptr, nullptr, nullptr, napi_default, nullptr },
2811 { "queueApiTest010", nullptr, QueueApiTest010, nullptr, nullptr, nullptr, napi_default, nullptr },
2812 { "queueApiTest011", nullptr, QueueApiTest011, nullptr, nullptr, nullptr, napi_default, nullptr },
2813 { "queueApiTest012", nullptr, QueueApiTest012, nullptr, nullptr, nullptr, napi_default, nullptr },
2814 { "queueApiTest013", nullptr, QueueApiTest013, nullptr, nullptr, nullptr, napi_default, nullptr },
2815 { "queueCancelTest001", nullptr, QueueCancelTest001, nullptr, nullptr, nullptr, napi_default, nullptr },
2816 { "queueCancelTest003", nullptr, QueueCancelTest003, nullptr, nullptr, nullptr, napi_default, nullptr },
2817 { "queueCancelTest004", nullptr, QueueCancelTest004, nullptr, nullptr, nullptr, napi_default, nullptr },
2818 { "queueDelayTest001", nullptr, QueueDelayTest001, nullptr, nullptr, nullptr, napi_default, nullptr },
2819 { "queueDelayTest002", nullptr, QueueDelayTest002, nullptr, nullptr, nullptr, napi_default, nullptr },
2820 { "queueDelayTest005", nullptr, QueueDelayTest005, nullptr, nullptr, nullptr, napi_default, nullptr },
2821 { "queueDfxTest001", nullptr, QueueDfxTest001, nullptr, nullptr, nullptr, napi_default, nullptr },
2822 { "queueDfxTest002", nullptr, QueueDfxTest002, nullptr, nullptr, nullptr, napi_default, nullptr },
2823 { "queueDfxTest003", nullptr, QueueDfxTest003, nullptr, nullptr, nullptr, napi_default, nullptr },
2824 { "queueDfxTest004", nullptr, QueueDfxTest004, nullptr, nullptr, nullptr, napi_default, nullptr },
2825 { "queueDfxTest005", nullptr, QueueDfxTest005, nullptr, nullptr, nullptr, napi_default, nullptr },
2826 { "queueDfxTest006", nullptr, QueueDfxTest006, nullptr, nullptr, nullptr, napi_default, nullptr },
2827 { "queueTest001", nullptr, QueueTest001, nullptr, nullptr, nullptr, napi_default, nullptr },
2828 { "queueTest002", nullptr, QueueTest002, nullptr, nullptr, nullptr, napi_default, nullptr },
2829 { "queueTest003", nullptr, QueueTest003, nullptr, nullptr, nullptr, napi_default, nullptr },
2830 { "queueWaitTest001", nullptr, QueueWaitTest001, nullptr, nullptr, nullptr, napi_default, nullptr },
2831 { "submitAbnormalTest", nullptr, SubmitAbnormalTest, nullptr, nullptr, nullptr, napi_default, nullptr },
2832 { "submitBasicTest001", nullptr, SubmitBasicTest001, nullptr, nullptr, nullptr, napi_default, nullptr },
2833 { "submitBasicTest002", nullptr, SubmitBasicTest002, nullptr, nullptr, nullptr, napi_default, nullptr },
2834 { "submitInDependEmptyTest", nullptr, SubmitInDependEmptyTest, nullptr, nullptr, nullptr,
2835 napi_default, nullptr },
2836 { "submitInDependNullptrTest", nullptr, SubmitInDependNullptrTest, nullptr, nullptr, nullptr,
2837 napi_default, nullptr },
2838 { "submitOuDependEmptyTest", nullptr, SubmitOuDependEmptyTest, nullptr, nullptr, nullptr,
2839 napi_default, nullptr },
2840 { "submitOuDependNullptrTest", nullptr, SubmitOuDependNullptrTest, nullptr, nullptr, nullptr,
2841 napi_default, nullptr },
2842 { "submitIODependTest001", nullptr, SubmitIODependTest001, nullptr, nullptr, nullptr,
2843 napi_default, nullptr },
2844 { "submitIODependTest002", nullptr, SubmitIODependTest002, nullptr, nullptr, nullptr,
2845 napi_default, nullptr },
2846 { "submitIn0Ou0WaitNullTask1Test", nullptr, SubmitIn0Ou0WaitNullTask1Test, nullptr, nullptr, nullptr,
2847 napi_default, nullptr },
2848 { "submitHBasicTest001", nullptr, SubmitHBasicTest001, nullptr, nullptr, nullptr, napi_default, nullptr },
2849 { "submitHBasicTest002", nullptr, SubmitHBasicTest002, nullptr, nullptr, nullptr, napi_default, nullptr },
2850 { "submitHInDependEmptyTest", nullptr, SubmitHInDependEmptyTest, nullptr, nullptr, nullptr,
2851 napi_default, nullptr },
2852 { "submitHInDependNullptrTest", nullptr, SubmitHInDependNullptrTest, nullptr, nullptr, nullptr,
2853 napi_default, nullptr },
2854 { "submitHOuDependEmptyTest", nullptr, SubmitHOuDependEmptyTest, nullptr, nullptr, nullptr,
2855 napi_default, nullptr },
2856 { "submitHOuDependNullptrTest", nullptr, SubmitHOuDependNullptrTest, nullptr, nullptr, nullptr,
2857 napi_default, nullptr },
2858 { "submitHIODependTest001", nullptr, SubmitHIODependTest001, nullptr, nullptr, nullptr,
2859 napi_default, nullptr },
2860 { "submitHIODependTest002", nullptr, SubmitHIODependTest002, nullptr, nullptr, nullptr,
2861 napi_default, nullptr },
2862 { "sleepForTest000", nullptr, SleepForTest000, nullptr, nullptr, nullptr, napi_default, nullptr },
2863 { "sleepForTest001", nullptr, SleepForTest001, nullptr, nullptr, nullptr, napi_default, nullptr },
2864 { "taskAttrAbnormalTest", nullptr, TaskAttrAbnormalTest, nullptr, nullptr, nullptr, napi_default, nullptr },
2865 { "taskAttrQosIllegalTest", nullptr, TaskAttrQosIllegalTest, nullptr, nullptr, nullptr, napi_default, nullptr },
2866 { "taskAttrQosQueryTest", nullptr, TaskAttrQosQueryTest, nullptr, nullptr, nullptr, napi_default, nullptr },
2867 { "taskAttrSetNameTest", nullptr, TaskAttrSetNameTest, nullptr, nullptr, nullptr, napi_default, nullptr },
2868 { "taskAttrSetQosTest", nullptr, TaskAttrSetQosTest, nullptr, nullptr, nullptr, napi_default, nullptr }
2869 };
2870 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
2871 return exports;
2872 }
2873 EXTERN_C_END
2874
2875 static napi_module demoModule = {
2876 .nm_version =1,
2877 .nm_flags = 0,
2878 .nm_filename = nullptr,
2879 .nm_register_func = Init,
2880 .nm_modname = "ffrtndk",
2881 .nm_priv = ((void*)0),
2882 .reserved = { 0 },
2883 };
2884
RegisterEntryModule(void)2885 extern "C" __attribute__((constructor)) void RegisterEntryModule(void)
2886 {
2887 napi_module_register(&demoModule);
2888 }
2889