1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <thread>
17 #include <chrono>
18 #include <gtest/gtest.h>
19 #include "ffrt_inner.h"
20 #include "c/queue_ext.h"
21 #include "../common.h"
22 #include "queue/base_queue.h"
23
24 using namespace std;
25 using namespace ffrt;
26 using namespace testing;
27 #ifdef HWTEST_TESTING_EXT_ENABLE
28 using namespace testing::ext;
29 #endif
30
31 class QueueTest : public testing::Test {
32 protected:
SetUpTestCase()33 static void SetUpTestCase()
34 {
35 }
36
TearDownTestCase()37 static void TearDownTestCase()
38 {
39 }
40
SetUp()41 void SetUp() override
42 {
43 }
44
TearDown()45 void TearDown() override
46 {
47 }
48 };
49
50 #if defined(__clang__)
51 #define OPTIMIZE_OFF __attribute__((optnone))
52 #elif defined(__GNUC__)
53 #define OPTIMIZE_OFF __attribute__((optimize(0)))
54 #else
55 #define OPTIMIZE_OFF
56 #endif
57
58 namespace {
OnePlusForTest(void * data)59 void OPTIMIZE_OFF OnePlusForTest(void* data)
60 {
61 *(int*)data += 1;
62 }
63
PrintForTest(void * data)64 void PrintForTest(void* data)
65 {
66 printf("run no input func PrintForTest\n");
67 }
68
fibonacci(int n)69 int fibonacci(int n)
70 {
71 if (n == 0 || n == 1) {
72 return n;
73 }
74 return fibonacci(n - 1) + fibonacci(n - 2);
75 }
76
FibonacciTest(void * data,int fibnum)77 void FibonacciTest(void* data, int fibnum)
78 {
79 int testnum = fibonacci(fibnum);
80 *(int*)data += testnum;
81 }
82 } // namespace
83
EmptyFunction()84 void EmptyFunction() {}
85 /*
86 * 测试用例名称 : serial_queue_submit_cancel_succ
87 * 测试用例描述：提交、取消串行延时任务成功
88 * 预置条件 ：1、调用串行队列创建接口创建队列
89 * 操作步骤 ：1、提交串行队列任务并执行
90 * 2、提交延时串行队列任务并执行
91 * 预期结果 ：执行成功
92 */
93 HWTEST_F(QueueTest, serial_queue_submit_cancel_succ, TestSize.Level1)
94 {
95 // 创建队列
96 ffrt_queue_attr_t queue_attr;
97 (void)ffrt_queue_attr_init(&queue_attr); // 初始化属性，必须
98 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
99
100 int result = 0;
__anon6ee974240202() 101 std::function<void()> basicFunc = [&result]() { OnePlusForTest(static_cast<void*>(&result)); };
102 reinterpret_cast<ffrt::queue*>(&queue_handle)->submit(basicFunc);
103
104 ffrt_task_handle_t task1 =
105 ffrt_queue_submit_h(queue_handle, create_function_wrapper(basicFunc, ffrt_function_kind_queue), nullptr);
106 ffrt_queue_wait(task1);
107 ffrt_task_handle_destroy(task1); // 销毁task_handle，必须
108 EXPECT_EQ(result, 2);
109
110 ffrt::task_handle task2 =
111 reinterpret_cast<ffrt::queue*>(&queue_handle)->submit_h(basicFunc, ffrt::task_attr().delay(1000));
112 int cancel = reinterpret_cast<ffrt::queue*>(&queue_handle)->cancel(task2);
113 ffrt_queue_attr_destroy(&queue_attr);
114 EXPECT_EQ(cancel, 0);
115 EXPECT_EQ(result, 2);
116
117 // 销毁队列
118 ffrt_queue_destroy(queue_handle);
119 }
120
121 /*
122 * 测试用例名称 : serial_queue_create_fail
123 * 测试用例描述：串行队列创建和销毁失败
124 * 预置条件 ：1、调用串行队列创建接口创建队列
125 * 操作步骤 ：1、调用串行队列创建接口创建队列，type为非串行队列
126 * 2、调用串行队列创建接口创建队列，type为串行队列，但name与attr为nullptr
127 * 3、调用串行队列创建接口创建队列，type为串行队列，但name为nullptr
128 * 预期结果 ：1创建失败，2、3创建成功
129 */
130 HWTEST_F(QueueTest, serial_queue_create_fail, TestSize.Level1)
131 {
132 // input invalid
133 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_max, nullptr, nullptr);
134 ffrt_queue_destroy(queue_handle);
135 ffrt_queue_destroy(nullptr);
136
137 queue_handle = ffrt_queue_create(ffrt_queue_serial, nullptr, nullptr);
138 EXPECT_EQ(queue_handle == nullptr, 0);
139 ffrt_queue_destroy(queue_handle);
140
141 // succ free
142 ffrt_queue_attr_t queue_attr;
143 (void)ffrt_queue_attr_init(&queue_attr); // attr 缺少 init 无法看护
144 queue_handle = ffrt_queue_create(ffrt_queue_serial, nullptr, &queue_attr);
145 EXPECT_EQ(queue_handle == nullptr, 0);
146 ffrt_queue_attr_destroy(&queue_attr);
147 ffrt_queue_destroy(queue_handle);
148 }
149
150 /*
151 * 测试用例名称 : ffrt_task_attr_set_get_delay
152 * 测试用例描述：测试 ffrt_task_attr_set_get_delay
153 * 操作步骤 ：1、调用ffrt_task_attr_set_delay接口设置队列延时时间
154 * 2、使用ffrt_task_attr_get_delay查询时间
155 * 预期结果 ：查询结果与设定相同，初始值为0
156 */
157 HWTEST_F(QueueTest, ffrt_task_attr_set_get_delay, TestSize.Level1)
158 {
159 // succ free
160 ffrt_task_attr_t task_attr;
161 (void)ffrt_task_attr_init(&task_attr); // attr 缺少 init 无法看护
162 // set_attr_delay
163 uint64_t delay = 100;
164 ffrt_task_attr_set_delay(nullptr, delay);
165 ffrt_task_attr_set_delay(&task_attr, delay);
166 // error and return 0
167 delay = ffrt_task_attr_get_delay(nullptr);
168 EXPECT_EQ(delay, 0);
169 delay = ffrt_task_attr_get_delay(&task_attr);
170 EXPECT_EQ(delay, 100);
171 ffrt_task_attr_destroy(&task_attr);
172 }
173
174 /*
175 * 测试用例名称 : serial_queue_task_create_destroy_fail
176 * 测试用例描述：串行任务提交和销毁失败
177 * 操作步骤 ：1、直接调用串行队列接口提交空任务，随后销毁任务
178 * 2、调用串行队列创建接口创建队列并提交空任务
179 * 3、调用串行队列创建接口创建队列并提交任务，随后销毁任务
180 * 预期结果 ：2提交失败并返回nullptr，3提交成功
181 */
182 HWTEST_F(QueueTest, serial_queue_task_create_destroy_fail, TestSize.Level1)
183 {
184 // input invalid
185 ffrt_task_handle_t task = ffrt_queue_submit_h(nullptr, nullptr, nullptr);
186 ffrt_task_handle_destroy(task);
187
188 ffrt_queue_attr_t queue_attr;
189 (void)ffrt_queue_attr_init(&queue_attr); // 初始化属性，必须
190 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
191 task = ffrt_queue_submit_h(queue_handle, nullptr, nullptr);
192 EXPECT_EQ(task == nullptr, 1);
193
194 std::function<void()> basicFunc = std::bind(PrintForTest, nullptr);
195 task = ffrt_queue_submit_h(queue_handle, create_function_wrapper(basicFunc, ffrt_function_kind_queue), nullptr);
196 ffrt_queue_wait(task);
197 // succ free
198 EXPECT_EQ(task == nullptr, 0);
199 ffrt_task_handle_destroy(task);
200 ffrt_queue_attr_destroy(&queue_attr);
201 ffrt_queue_destroy(queue_handle);
202 }
203
204 /*
205 * 测试用例名称 : serial_multi_submit_succ
206 * 测试用例描述：循环提交普通任务和延时任务，执行成功
207 * 操作步骤 ：1、循环提交普通任务90次
208 * 2、循环提交延时任务20次，取消10次
209 * 预期结果 ：总共应执行100+取消前已执行的次数
210 */
211 HWTEST_F(QueueTest, serial_multi_submit_succ, TestSize.Level1)
212 {
213 ffrt_queue_attr_t queue_attr;
214 (void)ffrt_queue_attr_init(&queue_attr); // 初始化属性，必须
215 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
216
217 int result = 0;
218 int cancelFailedNum = 0;
__anon6ee974240302() 219 std::function<void()>&& basicFunc = [&result]() { OnePlusForTest(static_cast<void*>(&result)); };
220 ffrt_task_attr_t task_attr;
221 (void)ffrt_task_attr_init(&task_attr); // 初始化task属性，必须
222 ffrt_task_attr_set_delay(&task_attr, 100); // 设置任务0.1ms后才执行，非必须
223
224 for (int n = 0; n < 10; ++n) {
225 for (int i = 0; i < 9; ++i) {
226 ffrt_queue_submit(queue_handle, create_function_wrapper(basicFunc, ffrt_function_kind_queue), nullptr);
227 }
228
229 ffrt_task_handle_t t1 =
230 ffrt_queue_submit_h(queue_handle, create_function_wrapper(basicFunc, ffrt_function_kind_queue), &task_attr);
231 ffrt_task_handle_t t2 =
232 ffrt_queue_submit_h(queue_handle, create_function_wrapper(basicFunc, ffrt_function_kind_queue), &task_attr);
233 cancelFailedNum += ffrt_queue_cancel(t1);
234 ffrt_task_handle_destroy(t1); // 销毁task_handle，必须
235
236 ffrt_queue_wait(t2);
237 ffrt_task_handle_destroy(t2);
238 }
239
240 EXPECT_EQ(result, (cancelFailedNum + 100));
241 ffrt_queue_attr_destroy(&queue_attr);
242 ffrt_queue_destroy(queue_handle);
243 }
244
245 /*
246 * 测试用例名称 : serial_early_quit_succ
247 * 测试用例描述：主动销毁队列，未执行的任务取消
248 * 操作步骤 ：1、提交10000个斐波那契任务
249 2、至少取消1个
250 * 预期结果 ：取消成功
251 */
252 HWTEST_F(QueueTest, serial_early_quit_succ, TestSize.Level1)
253 {
254 ffrt_queue_attr_t queue_attr;
255 (void)ffrt_queue_attr_init(&queue_attr); // 初始化属性，必须
256 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
257 int fibnum = 10;
258 int result = 0;
259 int expect = fibonacci(fibnum);
__anon6ee974240402() 260 std::function<void()>&& basicFunc = [&result, fibnum]() {
261 FibonacciTest(static_cast<void*>(&result), fibnum);
262 usleep(10);
263 };
264 for (int i = 0; i < 10000; ++i) {
265 ffrt_queue_submit(queue_handle, create_function_wrapper(basicFunc, ffrt_function_kind_queue), nullptr);
266 }
267
268 ffrt_queue_destroy(queue_handle);
269 printf("result = %d\n", result);
270 EXPECT_EQ(result < expect * 10000, 1);
271 }
272
273 /*
274 * 测试用例名称 : serial_double_cancel_failed
275 * 测试用例描述：对一个任务取消两次
276 * 操作步骤 ：1、调用串行队列创建接口创建队列，设置延时并提交任务
277 2、调用两次ffrt_queue_cancel取消同一任务
278 * 预期结果 ：首次取消成功，第二次取消失败
279 */
280 HWTEST_F(QueueTest, serial_double_cancel_failed, TestSize.Level1)
281 {
282 ffrt_queue_attr_t queue_attr;
283 (void)ffrt_queue_attr_init(&queue_attr); // 初始化属性，必须
284 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
285
286 int result = 0;
__anon6ee974240502() 287 std::function<void()>&& basicFunc = [&result]() { OnePlusForTest(static_cast<void*>(&result)); };
288 ffrt_task_attr_t task_attr;
289 (void)ffrt_task_attr_init(&task_attr); // 初始化task属性，必须
290 ffrt_task_attr_set_delay(&task_attr, 100); // 设置任务0.1ms后才执行，非必须
291
292 ffrt_task_handle_t t1 =
293 ffrt_queue_submit_h(queue_handle, create_function_wrapper(basicFunc, ffrt_function_kind_queue), &task_attr);
294 int cancel = ffrt_queue_cancel(t1);
295 EXPECT_EQ(cancel, 0);
296 cancel = ffrt_queue_cancel(t1);
297 EXPECT_EQ(cancel, 1);
298 ffrt_task_handle_destroy(t1); // 销毁task_handle，必须
299
300 ffrt_queue_destroy(queue_handle);
301 }
302
303 /*
304 * 测试用例名称 : ffrt_queue_attr_des
305 * 测试用例描述：设置串行队列qos等级，销毁队列attr
306 * 操作步骤 ：1、设置队列qos等级，调用串行队列创建接口创建队列
307 2、调用ffrt_queue_attr_destroy接口销毁队列创建的attr
308 * 预期结果 ：设置与销毁成功
309 */
310 HWTEST_F(QueueTest, ffrt_queue_attr_des, TestSize.Level1)
311 {
312 ffrt_queue_attr_t queue_attr;
313 (void)ffrt_queue_attr_init(&queue_attr);
314 ffrt_queue_attr_set_qos(&queue_attr, ffrt_qos_background);
315 ffrt_qos_t qos = ffrt_queue_attr_get_qos(&queue_attr);
316 EXPECT_EQ(qos == ffrt_qos_background, 1);
317 ffrt_queue_attr_destroy(&queue_attr);
318 }
319
320 HWTEST_F(QueueTest, ffrt_queue_dfx_api_0001, TestSize.Level1)
321 {
322 // ffrt_queue_attr_set_timeout接口attr为异常值
323 ffrt_queue_attr_t queue_attr;
324 (void)ffrt_queue_attr_init(&queue_attr); // 初始化属性，必须
325 ffrt_queue_attr_set_timeout(nullptr, 10000);
326 uint64_t time = ffrt_queue_attr_get_timeout(&queue_attr);
327 EXPECT_EQ(time, 0);
328 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
329 EXPECT_TRUE(queue_handle != nullptr);
330
331 // 销毁队列
332 ffrt_queue_attr_destroy(&queue_attr);
333 ffrt_queue_destroy(queue_handle);
334 }
335
336 HWTEST_F(QueueTest, ffrt_queue_dfx_api_0002, TestSize.Level1)
337 {
338 // ffrt_queue_attr_get_timeout接口attr为异常值
339 ffrt_queue_attr_t queue_attr;
340 (void)ffrt_queue_attr_init(&queue_attr); // 初始化属性，必须
341 ffrt_queue_attr_set_timeout(&queue_attr, 10000);
342 uint64_t time = ffrt_queue_attr_get_timeout(nullptr);
343 EXPECT_EQ(time, 0);
344 time = ffrt_queue_attr_get_timeout(&queue_attr);
345 EXPECT_EQ(time, 10000);
346 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
347 EXPECT_TRUE(queue_handle != nullptr);
348
349 // 销毁队列
350 ffrt_queue_attr_destroy(&queue_attr);
351 ffrt_queue_destroy(queue_handle);
352 }
353
354 HWTEST_F(QueueTest, ffrt_queue_dfx_api_0004, TestSize.Level1)
355 {
356 // ffrt_queue_attr_get_timeoutCb接口attr为异常值
__anon6ee974240602() 357 std::function<void()> cbOne = []() { printf("first set callback\n"); };
358
359 ffrt_queue_attr_t queue_attr;
360 (void)ffrt_queue_attr_init(&queue_attr); // 初始化属性，必须
361 ffrt_queue_attr_set_callback(&queue_attr, ffrt::create_function_wrapper(cbOne, ffrt_function_kind_queue));
362 ffrt_function_header_t* func = ffrt_queue_attr_get_callback(nullptr);
363 EXPECT_TRUE(func == nullptr);
364 func = ffrt_queue_attr_get_callback(&queue_attr);
365 EXPECT_TRUE(func != nullptr);
366 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
367 EXPECT_TRUE(queue_handle != nullptr);
368
369 // 销毁队列
370 ffrt_queue_destroy(queue_handle);
371 ffrt_queue_attr_destroy(&queue_attr);
372 }
373
374 /*
375 * 测试用例名称 : ffrt_task_attr_set_queue_priority
376 * 测试用例描述 : 测试 ffrt_task_attr_set_queue_priority
377 * 操作步骤 : 1、调用ffrt_task_attr_set_queue_priority接口设置队列优先级
378 * 2、使用ffrt_task_attr_get_queue_priority查询优先级
379 * 预期结果 : 查询结果与设定相同，值为3
380 */
381 HWTEST_F(QueueTest, ffrt_task_attr_set_queue_priority, TestSize.Level1)
382 {
383 ffrt_task_attr_t task_attr;
384 (void)ffrt_task_attr_init(&task_attr);
385 ffrt_queue_priority_t priority = ffrt_queue_priority_low;
386 ffrt_task_attr_set_queue_priority(nullptr, priority);
387 ffrt_task_attr_set_queue_priority(&task_attr, priority);
388 priority = ffrt_task_attr_get_queue_priority(nullptr);
389 EXPECT_EQ(priority, ffrt_queue_priority_immediate);
390 priority = ffrt_task_attr_get_queue_priority(&task_attr);
391 EXPECT_EQ(priority, ffrt_queue_priority_low);
392 ffrt_task_attr_destroy(&task_attr);
393 }
394
395 /*
396 * 测试用例名称 : ffrt_queue_attr_set_max_concurrency
397 * 测试用例描述 : 测试 ffrt_queue_attr_set_max_concurrency
398 * 操作步骤 : 1、调用ffrt_queue_attr_set_max_concurrency设置FFRT并行队列，并行度为4
399 * 2、使用ffrt_queue_attr_get_max_concurrency查询并行度
400 * 预期结果 : 查询结果与设定相同，值为4
401 */
402 HWTEST_F(QueueTest, ffrt_queue_attr_set_max_concurrency, TestSize.Level1)
403 {
404 ffrt_queue_attr_t queue_attr;
405 (void)ffrt_queue_attr_init(&queue_attr);
406 uint64_t concurrency = 4;
407 ffrt_queue_attr_set_max_concurrency(nullptr, concurrency);
408 ffrt_queue_attr_set_max_concurrency(&queue_attr, concurrency);
409 concurrency = ffrt_queue_attr_get_max_concurrency(nullptr);
410 EXPECT_EQ(concurrency, 0);
411 concurrency = ffrt_queue_attr_get_max_concurrency(&queue_attr);
412 EXPECT_EQ(concurrency, 4);
413 ffrt_queue_attr_destroy(&queue_attr);
414
415 ffrt_queue_attr_t queue_attr1;
416 (void)ffrt_queue_attr_init(&queue_attr1);
417 concurrency = 0;
418 ffrt_queue_attr_set_max_concurrency(&queue_attr1, concurrency);
419 concurrency = ffrt_queue_attr_get_max_concurrency(&queue_attr1);
420 EXPECT_EQ(concurrency, 1);
421 ffrt_queue_attr_destroy(&queue_attr1);
422 }
423
424 /*
425 * 测试用例名称 : ffrt_queue_has_task
426 * 测试用例描述 : 测试 ffrt_queue_has_task
427 * 操作步骤 : 1、往队列中提交若干任务，其中包含待查询的任务
428 * 2、调用ffrt_queue_has_task查询任务是否在队列中
429 * 预期结果 : 查询结果与预期相同
430 */
431 HWTEST_F(QueueTest, ffrt_queue_has_task, TestSize.Level1)
432 {
433 ffrt_queue_attr_t queue_attr;
434 (void)ffrt_queue_attr_init(&queue_attr); // 初始化属性，必须
435 ffrt_queue_t queue_handle = ffrt_queue_create(ffrt_queue_serial, "test_queue", &queue_attr);
436
437 std::mutex lock;
438 lock.lock();
__anon6ee974240702() 439 std::function<void()> basicFunc = [&]() { lock.lock(); };
__anon6ee974240802() 440 std::function<void()> emptyFunc = []() {};
441
442 ffrt_task_attr_t task_attr;
443 ffrt_task_attr_init(&task_attr);
444 ffrt_task_attr_set_name(&task_attr, "basic_function");
445 ffrt_task_handle_t handle = ffrt_queue_submit_h(queue_handle,
446 create_function_wrapper(basicFunc, ffrt_function_kind_queue), &task_attr);
447
448 for (int i = 0; i < 10; i++) {
449 std::string name = "empty_function_" + std::to_string(i);
450 ffrt_task_attr_set_name(&task_attr, name.c_str());
451 ffrt_queue_submit(queue_handle, create_function_wrapper(emptyFunc, ffrt_function_kind_queue), &task_attr);
452 }
453
454 // 全字匹配
455 for (int i = 0; i < 10; i++) {
456 std::string name = "empty_function_" + std::to_string(i);
457 bool hasEmptyTask = ffrt_queue_has_task(queue_handle, name.c_str());
458 EXPECT_EQ(hasEmptyTask, true);
459 }
460
461 // 正则匹配
462 bool hasEmptyTask = ffrt_queue_has_task(queue_handle, "empty_function_.*");
463 EXPECT_EQ(hasEmptyTask, true);
464
465 hasEmptyTask = ffrt_queue_has_task(queue_handle, "random_function");
466 EXPECT_EQ(hasEmptyTask, false);
467
468 lock.unlock();
469 ffrt_queue_wait(handle);
470
471 ffrt_task_handle_destroy(handle);
472 ffrt_task_attr_destroy(&task_attr);
473 ffrt_queue_attr_destroy(&queue_attr);
474 ffrt_queue_destroy(queue_handle);
475 }
476
477 /*
478 * 测试用例名称 : ffrt_queue_cancel_all_and_cancel_by_name
479 * 测试用例描述 : 测试 ffrt_queue_cancel_all、ffrt_queue_cancel_by_name
480 * 操作步骤 : 1、往队列中提交若干任务
481 * 2、调用ffrt_queue_cancel_by_name取消指定任务
482 * 3、调用ffrt_queue_cancel_all取消所有任务
483 * 预期结果 : 任务取消成功
484 */
485 HWTEST_F(QueueTest, ffrt_queue_cancel_all_and_cancel_by_name, TestSize.Level1)
486 {
487 ffrt_queue_attr_t queue_attr;
488 (void)ffrt_queue_attr_init(&queue_attr); // 初始化属性，必须
489 ffrt_queue_t queue_handle = ffrt_queue_create(
490 static_cast<ffrt_queue_type_t>(ffrt_queue_eventhandler_adapter), "test_queue", &queue_attr);
491
492 std::mutex lock;
493 lock.lock();
__anon6ee974240902() 494 std::function<void()> basicFunc = [&]() { lock.lock(); };
__anon6ee974240a02() 495 std::function<void()> emptyFunc = []() {};
496
497 ffrt_task_attr_t task_attr;
498 ffrt_task_attr_init(&task_attr);
499 ffrt_task_attr_set_name(&task_attr, "basic_function");
500 ffrt_task_handle_t handle = ffrt_queue_submit_h(queue_handle,
501 create_function_wrapper(basicFunc, ffrt_function_kind_queue), &task_attr);
502
503 for (int i = 0; i < 10; i++) {
504 std::string name = "empty_function_" + std::to_string(i);
505 ffrt_task_attr_set_name(&task_attr, name.c_str());
506 ffrt_queue_submit(queue_handle, create_function_wrapper(emptyFunc, ffrt_function_kind_queue), &task_attr);
507 }
508
509 // 测试ffrt_queue_cancel_by_name
510 bool hasEmptyTask = ffrt_queue_has_task(queue_handle, "empty_function_3");
511 EXPECT_EQ(hasEmptyTask, true);
512
513 ffrt_queue_cancel_by_name(queue_handle, "empty_function_3");
514
515 hasEmptyTask = ffrt_queue_has_task(queue_handle, "empty_function_3");
516 EXPECT_EQ(hasEmptyTask, false);
517
518 // 测试ffrt_queue_cancel_all
519 hasEmptyTask = ffrt_queue_has_task(queue_handle, "empty_function_.*");
520 EXPECT_EQ(hasEmptyTask, true);
521
522 bool isIdle = ffrt_queue_is_idle(queue_handle);
523 EXPECT_EQ(isIdle, false);
524
525 ffrt_queue_cancel_all(queue_handle);
526
527 hasEmptyTask = ffrt_queue_has_task(queue_handle, "empty_function_.*");
528 EXPECT_EQ(hasEmptyTask, false);
529
530 lock.unlock();
531 ffrt_queue_cancel_and_wait(queue_handle);
532 ffrt_queue_wait(handle);
533
534 isIdle = ffrt_queue_is_idle(queue_handle);
535 EXPECT_EQ(isIdle, true);
536
537 ffrt_task_attr_destroy(&task_attr);
538 ffrt_task_handle_destroy(handle);
539 ffrt_queue_attr_destroy(&queue_attr);
540 ffrt_queue_destroy(queue_handle);
541 }
542
543 /*
544 * 测试用例名称 : ffrt_queue_submit_head
545 * 测试用例描述 : 测试 ffrt_queue_submit_head
546 * 操作步骤 : 1、往队列中提交若干任务
547 * 2、调用ffrt_queue_submit_head提交任务至队头
548 * 预期结果 : 提交到对头的任务优先被执行
549 */
550 HWTEST_F(QueueTest, ffrt_queue_submit_head, TestSize.Level1)
551 {
552 ffrt::queue* testQueue = new ffrt::queue(static_cast<ffrt::queue_type>(
553 ffrt_inner_queue_type_t::ffrt_queue_eventhandler_adapter), "test_queue");
554
555 int result = 0;
556 std::mutex lock;
557 lock.lock();
__anon6ee974240b02() 558 std::function<void()> basicFunc = [&]() { lock.lock(); };
559 std::vector<std::function<void()>> assignFuncs(8, nullptr);
560 std::vector<int> results;
561 std::vector<int> expectResults {6, 2, 1, 4, 3, 5, 8, 7};
562 for (int idx = 0; idx < 8; idx++) {
__anon6ee974240c02() 563 assignFuncs[idx] = [idx, &results]() {
564 results.push_back(idx + 1);
565 };
566 }
567
568 ffrt::task_attr taskAttr;
569 taskAttr.priority(ffrt_queue_priority_immediate).name("basic_function");
570 testQueue->submit_head(basicFunc, taskAttr);
571 testQueue->submit_head(assignFuncs[0], taskAttr);
572 testQueue->submit_head(assignFuncs[1], taskAttr);
573
574 taskAttr.priority(ffrt_queue_priority_high);
575 testQueue->submit_head(assignFuncs[2], taskAttr);
576 testQueue->submit_head(assignFuncs[3], taskAttr);
577
578 taskAttr.priority(ffrt_queue_priority_low);
579 testQueue->submit_head(assignFuncs[4], taskAttr);
580
581 taskAttr.priority(ffrt_queue_priority_immediate);
582 testQueue->submit_head(assignFuncs[5], taskAttr);
583
584 taskAttr.priority(ffrt_queue_priority_idle);
585 ffrt::task_handle handle = testQueue->submit_head_h(assignFuncs[6], taskAttr);
586 testQueue->submit_head(assignFuncs[7], taskAttr);
587
588 lock.unlock();
589 testQueue->wait(handle);
590 EXPECT_EQ(results, expectResults);
591 }
592
593 HWTEST_F(QueueTest, ffrt_get_main_queue, TestSize.Level1)
594 {
595 // ffrt test case begin
596 ffrt::queue *serialQueue = new ffrt::queue("ffrt_normal_queue", {});
597 ffrt_queue_t mainQueue = ffrt_get_main_queue();
598 ffrt_task_attr_t attr;
599 ffrt_task_attr_init(&attr);
600 ffrt_task_attr_set_qos(&attr, ffrt_qos_user_initiated);
601 int result = 0;
__anon6ee974240d02() 602 std::function<void()>&& basicFunc = [&result]() {
603 OnePlusForTest(static_cast<void*>(&result));
604 OnePlusForTest(static_cast<void*>(&result));
605 EXPECT_EQ(result, 2);
606 usleep(3000);
607 };
608
609 ffrt::task_handle handle = serialQueue->submit_h(
__anon6ee974240e02null610 [&] {
611 result = result + 1;
612 ffrt_queue_submit(mainQueue, ffrt::create_function_wrapper(basicFunc, ffrt_function_kind_queue),
613 &attr);
614 },
615 ffrt::task_attr().qos(3).name("ffrt main_queue."));
616
617 serialQueue->wait(handle);
618 EXPECT_EQ(result, 1);
619 delete serialQueue;
620 }
621
622 HWTEST_F(QueueTest, ffrt_get_current_queue, TestSize.Level1)
623 {
624 // ffrt test case begin
625 ffrt::queue *serialQueue = new ffrt::queue("ffrt_normal_queue", {});
626 ffrt_queue_t currentQueue = ffrt_get_current_queue();
627 ffrt_task_attr_t attr;
628 ffrt_task_attr_init(&attr);
629 ffrt_task_attr_set_qos(&attr, ffrt_qos_user_initiated);
630 int result = 0;
__anon6ee974240f02() 631 std::function<void()>&& basicFunc = [&result]() {
632 OnePlusForTest(static_cast<void*>(&result));
633 OnePlusForTest(static_cast<void*>(&result));
634 EXPECT_EQ(result, 3);
635 usleep(3000);
636 };
637
638 ffrt::task_handle handle = serialQueue->submit_h(
__anon6ee974241002null639 [&] {
640 EXPECT_GT(ffrt::get_queue_id(), 0);
641 result = result + 1;
642 ffrt_queue_submit(currentQueue, ffrt::create_function_wrapper(basicFunc, ffrt_function_kind_queue),
643 &attr);
644 },
645 ffrt::task_attr().qos(3).name("ffrt current_queue."));
646
647 serialQueue->wait(handle);
648
649 EXPECT_EQ(result, 1);
650 delete serialQueue;
651 }