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
16 #include <unistd.h>
17 #include <pthread.h>
18 #include <semaphore.h>
19 #include <sys/resource.h>
20 #include <gtest/gtest.h>
21 #include "log.h"
22 #include "utils.h"
23 #include "mt_utils.h"
24 #include "KernelConstants.h"
25
26 using namespace testing::ext;
27 // global variables used to communicate between threads
28 static int g_policy = 0;
29 static int g_prioriy = 0;
30
31 class PthreadSchedApiTest : public testing::Test {
32 };
33 class PthreadAllPrioTest : public testing::TestWithParam<int> {
34 };
35
36 /**
37 * @tc.number SUB_KERNEL_SCHED_API_PATTR_INHERIT_0100
38 * @tc.name test the default value of inheritsched.
39 * @tc.desc [C- SOFTWARE -0200]
40 */
41 HWTEST_F(PthreadSchedApiTest, testAttrGetInheritsched, Function | MediumTest | Level1)
42 {
43 pthread_attr_t attr;
44 ASSERT_EQ(pthread_attr_init(&attr), 0);
45
46 int inheritsched = -1;
47 int rt = pthread_attr_getinheritsched(&attr, &inheritsched);
48 EXPECT_EQ(rt, 0) << "pthread_attr_getinheritsched failed. errno=" << errno;
49 EXPECT_EQ(inheritsched, PTHREAD_INHERIT_SCHED)
50 << "check default inheritsched failed. expect PTHREAD_INHERIT_SCHED";
51 }
52
53 /**
54 * @tc.number SUB_KERNEL_SCHED_API_PATTR_INHERIT_0200
55 * @tc.name test set and get inheritsched.
56 * @tc.desc [C- SOFTWARE -0200]
57 */
58 HWTEST_F(PthreadSchedApiTest, testAttrSetInheritsched, Function | MediumTest | Level1)
59 {
60 pthread_attr_t attr;
61 ASSERT_EQ(pthread_attr_init(&attr), 0);
62
63 int rt = pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);
64 EXPECT_EQ(rt, 0) << "pthread_attr_setinheritsched failed. errno=" << errno;
65 int inheritsched = -1;
66 rt = pthread_attr_getinheritsched(&attr, &inheritsched);
67 EXPECT_EQ(rt, 0) << "pthread_attr_getinheritsched failed. errno=" << errno;
68 EXPECT_EQ(inheritsched, PTHREAD_INHERIT_SCHED) << "check inheritsched failed";
69
70 rt = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
71 EXPECT_EQ(rt, 0) << "pthread_attr_setinheritsched failed. errno=" << errno;
72 inheritsched = -1;
73 rt = pthread_attr_getinheritsched(&attr, &inheritsched);
74 EXPECT_EQ(rt, 0) << "pthread_attr_getinheritsched failed. errno=" << errno;
75 EXPECT_EQ(inheritsched, PTHREAD_EXPLICIT_SCHED) << "check inheritsched failed";
76 }
77
78 /**
79 * @tc.number SUB_KERNEL_SCHED_API_PATTR_INHERIT_0300
80 * @tc.name pthread_attr_setinheritsched error test.
81 * @tc.desc [C- SOFTWARE -0200]
82 */
83 HWTEST_F(PthreadSchedApiTest, testAttrSetInheritschedError, Function | MediumTest | Level1)
84 {
85 pthread_attr_t attr;
86 ASSERT_EQ(pthread_attr_init(&attr), 0);
87
88 int n = -GetRandom(100);
89 int rt = pthread_attr_setinheritsched(&attr, n);
90 EXPECT_EQ(rt, EINVAL) << "pthread_attr_setinheritsched(" << n << ") should fail";
91 n = 2 + GetRandom(100);
92 rt = pthread_attr_setinheritsched(&attr, n);
93 EXPECT_EQ(rt, EINVAL) << "pthread_attr_setinheritsched(" << n << ") should fail";
94 }
95
96 /**
97 * @tc.number SUB_KERNEL_SCHED_API_PATTR_SCHEDPARAM_0100
98 * @tc.name test the default value of sched_param.
99 * @tc.desc [C- SOFTWARE -0200]
100 */
101 HWTEST_F(PthreadSchedApiTest, testAttrGetSchedParam, Function | MediumTest | Level1)
102 {
103 pthread_attr_t attr;
104 ASSERT_EQ(pthread_attr_init(&attr), 0);
105
106 struct sched_param param = {0};
107 int rt = pthread_attr_getschedparam(&attr, ¶m);
108 EXPECT_EQ(rt, 0) << "pthread_attr_getschedparam failed. errno=" << errno;
109 EXPECT_EQ(param.sched_priority, DEFAULT_THREAD_PRIORITY) << "check default pthread priority failed";
110 }
111
112 /**
113 * @tc.number SUB_KERNEL_SCHED_API_PATTR_SCHEDPARAM_0200
114 * @tc.name test set and get sched param.
115 * @tc.desc [C- SOFTWARE -0200]
116 */
117 HWTEST_F(PthreadSchedApiTest, testAttrSetSchedParam, Function | MediumTest | Level1)
118 {
119 pthread_attr_t attr;
120 ASSERT_EQ(pthread_attr_init(&attr), 0);
121
122 struct sched_param param = {0};
123 int rt = pthread_attr_getschedparam(&attr, ¶m);
124 EXPECT_EQ(rt, 0) << "pthread_attr_getschedparam failed. errno=" << errno;
125
126 param.sched_priority = 22;
127 rt = pthread_attr_setschedparam(&attr, ¶m);
128 EXPECT_EQ(rt, 0) << "pthread_attr_setschedparam failed. errno=" << errno;
129
130 rt = pthread_attr_getschedparam(&attr, ¶m);
131 EXPECT_EQ(rt, 0) << "pthread_attr_getschedparam failed. errno=" << errno;
132 EXPECT_EQ(param.sched_priority, 22) << "check pthread priority failed";
133 }
134
135 /**
136 * @tc.number SUB_KERNEL_SCHED_API_PATTR_SCHEDPARAM_0300
137 * @tc.name pthread_attr_setschedparam error test.
138 * @tc.desc [C- SOFTWARE -0200]
139 */
140 HWTEST_F(PthreadSchedApiTest, testAttrSetSchedParamError, Function | MediumTest | Level1)
141 {
142 pthread_attr_t attr;
143 ASSERT_EQ(pthread_attr_init(&attr), 0);
144
145 struct sched_param param = {0};
146 int rt = pthread_attr_getschedparam(&attr, ¶m);
147 EXPECT_EQ(rt, 0) << "pthread_attr_getschedparam failed. errno=" << errno;
148
149 param.sched_priority = LOWEST_USER_THREAD_PRIORITY + 1;
150 rt = pthread_attr_setschedparam(&attr, ¶m);
151 EXPECT_EQ(rt, EINVAL);
152 }
153
154 /**
155 * @tc.number SUB_KERNEL_SCHED_API_PATTR_SCHEDPOLICY_0100
156 * @tc.name test the default value of sched policy.
157 * @tc.desc [C- SOFTWARE -0200]
158 */
159 HWTEST_F(PthreadSchedApiTest, testAttrGetSchedPolicy, Function | MediumTest | Level1)
160 {
161 pthread_attr_t attr;
162 ASSERT_EQ(pthread_attr_init(&attr), 0);
163
164 int policy = -1;
165 int rt = pthread_attr_getschedpolicy(&attr, &policy);
166 EXPECT_EQ(rt, 0) << "pthread_attr_getschedpolicy failed. errno=" << errno;
167 EXPECT_EQ(policy, SCHED_RR) << "check default policy failed, expect SCHED_RR";
168 }
169
170 /**
171 * @tc.number SUB_KERNEL_SCHED_API_PATTR_SCHEDPOLICY_0200
172 * @tc.name test set and get sched policy.
173 * @tc.desc [C- SOFTWARE -0200]
174 */
175 HWTEST_F(PthreadSchedApiTest, testAttrSetSchedPolicy, Function | MediumTest | Level1)
176 {
177 pthread_attr_t attr;
178 ASSERT_EQ(pthread_attr_init(&attr), 0);
179
180 int rt = pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
181 EXPECT_EQ(rt, 0) << "pthread_attr_setschedparam failed. errno=" << errno;
182 int policy = -1;
183 rt = pthread_attr_getschedpolicy(&attr, &policy);
184 EXPECT_EQ(rt, 0) << "pthread_attr_getschedpolicy failed. errno=" << errno;
185 EXPECT_EQ(policy, SCHED_FIFO);
186
187 rt = pthread_attr_setschedpolicy(&attr, SCHED_RR);
188 EXPECT_EQ(rt, 0) << "pthread_attr_setschedparam failed. errno=" << errno;
189 rt = pthread_attr_getschedpolicy(&attr, &policy);
190 EXPECT_EQ(rt, 0) << "pthread_attr_getschedpolicy failed. errno=" << errno;
191 EXPECT_EQ(policy, SCHED_RR);
192 }
193
194 /**
195 * @tc.number SUB_KERNEL_SCHED_API_PATTR_SCHEDPOLICY_0300
196 * @tc.name pthread_attr_setschedpolicy error test.
197 * @tc.desc [C- SOFTWARE -0200]
198 */
199 HWTEST_F(PthreadSchedApiTest, testAttrSetSchedPolicyError, Function | MediumTest | Level1)
200 {
201 pthread_attr_t attr;
202 ASSERT_EQ(pthread_attr_init(&attr), 0);
203 int rt;
204
205 // SCHED_FIFO is 1, and SCHED_RR is 2
206 const int testLoop = 7;
207 int invalidPolicy[testLoop] = {SCHED_OTHER, SCHED_BATCH, SCHED_IDLE, SCHED_DEADLINE, SCHED_RESET_ON_FORK};
208 invalidPolicy[5] = -GetRandom(10000);
209 invalidPolicy[6] = GetRandom(10000) + 6;
210 for (int i = 0; i < testLoop; i++) {
211 rt = pthread_attr_setschedpolicy(&attr, invalidPolicy[i]);
212 EXPECT_EQ(rt, EINVAL) << "errno check fail for policy=" << invalidPolicy[i];
213 }
214 }
215
216 /**
217 * @tc.number SUB_KERNEL_SCHED_API_PATTR_SCOPE_0100
218 * @tc.name test the default value of sched scope.
219 * @tc.desc [C- SOFTWARE -0200]
220 */
221 HWTEST_F(PthreadSchedApiTest, testAttrGetScope, Function | MediumTest | Level1)
222 {
223 pthread_attr_t attr;
224 ASSERT_EQ(pthread_attr_init(&attr), 0);
225
226 int scope = -1;
227 int rt = pthread_attr_getscope(&attr, &scope);
228 EXPECT_EQ(rt, 0) << "pthread_attr_getscope failed. errno=" << errno;
229 EXPECT_EQ(scope, PTHREAD_SCOPE_PROCESS) << "check default scope failed. expect PTHREAD_SCOPE_PROCESS";
230 }
231
232 /**
233 * @tc.number SUB_KERNEL_SCHED_API_PATTR_SCOPE_0200
234 * @tc.name test set and get scope.
235 * @tc.desc [C- SOFTWARE -0200]
236 */
237 HWTEST_F(PthreadSchedApiTest, testAttrSetScope, Function | MediumTest | Level1)
238 {
239 pthread_attr_t attr;
240 ASSERT_EQ(pthread_attr_init(&attr), 0);
241
242 int rt = pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
243 EXPECT_EQ(rt, ENOTSUP); // liteos support PTHREAD_SCOPE_PROCESS only
244
245 rt = pthread_attr_setscope(&attr, -GetRandom(10000));
246 EXPECT_EQ(rt, EINVAL);
247
248 rt = pthread_attr_setscope(&attr, GetRandom(10000) + 2);
249 EXPECT_EQ(rt, EINVAL);
250
251 int scope = -1;
252 rt = pthread_attr_getscope(&attr, &scope);
253 EXPECT_EQ(rt, 0) << "pthread_attr_getscope failed. errno=" << errno;
254 EXPECT_EQ(scope, PTHREAD_SCOPE_PROCESS) << "check scope failed. expect PTHREAD_SCOPE_PROCESS";
255 }
256
ThreadFunc1(void * arg)257 void* ThreadFunc1(void* arg)
258 {
259 sem_t *sem = (sem_t*)arg;
260
261 int policy;
262 struct sched_param param = {0};
263 EXPECT_EQ(pthread_getschedparam(pthread_self(), &policy, ¶m), 0);
264 EXPECT_EQ(policy, g_policy);
265 EXPECT_EQ(param.sched_priority, g_prioriy);
266
267 LOG("wait main thread check this thread para...");
268 sem_wait(sem);
269 return nullptr;
270 }
271 /**
272 * @tc.number SUB_KERNEL_SCHED_API_PTHREAD_GETSCHEDPARAM_0100
273 * @tc.name pthread_getschedparam basic test.
274 * @tc.desc [C- SOFTWARE -0200]
275 */
276 HWTEST_F(PthreadSchedApiTest, testGetSchedParam, Function | MediumTest | Level1)
277 {
278 sem_t sem;
279 ASSERT_EQ(sem_init(&sem, 0, 0), 0) << "sem_init errno = " << errno;
280
281 pthread_t ptSub;
282 pthread_attr_t attr;
283 struct sched_param param = {0};
284 ASSERT_EQ(pthread_attr_init(&attr), 0);
285 g_policy = SCHED_FIFO;
286 param.sched_priority = g_prioriy = GetRandom(LOWEST_USER_THREAD_PRIORITY);
287
288 EXPECT_EQ(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED), 0);
289 EXPECT_EQ(pthread_attr_setschedpolicy(&attr, g_policy), 0);
290 EXPECT_EQ(pthread_attr_setschedparam(&attr, ¶m), 0);
291 int rt = pthread_create(&ptSub, &attr, ThreadFunc1, (void*)&sem);
292 ASSERT_EQ(rt, 0) << "pthread_create failed!";
293
294 LOG("check sub thread's para");
295 int policy;
296 EXPECT_EQ(pthread_getschedparam(ptSub, &policy, ¶m), 0);
297 EXPECT_EQ(policy, g_policy);
298 EXPECT_EQ(param.sched_priority, g_prioriy);
299
300 LOGD("main:before post sem...");
301 sem_post(&sem);
302 LOGD("main:after post sem...");
303 pthread_join(ptSub, nullptr);
304 }
305
306 /**
307 * @tc.number SUB_KERNEL_SCHED_API_PTHREAD_SETSCHEDPARAM_0100
308 * @tc.name pthread_setschedparam basic test.
309 * @tc.desc [C- SOFTWARE -0200]
310 */
311 HWTEST_P(PthreadAllPrioTest, testSetSchedParam, Function | MediumTest | Level1)
312 {
313 pthread_t ptSub;
314 pthread_t ptSelf = pthread_self();
315 sem_t sem;
316 ASSERT_EQ(sem_init(&sem, 0, 0), 0) << "sem_init errno = " << errno;
317
318 // change self sched para
319 struct sched_param param = {0};
320 int policy;
321 EXPECT_EQ(pthread_getschedparam(ptSelf, &policy, ¶m), 0);
322 param.sched_priority = g_prioriy = GetParam();
323 if (GetRandom(100)%2) {
324 policy = g_policy = SCHED_RR;
325 } else {
326 policy = g_policy = SCHED_FIFO;
327 }
328 LOG("========= Test policy(%d) and prioriy(%d) =========", g_policy, g_prioriy);
329
330 int rt = pthread_setschedparam(ptSelf, policy, ¶m);
331 ASSERT_EQ(rt, 0) << "pthread_setschedparam failed!";
332
333 LOG("create sub thread");
334 pthread_attr_t attr;
335 ASSERT_EQ(pthread_attr_init(&attr), 0);
336 EXPECT_EQ(pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED), 0);
337 rt = pthread_create(&ptSub, &attr, ThreadFunc1, (void*)&sem);
338 ASSERT_EQ(rt, 0) << "pthread_create failed!";
339
340 LOG("check self and sub thread's para");
341 EXPECT_EQ(pthread_getschedparam(ptSelf, &policy, ¶m), 0);
342 EXPECT_EQ(policy, g_policy);
343 EXPECT_EQ(param.sched_priority, g_prioriy);
344
345 EXPECT_EQ(pthread_getschedparam(ptSub, &policy, ¶m), 0);
346 EXPECT_EQ(policy, g_policy);
347 EXPECT_EQ(param.sched_priority, g_prioriy);
348
349 LOGD("main:before post sem...");
350 sem_post(&sem);
351 LOGD("main:after post sem...");
352 pthread_join(ptSub, nullptr);
353
354
355 LOG("restore...");
356 policy = SCHED_RR;
357 param.sched_priority = DEFAULT_THREAD_PRIORITY;
358 rt = pthread_setschedparam(ptSelf, policy, ¶m);
359 ASSERT_EQ(rt, 0) << "pthread_setschedparam failed!";
360 }
361 INSTANTIATE_TEST_CASE_P(PthreadSchedApiTest, PthreadAllPrioTest,
362 testing::Range(HIGHEST_USER_THREAD_PRIORITY, LOWEST_USER_THREAD_PRIORITY + 1));
363
ThrdFuncForSetSchedParamTest(void * arg)364 void* ThrdFuncForSetSchedParamTest(void* arg)
365 {
366 sem_t *sem = (sem_t*)arg;
367 pthread_t ptSelf = pthread_self();
368 int rt, policy;
369 struct sched_param param = {0};
370 EXPECT_EQ(pthread_getschedparam(ptSelf, &policy, ¶m), 0);
371
372 LOG("invalid policy test:");
373 const int testLoop = 7;
374 int invalidPolicy[testLoop] = {
375 SCHED_OTHER, SCHED_BATCH, SCHED_IDLE, SCHED_DEADLINE, SCHED_RESET_ON_FORK,
376 -(int)GetRandom(10000), (int)GetRandom(10000) + SCHED_DEADLINE
377 };
378 for (int i = 0; i < testLoop; i++) {
379 rt = pthread_setschedparam(ptSelf, invalidPolicy[i], ¶m);
380 EXPECT_EQ(rt, EINVAL) << "pthread_setschedparam should fail for policy=" << invalidPolicy[i];
381 }
382
383 LOG("invalid 'priority' test:");
384 param.sched_priority = HIGHEST_USER_THREAD_PRIORITY - 1;
385 EXPECT_EQ(pthread_setschedparam(ptSelf, SCHED_RR, ¶m), EINVAL);
386 param.sched_priority = LOWEST_USER_THREAD_PRIORITY + 1;
387 EXPECT_EQ(pthread_setschedparam(ptSelf, SCHED_RR, ¶m), EINVAL);
388
389 LOG("tell main thread check this thread para...");
390 sem_post(sem);
391 Msleep(100);
392 LOG("thread exit...");
393 return nullptr;
394 }
395 /**
396 * @tc.number SUB_KERNEL_SCHED_API_PTHREAD_SETSCHEDPARAM_0200
397 * @tc.name pthread_setschedparam api error test.
398 * @tc.desc [C- SOFTWARE -0200]
399 */
400 HWTEST_F(PthreadSchedApiTest, testSetSchedParamError, Function | MediumTest | Level3)
401 {
402 sem_t sem;
403 ASSERT_EQ(sem_init(&sem, 0, 0), 0) << "sem_init errno = " << errno;
404
405 pthread_t ptSub;
406 pthread_attr_t attr;
407 struct sched_param param = {0};
408 ASSERT_EQ(pthread_attr_init(&attr), 0);
409 g_policy = SCHED_FIFO;
410 param.sched_priority = g_prioriy = GetRandom(LOWEST_USER_THREAD_PRIORITY);
411
412 EXPECT_EQ(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED), 0);
413 EXPECT_EQ(pthread_attr_setschedpolicy(&attr, g_policy), 0);
414 EXPECT_EQ(pthread_attr_setschedparam(&attr, ¶m), 0);
415 int rt = pthread_create(&ptSub, &attr, ThrdFuncForSetSchedParamTest, (void*)&sem);
416 ASSERT_EQ(rt, 0) << "pthread_create failed!";
417
418 LOGD("main:wait sub-thread...");
419 sem_wait(&sem);
420 LOG("check sub thread's para doesn't changed");
421 int policy;
422 EXPECT_EQ(pthread_getschedparam(ptSub, &policy, ¶m), 0);
423 EXPECT_EQ(policy, g_policy);
424 EXPECT_EQ(param.sched_priority, g_prioriy);
425
426 pthread_join(ptSub, nullptr);
427 }
428
ThrdFuncForSetSchedPrioTest(void * arg)429 void* ThrdFuncForSetSchedPrioTest(void* arg)
430 {
431 sem_t *sem = (sem_t*)arg;
432 pthread_t ptSelf = pthread_self();
433
434 LOG("invalid 'priority' test:");
435 EXPECT_EQ(pthread_setschedprio(ptSelf, HIGHEST_USER_THREAD_PRIORITY - 1), EINVAL);
436 EXPECT_EQ(pthread_setschedprio(ptSelf, LOWEST_USER_THREAD_PRIORITY + 1), EINVAL);
437
438 LOG("valid 'priority' test:");
439 EXPECT_EQ(pthread_setschedprio(ptSelf, LOWEST_USER_THREAD_PRIORITY), 0);
440
441 LOG("tell main thread check this thread para...");
442 sem_post(sem);
443 Msleep(100);
444 LOG("thread exit...");
445 return nullptr;
446 }
447 /**
448 * @tc.number SUB_KERNEL_SCHED_API_PTHREAD_SETSCHEDPRIO_0100
449 * @tc.name pthread_setschedprio api basic test.
450 * @tc.desc [C- SOFTWARE -0200]
451 */
452 HWTEST_F(PthreadSchedApiTest, testSetSchedPrio, Function | MediumTest | Level1)
453 {
454 sem_t sem;
455 ASSERT_EQ(sem_init(&sem, 0, 0), 0) << "sem_init errno = " << errno;
456
457 pthread_t ptSub;
458 pthread_attr_t attr;
459 struct sched_param param = {0};
460 ASSERT_EQ(pthread_attr_init(&attr), 0);
461 g_policy = SCHED_RR;
462 param.sched_priority = g_prioriy = HIGHEST_USER_THREAD_PRIORITY;
463
464 EXPECT_EQ(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED), 0);
465 EXPECT_EQ(pthread_attr_setschedpolicy(&attr, g_policy), 0);
466 EXPECT_EQ(pthread_attr_setschedparam(&attr, ¶m), 0);
467 int rt = pthread_create(&ptSub, &attr, ThrdFuncForSetSchedPrioTest, (void*)&sem);
468 ASSERT_EQ(rt, 0) << "pthread_create failed!";
469
470 LOGD("main:wait sub-thread...");
471 sem_wait(&sem);
472 LOG("check sub thread's priority has changed");
473 int policy;
474 EXPECT_EQ(pthread_getschedparam(ptSub, &policy, ¶m), 0);
475 EXPECT_EQ(policy, g_policy);
476 EXPECT_EQ(param.sched_priority, LOWEST_USER_THREAD_PRIORITY);
477 pthread_join(ptSub, nullptr);
478 }
479
480 // second
ThreadTestFifoSched1(void * arg)481 void *ThreadTestFifoSched1(void *arg)
482 {
483 sem_t *sem = (sem_t*)arg;
484 EXPECT_EQ(sem_wait(sem), 0) << "sem_wait errno = " << errno;
485 CheckStep(3);
486 LOG("> This is ThreadSched1");
487 return arg;
488 }
489
490 // first
ThreadTestFifoSched2(void * arg)491 void *ThreadTestFifoSched2(void *arg)
492 {
493 sem_t *sem = (sem_t*)arg;
494 EXPECT_EQ(sem_wait(sem), 0) << "sem_wait errno = " << errno;
495 CheckStep(2);
496 LOG("> This is ThreadSched2");
497 return arg;
498 }
499
500 /**
501 * @tc.number SUB_KERNEL_SCHED_API_PTHREAD_SCHED_ALL_0100
502 * @tc.name test thread high ang low priority function
503 * @tc.desc [C- SOFTWARE -0200]
504 */
505 HWTEST_F(PthreadSchedApiTest, testSchedFifo, Function | MediumTest | Level3)
506 {
507 pthread_t tid1;
508 pthread_t tid2;
509 int param;
510 pthread_attr_t attr;
511 struct sched_param schedParam = {0};
512 sem_t sem;
513 CheckStep(1);
514
515 ASSERT_EQ(sem_init(&sem, 0, 0), 0) << "> sem_init errno = " << errno;
516
517 // low
518 EXPECT_EQ(pthread_attr_init(&attr), 0);
519 EXPECT_EQ(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED), 0) << "> return errno";
520 EXPECT_EQ(pthread_attr_setschedpolicy(&attr, SCHED_FIFO), 0) << "> return errno";
521 EXPECT_EQ(pthread_attr_getschedpolicy(&attr, ¶m), 0);
522 EXPECT_EQ(param, SCHED_FIFO);
523
524 schedParam.sched_priority = 22;
525 EXPECT_EQ(pthread_attr_setschedparam(&attr, &schedParam), 0) << "> return errno";
526
527 ASSERT_EQ(pthread_create(&tid1, &attr, ThreadTestFifoSched1, (void*)&sem), 0) << "> return errno";
528 EXPECT_EQ(pthread_attr_destroy(&attr), 0);
529
530 // high
531 EXPECT_EQ(pthread_attr_init(&attr), 0);
532 EXPECT_EQ(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED), 0) << "> return errno";
533 EXPECT_EQ(pthread_attr_setschedpolicy(&attr, SCHED_FIFO), 0) << "> return errno";
534
535 schedParam.sched_priority = 21;
536 EXPECT_EQ(pthread_attr_setschedparam(&attr, &schedParam), 0) << "> return errno";
537
538 ASSERT_EQ(pthread_create(&tid2, &attr, ThreadTestFifoSched2, (void*)&sem), 0) << "> return errno";
539 EXPECT_EQ(pthread_attr_destroy(&attr), 0);
540
541 Msleep(10);
542 EXPECT_EQ(sem_post(&sem), 0) << "sem_post errno = " << errno;
543 Msleep(10);
544 EXPECT_EQ(sem_post(&sem), 0) << "sem_post errno = " << errno;
545
546 EXPECT_EQ(pthread_join(tid1, nullptr), 0) << "> return errno";
547 EXPECT_EQ(pthread_join(tid2, nullptr), 0) << "> return errno";
548
549 EXPECT_EQ(CheckStep(4), 0x1234Ull); // make sure ThreadTestFifoSched2 ahead
550 }