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 <gtest/gtest.h>
17 #include <cstdlib>
18 #include <mutex>
19 #include <cmath>
20 #include <chrono>
21 #include <thread>
22 #include <fstream>
23 #include <random>
24 #include <algorithm>
25 #include <cinttypes>
26 #include "util.h"
27 #include "ffrt_inner.h"
28 #include "c/ffrt_ipc.h"
29 #include "eu/co_routine.h"
30 #include "sync/io_poller.h"
31 #define private public
32 #define protect public
33 #include "util/ffrt_facade.h"
34 #undef private
35 #undef protect
36 #include "../common.h"
37
38 using namespace std;
39 using namespace testing;
40 #ifdef HWTEST_TESTING_EXT_ENABLE
41 using namespace testing::ext;
42 #endif
43 #ifdef APP_USE_ARM
44 #define SIZEOF_BYTES sizeof(uint32_t)
45 #else
46 #define SIZEOF_BYTES sizeof(uint64_t)
47 #endif
48
49 class ffrtIoTest : public testing::Test {
50 protected:
SetUpTestCase()51 static void SetUpTestCase()
52 {
53 }
54
TearDownTestCase()55 static void TearDownTestCase()
56 {
57 }
58
SetUp()59 virtual void SetUp()
60 {
61 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
62 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAKE;
63 }
64
TearDown()65 virtual void TearDown()
66 {
67 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
68 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).timerHandle_ = -1;
69 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).timerMap_.clear();
70 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).executedHandle_.clear();
71 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::TEARDOWN;
72 }
73 };
74
HWTEST_F(ffrtIoTest, IoPoller_1Producer_1Consumer, TestSize.Level1)75 HWTEST_F(ffrtIoTest, IoPoller_1Producer_1Consumer, TestSize.Level1)
76 {
77 uint64_t expected = 0xabacadae;
78 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
79 ffrt::submit([&]() {
80 ffrt::sync_io(testFd);
81 uint64_t value = 0;
82 ssize_t n = read(testFd, &value, sizeof(uint64_t));
83 EXPECT_EQ(n, sizeof(value));
84 EXPECT_EQ(value, expected);
85 close(testFd);
86 }, {}, {});
87 ffrt::submit([&]() {
88 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
89 EXPECT_EQ(n, sizeof(uint64_t));
90 }, {}, {});
91
92 ffrt::wait();
93 }
94
HWTEST_F(ffrtIoTest, IoPoller_1Consumer_1Producer, TestSize.Level1)95 HWTEST_F(ffrtIoTest, IoPoller_1Consumer_1Producer, TestSize.Level1)
96 {
97 uint64_t expected = 0xabacadae;
98 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
99 ffrt::submit([&]() {
100 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
101 EXPECT_EQ(n, sizeof(uint64_t));
102 }, {}, {});
103
104 stall_us(3);
105
106 ffrt::submit([&]() {
107 ffrt::sync_io(testFd);
108 uint64_t value = 0;
109 ssize_t n = read(testFd, &value, sizeof(uint64_t));
110 EXPECT_EQ(n, sizeof(value));
111 EXPECT_EQ(value, expected);
112 close(testFd);
113 }, {}, {});
114
115 ffrt::wait();
116 }
117
118 uint64_t g_Ev = 0;
119
HWTEST_F(ffrtIoTest, IoPoller_Producer_N_Consumer_N, TestSize.Level1)120 HWTEST_F(ffrtIoTest, IoPoller_Producer_N_Consumer_N, TestSize.Level1)
121 {
122 int count = 3;
123 uint64_t ev = 0xabacadae;
124 int testFd[count];
125 uint64_t evN = 0;
126 uint64_t i;
127 for (i = 0; i < count; i++) {
128 testFd[i] = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
129 if (testFd[i] < 0) {
130 break;
131 }
132 evN++;
133 g_Ev = evN;
134 int fd = testFd[i];
135 ffrt::submit([fd, i]() {
136 ffrt::sync_io(fd);
137 uint64_t value = 0;
138 ssize_t n = read(fd, &value, sizeof(uint64_t));
139 EXPECT_EQ(n, sizeof(value));
140 close(fd);
141 }, {}, {});
142 }
143
144 for (i = 0; i < evN; i++) {
145 ffrt::submit([&, i]() {
146 uint64_t expected = ev + i;
147 ssize_t n = write(testFd[i], &expected, sizeof(uint64_t));
148 EXPECT_EQ(n, sizeof(uint64_t));
149 }, {}, {});
150 }
151 printf("max eventfd:%" PRIu64 ".\n", evN);
152 ffrt::wait();
153 }
154
155 struct TestData {
156 int fd;
157 uint64_t expected;
158 };
159
testCallBack(void* token, uint32_t event)160 static void testCallBack(void* token, uint32_t event)
161 {
162 struct TestData* testData = reinterpret_cast<TestData*>(token);
163 uint64_t value = 0;
164 ssize_t n = read(testData->fd, &value, sizeof(uint64_t));
165 EXPECT_EQ(n, sizeof(value));
166 EXPECT_EQ(value, testData->expected);
167 printf("cb done\n");
168 }
169
testfun(void* data)170 static void testfun(void* data)
171 {
172 *(int*)data += 1;
173 printf("%d, timeout callback\n", *(int*)data);
174 }
175 void (*cb)(void*) = testfun;
176
HWTEST_F(ffrtIoTest, ffrt_timer_start_succ_map_null, TestSize.Level1)177 HWTEST_F(ffrtIoTest, ffrt_timer_start_succ_map_null, TestSize.Level1)
178 {
179 uint64_t timeout = 20;
180 int x = 0;
181 int* xf = &x;
182 void* data = xf;
183 uint64_t expected = 0xabacadae;
184 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
185 EXPECT_EQ(0, ffrt_timer_start(ffrt_qos_default, timeout, data, cb, false));
186
187 struct TestData testData {.fd = testFd, .expected = expected};
188 ffrt_epoll_ctl(ffrt_qos_default, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
189
190 usleep(30000);
191 ffrt::submit([&]() {
192 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
193 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
194 }, {}, {});
195 ffrt_epoll_ctl(ffrt_qos_default, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
196 ffrt::wait();
197 EXPECT_EQ(1, x);
198 close(testFd);
199 }
200
HWTEST_F(ffrtIoTest, ffrt_timer_start_fail_cb_null, TestSize.Level1)201 HWTEST_F(ffrtIoTest, ffrt_timer_start_fail_cb_null, TestSize.Level1)
202 {
203 uint64_t timeout = 20;
204 void* data = nullptr;
205 void (*timeoutNullCb)(void*) = nullptr;
206
207 EXPECT_EQ(-1, ffrt_timer_start(ffrt_qos_default, timeout, data, timeoutNullCb, false));
208 }
209
HWTEST_F(ffrtIoTest, ffrt_timer_start_fail_flag_teardown, TestSize.Level1)210 HWTEST_F(ffrtIoTest, ffrt_timer_start_fail_flag_teardown, TestSize.Level1)
211 {
212 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
213 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::TEARDOWN;
214 uint64_t timeout = 20;
215 void* data = nullptr;
216
217 EXPECT_EQ(-1, ffrt_timer_start(qos, timeout, data, cb, false));
218 }
219
HWTEST_F(ffrtIoTest, ffrt_timer_start_succ_short_timeout_flagwait, TestSize.Level1)220 HWTEST_F(ffrtIoTest, ffrt_timer_start_succ_short_timeout_flagwait, TestSize.Level1)
221 {
222 int x = 0;
223 int* xf = &x;
224 void* data = xf;
225 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
226 uint64_t timeout1 = 200;
227 uint64_t timeout2 = 10;
228 uint64_t expected = 0xabacadae;
229 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
230 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAIT;
231 EXPECT_EQ(0, ffrt_timer_start(qos, timeout1, data, cb, false));
232
233 EXPECT_EQ(1, ffrt_timer_start(qos, timeout2, data, cb, false));
234 struct TestData testData {.fd = testFd, .expected = expected};
235 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
236
237 usleep(15000);
238 ffrt::submit([&]() {
239 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
240 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
241 }, {}, {});
242 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
243 ffrt::wait();
244 EXPECT_EQ(1, x);
245 close(testFd);
246 }
247
HWTEST_F(ffrtIoTest, ffrt_timer_start_succ_short_timeout_flagwake, TestSize.Level1)248 HWTEST_F(ffrtIoTest, ffrt_timer_start_succ_short_timeout_flagwake, TestSize.Level1)
249 {
250 int x = 0;
251 int* xf = &x;
252 void* data = xf;
253 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
254 uint64_t timeout1 = 400;
255 uint64_t timeout2 = 10;
256 uint64_t expected = 0xabacadae;
257 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
258 EXPECT_EQ(0, ffrt_timer_start(qos, timeout1, data, cb, false));
259 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAKE;
260 EXPECT_EQ(1, ffrt_timer_start(qos, timeout2, data, cb, false));
261 struct TestData testData {.fd = testFd, .expected = expected};
262 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
263
264 usleep(15000);
265 ffrt::submit([&]() {
266 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
267 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
268 }, {}, {});
269 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
270 ffrt::wait();
271 EXPECT_EQ(1, x);
272 close(testFd);
273 }
274
HWTEST_F(ffrtIoTest, ffrt_timer_start_succ_long_timeout_flagwake, TestSize.Level1)275 HWTEST_F(ffrtIoTest, ffrt_timer_start_succ_long_timeout_flagwake, TestSize.Level1)
276 {
277 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
278 int x = 0;
279 int* xf = &x;
280 void* data = xf;
281 uint64_t timeout1 = 10;
282 uint64_t timeout2 = 200;
283 uint64_t expected = 0xabacadae;
284 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
285
286 EXPECT_EQ(0, ffrt_timer_start(qos, timeout1, data, cb, false));
287 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAKE;
288 EXPECT_EQ(1, ffrt_timer_start(qos, timeout2, data, cb, false));
289 struct TestData testData {.fd = testFd, .expected = expected};
290 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
291
292 usleep(15000);
293 ffrt::submit([&]() {
294 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
295 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
296 }, {}, {});
297 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
298 ffrt::wait();
299 EXPECT_EQ(1, x);
300 close(testFd);
301 }
302
HWTEST_F(ffrtIoTest, ffrt_timer_stop_fail, TestSize.Level1)303 HWTEST_F(ffrtIoTest, ffrt_timer_stop_fail, TestSize.Level1)
304 {
305 int handle = -1;
306 ffrt_timer_stop(ffrt_qos_default, handle);
307 }
308
HWTEST_F(ffrtIoTest, ffrt_timer_stop_succ_mapfirst_flagwait, TestSize.Level1)309 HWTEST_F(ffrtIoTest, ffrt_timer_stop_succ_mapfirst_flagwait, TestSize.Level1)
310 {
311 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
312 int x = 0;
313 int* xf = &x;
314 void* data = xf;
315 uint64_t timeout1 = 20;
316 uint64_t timeout2 = 10;
317 uint64_t expected = 0xabacadae;
318 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
319
320 EXPECT_EQ(0, ffrt_timer_start(qos, timeout1, data, cb, false));
321
322 int handle = ffrt_timer_start(qos, timeout2, data, cb, false);
323 EXPECT_EQ(1, handle);
324 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAIT;
325 ffrt_timer_stop(qos, handle);
326 struct TestData testData {.fd = testFd, .expected = expected};
327 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
328
329 usleep(15000);
330 ffrt::submit([&]() {
331 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
332 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
333 }, {}, {});
334 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
335 ffrt::wait();
336 close(testFd);
337 }
338
HWTEST_F(ffrtIoTest, ffrt_timer_stop_succ_mapother, TestSize.Level1)339 HWTEST_F(ffrtIoTest, ffrt_timer_stop_succ_mapother, TestSize.Level1)
340 {
341 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
342 int x = 0;
343 int* xf = &x;
344 void* data = xf;
345 uint64_t timeout1 = 10;
346 uint64_t timeout2 = 20;
347 uint64_t expected = 0xabacadae;
348 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
349
350 EXPECT_EQ(0, ffrt_timer_start(qos, timeout1, data, cb, false));
351 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAIT;
352 int handle = ffrt_timer_start(qos, timeout2, data, cb, false);
353 EXPECT_EQ(1, handle);
354 ffrt_timer_stop(qos, handle);
355 struct TestData testData {.fd = testFd, .expected = expected};
356 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
357
358 usleep(15000);
359 ffrt::submit([&]() {
360 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
361 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
362 }, {}, {});
363 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
364 ffrt::wait();
365 close(testFd);
366 }
367
HWTEST_F(ffrtIoTest, ffrt_timer_stop_succ_mapfirst_flagwake, TestSize.Level1)368 HWTEST_F(ffrtIoTest, ffrt_timer_stop_succ_mapfirst_flagwake, TestSize.Level1)
369 {
370 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
371 int x = 0;
372 int* xf = &x;
373 void* data = xf;
374 uint64_t timeout1 = 10;
375 uint64_t timeout2 = 20;
376 uint64_t expected = 0xabacadae;
377 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
378
379 EXPECT_EQ(0, ffrt_timer_start(qos, timeout1, data, cb, false));
380 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::WAKE;
381 int handle = ffrt_timer_start(qos, timeout2, data, cb, false);
382 EXPECT_EQ(1, handle);
383 ffrt_timer_stop(qos, handle);
384 struct TestData testData {.fd = testFd, .expected = expected};
385 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
386
387 usleep(15000);
388
389 ffrt::submit([&]() {
390 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
391 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
392 }, {}, {});
393 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
394 ffrt::wait();
395 close(testFd);
396 }
397
HWTEST_F(ffrtIoTest, ffrt_timer_stop_succ_flag_teardown, TestSize.Level1)398 HWTEST_F(ffrtIoTest, ffrt_timer_stop_succ_flag_teardown, TestSize.Level1)
399 {
400 ffrt::QoS qos = ffrt::ExecuteCtx::Cur()->qos;
401 int x = 0;
402 int* xf = &x;
403 void* data = xf;
404 uint64_t timeout2 = 20;
405 uint64_t expected = 0xabacadae;
406 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
407
408 ffrt::FFRTFacade::GetPPInstance().GetPoller(qos).flag_ = ffrt::EpollStatus::TEARDOWN;
409 int handle = ffrt_timer_start(qos, timeout2, data, cb, false);
410 EXPECT_EQ(-1, handle);
411 ffrt_timer_stop(qos, handle);
412 struct TestData testData {.fd = testFd, .expected = expected};
413 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
414
415 usleep(21000);
416
417 ffrt::submit([&]() {
418 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
419 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
420 }, {}, {});
421 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
422 ffrt::wait();
423 EXPECT_EQ(0, x);
424 close(testFd);
425 }
426
HWTEST_F(ffrtIoTest, ffrt_timer_query_test, TestSize.Level1)427 HWTEST_F(ffrtIoTest, ffrt_timer_query_test, TestSize.Level1)
428 {
429 int x = 0;
430 int* xf = &x;
431 void* data = xf;
432 uint64_t timeout1 = 10;
433 uint64_t timeout2 = 20;
434 uint64_t expected = 0xabacadae;
435 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
436
437 ffrt_qos_t qos = ffrt_qos_default;
438 int handle = ffrt_timer_start(qos, timeout1, data, cb, false);
439 EXPECT_EQ(0, ffrt_timer_query(qos, handle));
440
441 struct TestData testData {.fd = testFd, .expected = expected};
442 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
443
444 usleep(15000);
445
446 ffrt::submit([&]() {
447 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
448 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
449 }, {}, {});
450 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
451 ffrt::wait();
452 close(testFd);
453 EXPECT_EQ(1, ffrt_timer_query(qos, handle));
454 }
455
HWTEST_F(ffrtIoTest, ffrt_timer_query_stop, TestSize.Level1)456 HWTEST_F(ffrtIoTest, ffrt_timer_query_stop, TestSize.Level1)
457 {
458 int x = 0;
459 int* xf = &x;
460 void* data = xf;
461 uint64_t timeout1 = 10;
462 uint64_t timeout2 = 20;
463 uint64_t expected = 0xabacadae;
464 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
465
466 ffrt_qos_t qos = ffrt_qos_default;
467 int handle = ffrt_timer_start(qos, timeout1, data, cb, false);
468 EXPECT_EQ(0, ffrt_timer_query(qos, handle));
469
470 ffrt_timer_stop(qos, handle);
471 struct TestData testData {.fd = testFd, .expected = expected};
472 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
473
474 usleep(15000);
475
476 ffrt::submit([&]() {
477 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
478 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
479 }, {}, {});
480 ffrt_epoll_ctl(qos, EPOLL_CTL_DEL, testFd, 0, nullptr, nullptr);
481 ffrt::wait();
482 EXPECT_EQ(-1, ffrt_timer_query(qos, handle));
483 close(testFd);
484 }
485
HWTEST_F(ffrtIoTest, ffrt_poller_deregister_qos_valid, TestSize.Level1)486 HWTEST_F(ffrtIoTest, ffrt_poller_deregister_qos_valid, TestSize.Level1)
487 {
488 uint64_t expected = 0xabacadae;
489 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
490 ffrt_qos_t qos_level = ffrt_qos_default;
491 int op = EPOLL_CTL_ADD;
492
493 struct TestData testData {.fd = testFd, .expected = expected};
494
495 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
496 EXPECT_EQ(0, ret);
497
498 ffrt::submit([&]() {
499 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
500 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
501 }, {}, {});
502
503 usleep(100);
504
505 ret = ffrt_epoll_ctl(qos_level, EPOLL_CTL_DEL, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
506 EXPECT_EQ(0, ret);
507 ffrt::wait();
508 close(testFd);
509 }
510
HWTEST_F(ffrtIoTest, ffrt_poller_deregister_qos_fd_invalid, TestSize.Level1)511 HWTEST_F(ffrtIoTest, ffrt_poller_deregister_qos_fd_invalid, TestSize.Level1)
512 {
513 uint64_t expected = 0xabacadae;
514 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
515 ffrt_qos_t qos_level = ffrt_qos_default;
516 int op = EPOLL_CTL_ADD;
517
518 struct TestData testData {.fd = testFd, .expected = expected};
519
520 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
521 EXPECT_EQ(0, ret);
522
523 ffrt::submit([&]() {
524 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
525 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
526 }, {}, {});
527
528 usleep(100);
529
530 ret = ffrt_epoll_ctl(qos_level, EPOLL_CTL_DEL, -1, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
531 EXPECT_EQ(-1, ret);
532 ffrt::wait();
533 close(testFd);
534 }
535
HWTEST_F(ffrtIoTest, ffrt_poller_deregister_qos_qos_invalid, TestSize.Level1)536 HWTEST_F(ffrtIoTest, ffrt_poller_deregister_qos_qos_invalid, TestSize.Level1)
537 {
538 uint64_t expected = 0xabacadae;
539 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
540 ffrt_qos_t qos_level = ffrt_qos_user_initiated;
541 int op = EPOLL_CTL_ADD;
542
543 struct TestData testData {.fd = testFd, .expected = expected};
544
545 int ret = ffrt_epoll_ctl(ffrt_qos_default, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
546 EXPECT_EQ(0, ret);
547
548 ffrt::submit([&]() {
549 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
550 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
551 }, {}, {});
552
553 usleep(100);
554
555 ret = ffrt_epoll_ctl(qos_level, EPOLL_CTL_DEL, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
556 EXPECT_EQ(-1, ret);
557 ffrt::wait();
558 close(testFd);
559 }
560
HWTEST_F(ffrtIoTest, ffrt_task_attr_set_local_true, TestSize.Level1)561 HWTEST_F(ffrtIoTest, ffrt_task_attr_set_local_true, TestSize.Level1)
562 {
563 bool isLocalSet = true;
564 ffrt_task_attr_t attr;
565 ffrt_task_attr_init(&attr);
566 ffrt_task_attr_set_local(&attr, isLocalSet);
567 bool localval = ffrt_task_attr_get_local(&attr);
568 EXPECT_EQ(localval, isLocalSet);
569 }
570
HWTEST_F(ffrtIoTest, ffrt_task_attr_set_local_false, TestSize.Level1)571 HWTEST_F(ffrtIoTest, ffrt_task_attr_set_local_false, TestSize.Level1)
572 {
573 bool isLocalSet = false;
574 ffrt_task_attr_t attr;
575 ffrt_task_attr_init(&attr);
576 ffrt_task_attr_set_local(&attr, isLocalSet);
577 bool localval = ffrt_task_attr_get_local(&attr);
578 EXPECT_EQ(localval, isLocalSet);
579 }
580
HWTEST_F(ffrtIoTest, ffrt_task_attr_set_local_attr_invalid, TestSize.Level1)581 HWTEST_F(ffrtIoTest, ffrt_task_attr_set_local_attr_invalid, TestSize.Level1)
582 {
583 bool isLocalSet = true;
584 ffrt_task_attr_set_local(nullptr, isLocalSet);
585 }
586
587 struct WakeData {
588 int fd;
589 void* data;
590 };
591
HWTEST_F(ffrtIoTest, ffrt_epoll_wait_valid, TestSize.Level1)592 HWTEST_F(ffrtIoTest, ffrt_epoll_wait_valid, TestSize.Level1)
593 {
594 uint64_t expected = 0xabacadae;
595 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
596 struct WakeData m_wakeData;
597 m_wakeData.data = nullptr;
598 m_wakeData.fd = testFd;
599 ffrt_qos_t qos_level = ffrt_qos_user_initiated;
600 int op = EPOLL_CTL_ADD;
601 epoll_event ev = { .events = EPOLLIN, .data = {.ptr = static_cast<void*>(&m_wakeData)} };
602 int maxevents = 1024;
603 uint64_t timeout = 0;
604 int result = 0;
605 struct TestData testData {.fd = testFd, .expected = expected};
606
607 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
608 EXPECT_EQ(0, ret);
609
610 ffrt::submit([&]() {
611 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
612 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
613 result = ffrt_epoll_wait(qos_level, &ev, maxevents, timeout);
614 }, {}, {});
615 usleep(1000);
616 EXPECT_EQ(0, result);
617 }
618
HWTEST_F(ffrtIoTest, ffrt_epoll_wait_events_invalid, TestSize.Level1)619 HWTEST_F(ffrtIoTest, ffrt_epoll_wait_events_invalid, TestSize.Level1)
620 {
621 uint64_t expected = 0xabacadae;
622 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
623 struct WakeData m_wakeData;
624 m_wakeData.data = nullptr;
625 m_wakeData.fd = testFd;
626 ffrt_qos_t qos_level = ffrt_qos_user_initiated;
627 int op = EPOLL_CTL_ADD;
628 epoll_event ev = { .events = EPOLLIN, .data = {.ptr = static_cast<void*>(&m_wakeData)} };
629 int maxevents = 1024;
630 uint64_t timeout = 0;
631 int result = 0;
632
633 struct TestData testData {.fd = testFd, .expected = expected};
634
635 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
636 EXPECT_EQ(0, ret);
637
638 ffrt::submit([&]() {
639 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
640 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
641 result = ffrt_epoll_wait(qos_level, nullptr, maxevents, timeout);
642 }, {}, {});
643 usleep(1000);
644 EXPECT_EQ(-1, result);
645 }
646
HWTEST_F(ffrtIoTest, ffrt_epoll_wait_maxevents_invalid, TestSize.Level1)647 HWTEST_F(ffrtIoTest, ffrt_epoll_wait_maxevents_invalid, TestSize.Level1)
648 {
649 uint64_t expected = 0xabacadae;
650 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
651
652 struct WakeData m_wakeData;
653 m_wakeData.data = nullptr;
654 m_wakeData.fd = testFd;
655 ffrt_qos_t qos_level = ffrt_qos_user_initiated;
656 int op = EPOLL_CTL_ADD;
657 int result = 0;
658
659 epoll_event ev = { .events = EPOLLIN, .data = {.ptr = static_cast<void*>(&m_wakeData)} };
660 int maxevents = -1;
661 uint64_t timeout = 0;
662 struct TestData testData {.fd = testFd, .expected = expected};
663
664 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
665 EXPECT_EQ(0, ret);
666
667 ffrt::submit([&]() {
668 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
669 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
670 result = ffrt_epoll_wait(qos_level, &ev, maxevents, timeout);
671 }, {}, {});
672 usleep(1000);
673 EXPECT_EQ(-1, result);
674 }
675
HWTEST_F(ffrtIoTest, ffrt_epoll_wait_timeout_invalid, TestSize.Level1)676 HWTEST_F(ffrtIoTest, ffrt_epoll_wait_timeout_invalid, TestSize.Level1)
677 {
678 uint64_t expected = 0xabacadae;
679 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
680 struct WakeData m_wakeData;
681 m_wakeData.data = nullptr;
682 m_wakeData.fd = testFd;
683 ffrt_qos_t qos_level = ffrt_qos_user_initiated;
684 int op = EPOLL_CTL_ADD;
685 int result = 0;
686
687 epoll_event ev = { .events = EPOLLIN, .data = {.ptr = static_cast<void*>(&m_wakeData)} };
688 int maxevents = 1024;
689 uint64_t timeout = -1;
690 struct TestData testData {.fd = testFd, .expected = expected};
691
692 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
693 EXPECT_EQ(0, ret);
694
695 ffrt::submit([&]() {
696 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
697 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
698 result = ffrt_epoll_wait(qos_level, &ev, maxevents, timeout);
699 }, {}, {});
700 usleep(1000);
701 EXPECT_EQ(0, result);
702 }
703
HWTEST_F(ffrtIoTest, ffrt_epoll_ctl_op1, TestSize.Level1)704 HWTEST_F(ffrtIoTest, ffrt_epoll_ctl_op1, TestSize.Level1)
705 {
706 int op = EPOLL_CTL_ADD;
707 ffrt_qos_t qos = ffrt_qos_default;
708 uint64_t expected = 0xabacadae;
709 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
710 struct TestData testData {.fd = testFd, .expected = expected};
711
712 int ret = ffrt_epoll_ctl(qos, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
713 EXPECT_EQ(0, ret);
714 }
715
HWTEST_F(ffrtIoTest, ffrt_epoll_ctl_op3, TestSize.Level1)716 HWTEST_F(ffrtIoTest, ffrt_epoll_ctl_op3, TestSize.Level1)
717 {
718 int op = EPOLL_CTL_MOD;
719 ffrt_qos_t qos = ffrt_qos_default;
720 uint64_t expected = 0xabacadae;
721 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
722 struct TestData testData {.fd = testFd, .expected = expected};
723
724 ffrt_epoll_ctl(qos, EPOLL_CTL_ADD, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
725 int ret = ffrt_epoll_ctl(qos, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
726 EXPECT_EQ(0, ret);
727 }
728
HWTEST_F(ffrtIoTest, ffrt_epoll_ctl_op_invalid, TestSize.Level1)729 HWTEST_F(ffrtIoTest, ffrt_epoll_ctl_op_invalid, TestSize.Level1)
730 {
731 int op = 0;
732 ffrt_qos_t qos = ffrt_qos_default;
733 uint64_t expected = 0xabacadae;
734 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
735 struct TestData testData {.fd = testFd, .expected = expected};
736
737 int ret = ffrt_epoll_ctl(qos, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
738 EXPECT_EQ(-1, ret);
739 }
740
741 /**
742 * @tc.name: ffrt_epoll_wait_valid_with_thread_mode
743 * @tc.desc: Test ffrt_epoll_wait when valid in Thread mode
744 * @tc.type: FUNC
745 */
HWTEST_F(ffrtIoTest, ffrt_epoll_wait_valid_with_thread_mode, TestSize.Level1)746 HWTEST_F(ffrtIoTest, ffrt_epoll_wait_valid_with_thread_mode, TestSize.Level1)
747 {
748 uint64_t expected = 0xabacadae;
749 int testFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
750 struct WakeData m_wakeData;
751 m_wakeData.data = nullptr;
752 m_wakeData.fd = testFd;
753 ffrt_qos_t qos_level = ffrt_qos_user_initiated;
754 int op = EPOLL_CTL_ADD;
755 epoll_event ev = { .events = EPOLLIN, .data = {.ptr = static_cast<void*>(&m_wakeData)} };
756 int maxevents = 1024;
757 uint64_t timeout = 0;
758 int result = 0;
759 struct TestData testData {.fd = testFd, .expected = expected};
760
761
762 int ret = ffrt_epoll_ctl(qos_level, op, testFd, EPOLLIN, reinterpret_cast<void*>(&testData), testCallBack);
763 EXPECT_EQ(0, ret);
764
765 ffrt::submit([&]() {
766 ffrt_this_task_set_legacy_mode(true);
767 ssize_t n = write(testFd, &expected, sizeof(uint64_t));
768 EXPECT_EQ(sizeof(n), SIZEOF_BYTES);
769 result = ffrt_epoll_wait(qos_level, &ev, maxevents, timeout);
770 ffrt_this_task_set_legacy_mode(false);
771 }, {}, {});
772 usleep(1000);
773 EXPECT_EQ(0, result);
774 }