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
17#include <unistd.h>
18#include <sys/resource.h>
19#include <sys/shm.h>
20#include <gtest/gtest.h>
21#include "log.h"
22#include "utils.h"
23#include "KernelConstants.h"
24#include "mt_utils.h"
25
26using namespace testing::ext;
27
28class ProcessSchedApiTest : public testing::Test {
29};
30
31/**
32 * @tc.number   SUB_KERNEL_SCHED_API_GETPRIORITY_0100
33 * @tc.name     getpriority api test.
34 * @tc.desc     [C- SOFTWARE -0200]
35 */
36HWTEST_F(ProcessSchedApiTest, testGetPriority, Function | MediumTest | Level1)
37{
38    int priority = getpriority(PRIO_PROCESS, INIT_PROCESS_ID);
39    EXPECT_EQ(priority, DEFAULT_INIT_PROCESS_PRIORITY) << "check 'init' priority failed.";
40    priority = getpriority(PRIO_PROCESS, KERNEL_PROCESS_ID);
41    EXPECT_EQ(priority, DEFAULT_KERNEL_PROCESS_PRIORITY) << "check 'KProcess' priority failed.";
42}
43
44/**
45 * @tc.number   SUB_KERNEL_SCHED_API_GETPRIORITY_0200
46 * @tc.name     getpriority error test with unsupport parameter 1.
47 * @tc.desc     [C- SOFTWARE -0200]
48 */
49HWTEST_F(ProcessSchedApiTest, testGetPriorityError0200, Function | MediumTest | Level3)
50{
51    LOG("invalid 'which' test:");
52    errno = 0;
53    int priority = getpriority(PRIO_PGRP, 0);
54    EXPECT_EQ(priority, -1);
55    EXPECT_EQ(errno, EINVAL);
56    errno = 0;
57    priority = getpriority(PRIO_USER, 0);
58    EXPECT_EQ(priority, -1);
59    EXPECT_EQ(errno, EINVAL);
60}
61
62/**
63 * @tc.number   SUB_KERNEL_SCHED_API_GETPRIORITY_0300
64 * @tc.name     getpriority error test with invalid parameter 1.
65 * @tc.desc     [C- SOFTWARE -0200]
66 */
67HWTEST_F(ProcessSchedApiTest, testGetPriorityError0300, Function | MediumTest | Level3)
68{
69    int priority;
70
71    LOG("invalid 'which' test:");
72    errno = 0;
73    priority = getpriority(PRIO_USER + GetRandom(1000), 0);
74    EXPECT_EQ(priority, -1);
75    EXPECT_EQ(errno, EINVAL);
76    errno = 0;
77    priority = getpriority(-GetRandom(1000), 0);
78    EXPECT_EQ(priority, -1);
79    EXPECT_EQ(errno, EINVAL);
80}
81
82/**
83 * @tc.number   SUB_KERNEL_SCHED_API_GETPRIORITY_0400
84 * @tc.name     getpriority error test with invalid parameter 2.
85 * @tc.desc     [C- SOFTWARE -0200]
86 */
87HWTEST_F(ProcessSchedApiTest, testGetPriorityError0400, Function | MediumTest | Level3)
88{
89    int priority;
90    LOG("invalid 'who' test:");
91    errno = 0;
92    priority = getpriority(PRIO_PROCESS, -1);
93    EXPECT_EQ(priority, -1);
94    EXPECT_EQ(errno, EINVAL);
95    errno = 0;
96    priority = getpriority(PRIO_PROCESS, MAX_PROCESS_NUMBER + 1);
97    EXPECT_EQ(priority, -1);
98    EXPECT_EQ(errno, EINVAL);
99    errno = 0;
100    priority = getpriority(PRIO_PROCESS, MAX_PROCESS_NUMBER + GetRandom(100000));
101    EXPECT_EQ(priority, -1);
102    EXPECT_EQ(errno, EINVAL);
103}
104
105/**
106 * @tc.number   SUB_KERNEL_SCHED_API_GETPRIORITY_0500
107 * @tc.name     getpriority error test with not exist parameter 2.
108 * @tc.desc     [C- SOFTWARE -0200]
109 */
110HWTEST_F(ProcessSchedApiTest, testGetPriorityError0500, Function | MediumTest | Level3)
111{
112    int priority;
113    LOG("invalid 'who' test:");
114    LOG("not exist pid test:");
115    pid_t nonExitPid = GetNonExistPid(); // valid but not exist pid
116    if (nonExitPid != -1) {
117        priority = getpriority(PRIO_PROCESS, nonExitPid);
118        EXPECT_EQ(priority, -1);
119        EXPECT_EQ(errno, ESRCH);
120    }
121}
122
123void SetPriorityAllTest()
124{
125    int rt, newPrio;
126    struct sched_param param;
127    LOG("test pid '0' and cover all supported priority:");
128    for (int prio = HIGHEST_USER_PROCESS_PRIORITY; prio <= LOWEST_USER_PROCESS_PRIORITY; prio++) {
129        rt = setpriority(PRIO_PROCESS, 0, prio);
130        EXPECT_EQ(rt, 0) << "setpriority failed for prio=" << prio << ", errno=" << errno;
131        newPrio = getpriority(PRIO_PROCESS, 0);
132        EXPECT_EQ(newPrio, prio);
133        rt = sched_getparam(getpid(), &param);
134        EXPECT_EQ(rt, 0);
135        newPrio = param.sched_priority;
136        EXPECT_EQ(newPrio, prio);
137    }
138    LOG("set back to default value:");
139    rt = setpriority(PRIO_PROCESS, getpid(), DEFAULT_SHELL_PROCESS_PRIORITY);
140    EXPECT_EQ(rt, 0);
141    newPrio = getpriority(PRIO_PROCESS, 0);
142    EXPECT_EQ(newPrio, DEFAULT_SHELL_PROCESS_PRIORITY);
143}
144/**
145* @tc.number     SUB_KERNEL_SCHED_API_SETPRIORITY_0100
146* @tc.name       test setpriority for all supported priority.
147 * @tc.desc     [C- SOFTWARE -0200]
148 */
149HWTEST_F(ProcessSchedApiTest, testSetPriority, Function | MediumTest | Level1)
150{
151    SetPriorityAllTest();
152}
153/**
154 * @tc.number   SUB_KERNEL_SCHED_API_SETPRIORITY_0200
155 * @tc.name     test setpriority for all supported priority, in RR mode
156 * @tc.desc     [C- SOFTWARE -0200]
157 */
158HWTEST_F(ProcessSchedApiTest, testSetPriorityFiFo, Function | MediumTest | Level3)
159{
160    LOG("change sched policy");
161    struct sched_param param;
162    int rt = sched_getparam(0, &param);
163    ASSERT_EQ(rt, 0) << "get sched param failed, errno=" << errno;
164
165    SetPriorityAllTest();
166
167    LOG("set back to RR");
168    rt = sched_setscheduler(0, SCHED_RR, &param);
169    ASSERT_EQ(rt, 0) << "set SCHED_RR failed, errno=" << errno;
170}
171
172/**
173 * @tc.number   SUB_KERNEL_SCHED_API_SETPRIORITY_0300
174 * @tc.name     setpriority error test with unsupport parameter 1.
175 * @tc.desc     [C- SOFTWARE -0200]
176 */
177HWTEST_F(ProcessSchedApiTest, testSetPriorityError0300, Function | MediumTest | Level3)
178{
179    const int testPrio = 18;
180    LOG("invalid 'which' test:");
181    errno = 0;
182    int rt = setpriority(PRIO_PGRP, 0, testPrio);
183    EXPECT_EQ(rt, -1);
184    EXPECT_EQ(errno, EINVAL);
185    errno = 0;
186    rt = setpriority(PRIO_USER, 0, testPrio);
187    EXPECT_EQ(rt, -1);
188    EXPECT_EQ(errno, EINVAL);
189}
190
191/**
192 * @tc.number   SUB_KERNEL_SCHED_API_SETPRIORITY_0400
193 * @tc.name     setpriority error test with invlid parameter 1.
194 * @tc.desc     [C- SOFTWARE -0200]
195 */
196HWTEST_F(ProcessSchedApiTest, testSetPriorityError0400, Function | MediumTest | Level3)
197{
198    const int testPrio = 18;
199    int rt;
200    LOG("invalid 'which' test:");
201    errno = 0;
202    rt = setpriority(PRIO_USER + GetRandom(1000), 0, testPrio);
203    EXPECT_EQ(rt, -1);
204    EXPECT_EQ(errno, EINVAL);
205    errno = 0;
206    rt = setpriority(-GetRandom(1000), 0, testPrio);
207    EXPECT_EQ(rt, -1);
208    EXPECT_EQ(errno, EINVAL);
209}
210
211/**
212 * @tc.number   SUB_KERNEL_SCHED_API_SETPRIORITY_0500
213 * @tc.name     setpriority error test with invalid parameter 2.
214 * @tc.desc     [C- SOFTWARE -0200]
215 */
216HWTEST_F(ProcessSchedApiTest, testSetPriorityError0500, Function | MediumTest | Level3)
217{
218    int rt;
219    const int testPrio = 18;
220    LOG("invalid 'pid' test:");
221    errno = 0;
222    rt = setpriority(PRIO_PROCESS, -1, testPrio);
223    EXPECT_EQ(rt, -1);
224    EXPECT_EQ(errno, EINVAL);
225    errno = 0;
226    rt = setpriority(PRIO_PROCESS, MAX_PROCESS_NUMBER + 1, testPrio);
227    EXPECT_EQ(rt, -1);
228    EXPECT_EQ(errno, EINVAL);
229    errno = 0;
230    rt = setpriority(PRIO_PROCESS, MAX_PROCESS_NUMBER + GetRandom(1000), testPrio);
231    EXPECT_EQ(rt, -1);
232    EXPECT_EQ(errno, EINVAL);
233}
234
235/**
236 * @tc.number   SUB_KERNEL_SCHED_API_SETPRIORITY_0600
237 * @tc.name     setpriority error test with not exist parameter 2.
238 * @tc.desc     [C- SOFTWARE -0200]
239 */
240HWTEST_F(ProcessSchedApiTest, testSetPriorityError0600, Function | MediumTest | Level3)
241{
242    const int testPrio = 18;
243    int rt;
244    LOG("not exist pid test:");
245    pid_t nonExitPid = GetNonExistPid(); // valid but not exist pid
246    if (nonExitPid != -1) {
247        rt = setpriority(PRIO_PROCESS, nonExitPid, testPrio);
248        EXPECT_EQ(rt, -1);
249        EXPECT_EQ(errno, ESRCH);
250    }
251}
252
253/**
254 * @tc.number   SUB_KERNEL_SCHED_API_SETPRIORITY_0700
255 * @tc.name     setpriority error test with invalid parameter 3.
256 * @tc.desc     [C- SOFTWARE -0200]
257 */
258HWTEST_F(ProcessSchedApiTest, testSetPriorityError0700, Function | MediumTest | Level3)
259{
260    int rt;
261    LOG("invalid 'priority' test:");
262    errno = 0;
263    rt = setpriority(PRIO_PROCESS, 0, -1);
264    EXPECT_EQ(rt, -1);
265    EXPECT_EQ(errno, EINVAL);
266    errno = 0;
267    rt = setpriority(PRIO_PROCESS, 0, -GetRandom(1000));
268    EXPECT_EQ(rt, -1);
269    EXPECT_EQ(errno, EINVAL);
270    errno = 0;
271    rt = setpriority(PRIO_PROCESS, 0, 0);
272    EXPECT_EQ(rt, -1);
273    EXPECT_EQ(errno, EINVAL);
274    errno = 0;
275    rt = setpriority(PRIO_PROCESS, 0, HIGHEST_USER_PROCESS_PRIORITY - 1);
276    EXPECT_EQ(rt, -1);
277    EXPECT_EQ(errno, EINVAL);
278    LOG("check the default priority not changed:");
279    int newPrio = getpriority(PRIO_PROCESS, 0);
280    if (newPrio != DEFAULT_SHELL_PROCESS_PRIORITY) {
281        rt = setpriority(PRIO_PROCESS, 0, DEFAULT_SHELL_PROCESS_PRIORITY);
282        EXPECT_EQ(rt, 0);
283        FAIL() << "setpriority failed but priority has changed";
284    }
285}
286
287/**
288 * @tc.number   SUB_KERNEL_SCHED_API_SETPRIORITY_0800
289 * @tc.name     setpriority error test with no permission.
290 * @tc.desc     [C- SOFTWARE -0200]
291 */
292HWTEST_F(ProcessSchedApiTest, testSetPriorityError0800, Function | MediumTest | Level3)
293{
294    const int testPrio = 18;
295    int rt;
296    LOG("no permission test:");
297    errno = 0;
298    rt = setpriority(PRIO_PROCESS, INIT_PROCESS_ID, testPrio);
299    EXPECT_EQ(rt, -1);
300    EXPECT_EQ(errno, EPERM);
301    errno = 0;
302    rt = setpriority(PRIO_PROCESS, KERNEL_PROCESS_ID, testPrio);
303    EXPECT_EQ(rt, -1);
304    EXPECT_EQ(errno, EPERM);
305}
306
307/**
308 * @tc.number   SUB_KERNEL_SCHED_API_SCHED_GETPARAM_0100
309 * @tc.name     sched_getparam api test.
310 * @tc.desc     [C- SOFTWARE -0200]
311 */
312HWTEST_F(ProcessSchedApiTest, testSchedGetParam, Function | MediumTest | Level1)
313{
314    struct sched_param param;
315    int rt = sched_getparam(0, &param);
316    EXPECT_EQ(rt, 0) << "sched_getparam failed, errno=" << errno;
317    EXPECT_EQ(param.sched_priority, DEFAULT_SHELL_PROCESS_PRIORITY);
318
319    rt = sched_getparam(getpid(), &param);
320    EXPECT_EQ(rt, 0) << "sched_getparam failed, errno=" << errno;
321    EXPECT_EQ(param.sched_priority, DEFAULT_SHELL_PROCESS_PRIORITY);
322
323    rt = sched_getparam(INIT_PROCESS_ID, &param);
324    EXPECT_EQ(rt, 0) << "sched_getparam failed, errno=" << errno;
325    EXPECT_EQ(param.sched_priority, DEFAULT_INIT_PROCESS_PRIORITY);
326
327    rt = sched_getparam(KERNEL_PROCESS_ID, &param);
328    EXPECT_EQ(rt, 0) << "sched_getparam failed, errno=" << errno;
329    EXPECT_EQ(param.sched_priority, DEFAULT_KERNEL_PROCESS_PRIORITY);
330}
331
332/**
333 * @tc.number   SUB_KERNEL_SCHED_API_SCHED_GETPARAM_0200
334 * @tc.name     sched_getparam error test with invalid parameter 1.
335 * @tc.desc     [C- SOFTWARE -0200]
336 */
337HWTEST_F(ProcessSchedApiTest, testSchedGetParamError0200, Function | MediumTest | Level3)
338{
339    struct sched_param param;
340    LOG("invalid 'pid' test:");
341    errno = 0;
342    int rt = sched_getparam(-1, &param);
343    EXPECT_EQ(rt, -1);
344    EXPECT_EQ(errno, EINVAL);
345    errno = 0;
346    rt = sched_getparam(MAX_PROCESS_NUMBER + 1, &param);
347    EXPECT_EQ(rt, -1);
348    EXPECT_EQ(errno, EINVAL);
349    errno = 0;
350    rt = sched_getparam(MAX_PROCESS_NUMBER + GetRandom(100000), &param);
351    EXPECT_EQ(rt, -1);
352    EXPECT_EQ(errno, EINVAL);
353}
354
355/**
356 * @tc.number   SUB_KERNEL_SCHED_API_SCHED_GETPARAM_0300
357 * @tc.name     sched_getparam error test with not exist pid.
358 * @tc.desc     [C- SOFTWARE -0200]
359 */
360HWTEST_F(ProcessSchedApiTest, testSchedGetParamError0300, Function | MediumTest | Level3)
361{
362    struct sched_param param;
363    int rt;
364    LOG("not exist pid test:");
365    pid_t nonExitPid = GetNonExistPid(); // valid but not exist pid
366    if (nonExitPid != -1) {
367        rt = sched_getparam(nonExitPid, &param);
368        EXPECT_EQ(rt, -1);
369        EXPECT_EQ(errno, ESRCH);
370    }
371}
372
373/**
374 * @tc.number   SUB_KERNEL_SCHED_API_SCHED_GETPARAM_0400
375 * @tc.name     sched_getparam error test with invalid parameter 2.
376 * @tc.desc     [C- SOFTWARE -0200]
377 */
378HWTEST_F(ProcessSchedApiTest, testSchedGetParamError0400, Function | MediumTest | Level3)
379{
380    int rt;
381    LOG("invalid 'param' test:");
382    rt = sched_getparam(0, NULL);
383    EXPECT_EQ(rt, -1);
384    EXPECT_EQ(errno, EINVAL);
385}
386
387void SchedSetParamAllTest()
388{
389    int rt, newPrio;
390    struct sched_param param;
391    LOG("test all supported priority:");
392    for (int prio = HIGHEST_USER_PROCESS_PRIORITY; prio <= LOWEST_USER_PROCESS_PRIORITY; prio++) {
393        param.sched_priority = prio;
394        rt = sched_setparam(0, &param);
395        EXPECT_EQ(rt, 0) << "sched_setparam failed for prio=" << prio << ", errno=" << errno;
396        newPrio = getpriority(PRIO_PROCESS, getpid());
397        EXPECT_EQ(prio, newPrio);
398        rt = sched_getparam(0, &param);
399        EXPECT_EQ(rt, 0);
400        EXPECT_EQ(prio, param.sched_priority);
401    }
402    LOG("set back to default value:");
403    param.sched_priority = DEFAULT_SHELL_PROCESS_PRIORITY;
404    rt = sched_setparam(getpid(), &param);
405    EXPECT_EQ(rt, 0);
406    newPrio = getpriority(PRIO_PROCESS, 0);
407    EXPECT_EQ(newPrio, DEFAULT_SHELL_PROCESS_PRIORITY);
408}
409/**
410 * @tc.number   SUB_KERNEL_SCHED_API_SCHED_SETPARAM_0100
411 * @tc.name     test sched_setparam for all supported priority.
412 * @tc.desc     [C- SOFTWARE -0200]
413 */
414HWTEST_F(ProcessSchedApiTest, testSchedSetParam, Function | MediumTest | Level1)
415{
416    SchedSetParamAllTest();
417}
418/**
419 * @tc.number   SUB_KERNEL_SCHED_API_SCHED_SETPARAM_0200
420 * @tc.name     test sched_setparam for all supported priority, in FIFO mode
421 * @tc.desc     [C- SOFTWARE -0200]
422 */
423HWTEST_F(ProcessSchedApiTest, testSchedSetParamFiFo, Function | MediumTest | Level3)
424{
425    struct sched_param param;
426    int rt = sched_getparam(0, &param);
427    ASSERT_EQ(rt, 0) << "get sched param failed, errno=" << errno;
428
429    SchedSetParamAllTest();
430
431    LOG("set to RR");
432    rt = sched_setscheduler(0, SCHED_RR, &param);
433    ASSERT_EQ(rt, 0) << "set SCHED_RR failed, errno=" << errno;
434}
435
436/**
437 * @tc.number   SUB_KERNEL_SCHED_API_SCHED_SETPARAM_0300
438 * @tc.name     sched_setparam error test with invalid pid.
439 * @tc.desc     [C- SOFTWARE -0200]
440 */
441HWTEST_F(ProcessSchedApiTest, testSchedSetParamError0300, Function | MediumTest | Level3)
442{
443    int rt;
444    struct sched_param param;
445    param.sched_priority = 18;
446
447    LOG("invalid 'pid' test:");
448    errno = 0;
449    rt = sched_setparam(-1, &param);
450    EXPECT_EQ(rt, -1);
451    EXPECT_EQ(errno, EINVAL);
452    errno = 0;
453    rt = sched_setparam(MAX_PROCESS_NUMBER + 1, &param);
454    EXPECT_EQ(rt, -1);
455    EXPECT_EQ(errno, EINVAL);
456    errno = 0;
457    rt = sched_setparam(MAX_PROCESS_NUMBER + GetRandom(100000), &param);
458    EXPECT_EQ(rt, -1);
459    EXPECT_EQ(errno, EINVAL);
460}
461
462/**
463 * @tc.number   SUB_KERNEL_SCHED_API_SCHED_SETPARAM_0400
464 * @tc.name     sched_setparam error test with not exist pid.
465 * @tc.desc     [C- SOFTWARE -0200]
466 */
467HWTEST_F(ProcessSchedApiTest, testSchedSetParamError0400, Function | MediumTest | Level3)
468{
469    int rt;
470    struct sched_param param;
471    param.sched_priority = 18;
472
473    LOG("not exist pid test:");
474    pid_t nonExitPid = GetNonExistPid(); // valid but not exist pid
475    if (nonExitPid != -1) {
476        rt = sched_setparam(nonExitPid, &param);
477        EXPECT_EQ(rt, -1);
478        EXPECT_EQ(errno, ESRCH);
479    }
480}
481
482/**
483 * @tc.number   SUB_KERNEL_SCHED_API_SCHED_SETPARAM_0500
484 * @tc.name     sched_setparam error test with invalid parameter 2.
485 * @tc.desc     [C- SOFTWARE -0200]
486 */
487HWTEST_F(ProcessSchedApiTest, testSchedSetParamError0500, Function | MediumTest | Level3)
488{
489    int rt;
490    LOG("invalid 'param' test:");
491    rt = sched_setparam(0, NULL);
492    EXPECT_EQ(rt, -1);
493    EXPECT_EQ(errno, EINVAL);
494}
495
496/**
497 * @tc.number   SUB_KERNEL_SCHED_API_SCHED_SETPARAM_0600
498 * @tc.name     sched_setparam error test with invalid priority.
499 * @tc.desc     [C- SOFTWARE -0200]
500 */
501HWTEST_F(ProcessSchedApiTest, testSchedSetParamError0600, Function | MediumTest | Level3)
502{
503    int rt;
504    struct sched_param param;
505    param.sched_priority = 18;
506
507    LOG("invalid 'priority' test:");
508    errno = 0;
509    param.sched_priority = -1;
510    rt = sched_setparam(0, &param);
511    EXPECT_EQ(rt, -1);
512    EXPECT_EQ(errno, EINVAL);
513    errno = 0;
514    param.sched_priority = -GetRandom(1000);
515    rt = sched_setparam(0, &param);
516    EXPECT_EQ(rt, -1);
517    EXPECT_EQ(errno, EINVAL);
518    errno = 0;
519    param.sched_priority = 0;
520    rt = sched_setparam(0, &param);
521    EXPECT_EQ(rt, -1);
522    EXPECT_EQ(errno, EINVAL);
523    errno = 0;
524    param.sched_priority = HIGHEST_USER_PROCESS_PRIORITY - 1;
525    rt = sched_setparam(0, &param);
526    EXPECT_EQ(rt, -1);
527    EXPECT_EQ(errno, EINVAL);
528
529    LOG("check the default priority not changed:");
530    int newPrio = getpriority(PRIO_PROCESS, 0);
531    if (newPrio != DEFAULT_SHELL_PROCESS_PRIORITY) {
532        rt = setpriority(PRIO_PROCESS, 0, DEFAULT_SHELL_PROCESS_PRIORITY);
533        EXPECT_EQ(rt, 0);
534        FAIL() << "sched_setparam failed but priority has changed";
535    }
536}
537
538/**
539 * @tc.number   SUB_KERNEL_SCHED_API_SCHED_SETPARAM_0700
540 * @tc.name     sched_setparam error test with no permission.
541 * @tc.desc     [C- SOFTWARE -0200]
542 */
543HWTEST_F(ProcessSchedApiTest, testSchedSetParamError0700, Function | MediumTest | Level3)
544{
545    int rt;
546    struct sched_param param;
547    param.sched_priority = 18;
548
549    LOG("no permission test:");
550    errno = 0;
551    rt = sched_setparam(INIT_PROCESS_ID, &param);
552    EXPECT_EQ(rt, -1);
553    EXPECT_EQ(errno, EPERM);
554    errno = 0;
555    rt = sched_setparam(KERNEL_PROCESS_ID, &param);
556    EXPECT_EQ(rt, -1);
557    EXPECT_EQ(errno, EPERM);
558
559    LOG("check the default priority not changed:");
560    int newPrio = getpriority(PRIO_PROCESS, 0);
561    if (newPrio != DEFAULT_SHELL_PROCESS_PRIORITY) {
562        rt = setpriority(PRIO_PROCESS, 0, DEFAULT_SHELL_PROCESS_PRIORITY);
563        EXPECT_EQ(rt, 0);
564        FAIL() << "sched_setparam failed but priority has changed";
565    }
566}
567
568/**
569 * @tc.number   SUB_KERNEL_SCHED_API_GET_PRIORITY_MAX_0100
570 * @tc.name     sched_get_priority_max api test.
571 * @tc.desc     [C- SOFTWARE -0200]
572 */
573HWTEST_F(ProcessSchedApiTest, testSchedGetPriorityMax, Function | MediumTest | Level3)
574{
575    int prio = sched_get_priority_max(SCHED_RR);
576    EXPECT_EQ(prio, LOWEST_USER_PROCESS_PRIORITY);
577}
578
579/**
580 * @tc.number   SUB_KERNEL_SCHED_API_GET_PRIORITY_MAX_0200
581 * @tc.name     sched_get_priority_max api error test with unsupport policy.
582 * @tc.desc     [C- SOFTWARE -0200]
583 */
584HWTEST_F(ProcessSchedApiTest, testSchedGetPriorityMaxError0200, Function | MediumTest | Level3)
585{
586    // SCHED_RR is 2
587    int invalidPolicy[] = {SCHED_FIFO, SCHED_OTHER, SCHED_BATCH, SCHED_IDLE, SCHED_DEADLINE, SCHED_RESET_ON_FORK};
588    int testLoop = sizeof(invalidPolicy)/sizeof(int);
589    for (int i = 0; i < testLoop; i++) {
590        errno = 0;
591        int prio = sched_get_priority_max(invalidPolicy[i]);
592        EXPECT_EQ(prio, -1) << "sched_get_priority_max ok for policy=" << invalidPolicy[i];
593        EXPECT_EQ(errno, EINVAL) << "errno check fail for policy=" << invalidPolicy[i];
594    }
595}
596
597/**
598 * @tc.number   SUB_KERNEL_SCHED_API_GET_PRIORITY_MAX_0300
599 * @tc.name     sched_get_priority_max api error test with invalid policy.
600 * @tc.desc     [C- SOFTWARE -0200]
601 */
602HWTEST_F(ProcessSchedApiTest, testSchedGetPriorityMaxError0300, Function | MediumTest | Level3)
603{
604    // SCHED_RR is 2
605    int invalidPolicyVal;
606    int prio;
607
608    invalidPolicyVal = -GetRandom(10000);
609    errno = 0;
610    prio = sched_get_priority_max(invalidPolicyVal);
611    EXPECT_EQ(prio, -1) << "sched_get_priority_max ok for policy=" << invalidPolicyVal;
612    EXPECT_EQ(errno, EINVAL) << "errno check fail for policy=" << invalidPolicyVal;
613
614    invalidPolicyVal = GetRandom(10000) + SCHED_DEADLINE;
615    errno = 0;
616    prio = sched_get_priority_max(invalidPolicyVal);
617    EXPECT_EQ(prio, -1) << "sched_get_priority_max ok for policy=" << invalidPolicyVal;
618    EXPECT_EQ(errno, EINVAL) << "errno check fail for policy=" << invalidPolicyVal;
619}
620
621/**
622 * @tc.number   SUB_KERNEL_SCHED_API_GET_PRIORITY_MIN_0100
623 * @tc.name     sched_get_priority_min api test.
624 * @tc.desc     [C- SOFTWARE -0200]
625 */
626HWTEST_F(ProcessSchedApiTest, testSchedGetPriorityMin, Function | MediumTest | Level3)
627{
628    int prio = sched_get_priority_min(SCHED_RR);
629    EXPECT_EQ(prio, HIGHEST_USER_PROCESS_PRIORITY);
630}
631
632/**
633 * @tc.number   SUB_KERNEL_SCHED_API_GET_PRIORITY_MIN_0200
634 * @tc.name     sched_get_priority_min api error test with unsupport policy.
635 * @tc.desc     [C- SOFTWARE -0200]
636 */
637HWTEST_F(ProcessSchedApiTest, testSchedGetPriorityMinError0200, Function | MediumTest | Level3)
638{
639    //  SCHED_RR is 2
640    int invalidPolicy[] = {SCHED_FIFO, SCHED_OTHER, SCHED_BATCH, SCHED_IDLE, SCHED_DEADLINE, SCHED_RESET_ON_FORK};
641    int testLoop = sizeof(invalidPolicy)/sizeof(int);
642    for (int i = 0; i < testLoop; i++) {
643        errno = 0;
644        int prio = sched_get_priority_min(invalidPolicy[i]);
645        EXPECT_EQ(prio, -1) << "sched_get_priority_min ok for policy=" << invalidPolicy[i];
646        EXPECT_EQ(errno, EINVAL) << "errno check fail for policy=" << invalidPolicy[i];
647    }
648}
649
650/**
651 * @tc.number   SUB_KERNEL_SCHED_API_GET_PRIORITY_MIN_0300
652 * @tc.name     sched_get_priority_min api error test with invalid policy.
653 * @tc.desc     [C- SOFTWARE -0200]
654 */
655HWTEST_F(ProcessSchedApiTest, testSchedGetPriorityMinError0300, Function | MediumTest | Level3)
656{
657    int invalidPolicyVal;
658    int prio;
659    invalidPolicyVal = -GetRandom(10000);
660    errno = 0;
661    prio = sched_get_priority_min(invalidPolicyVal);
662    EXPECT_EQ(prio, -1) << "sched_get_priority_min ok for policy=" << invalidPolicyVal;
663    EXPECT_EQ(errno, EINVAL) << "errno check fail for policy=" << invalidPolicyVal;
664
665    invalidPolicyVal = GetRandom(10000) + SCHED_DEADLINE;
666    errno = 0;
667    prio = sched_get_priority_min(invalidPolicyVal);
668    EXPECT_EQ(prio, -1) << "sched_get_priority_min ok for policy=" << invalidPolicyVal;
669    EXPECT_EQ(errno, EINVAL) << "errno check fail for policy=" << invalidPolicyVal;
670}
671
672/**
673 * @tc.number   SUB_KERNEL_SCHED_API_GETSCHEDULER_0100
674 * @tc.name     sched_getscheduler api test.
675 * @tc.desc     [C- SOFTWARE -0200]
676 */
677HWTEST_F(ProcessSchedApiTest, testSchedGetScheduler, Function | MediumTest | Level1)
678{
679    int policy = sched_getscheduler(0);
680    EXPECT_EQ(policy, SCHED_RR);
681    policy = sched_getscheduler(getpid());
682    EXPECT_EQ(policy, SCHED_RR) << "check 'shell' policy failed.";
683    policy = sched_getscheduler(INIT_PROCESS_ID);
684    EXPECT_EQ(policy, SCHED_RR) << "check 'init' policy failed.";
685    policy = sched_getscheduler(KERNEL_PROCESS_ID);
686    EXPECT_EQ(policy, SCHED_RR) << "check 'KProcess' policy failed.";
687}
688
689/**
690 * @tc.number   SUB_KERNEL_SCHED_API_GETSCHEDULER_0200
691 * @tc.name     sched_getscheduler api error test with invalid pid.
692 * @tc.desc     [C- SOFTWARE -0200]
693 */
694HWTEST_F(ProcessSchedApiTest, testSchedGetSchedulerError0200, Function | MediumTest | Level1)
695{
696    LOG("invalid pid test:");
697    errno = 0;
698    int rt = sched_getscheduler(-1);
699    EXPECT_EQ(rt, -1);
700    EXPECT_EQ(errno, EINVAL);
701    errno = 0;
702    rt = sched_getscheduler(MAX_PROCESS_NUMBER + 1);
703    EXPECT_EQ(rt, -1);
704    EXPECT_EQ(errno, EINVAL);
705    errno = 0;
706    rt = sched_getscheduler(MAX_PROCESS_NUMBER + GetRandom(1000));
707    EXPECT_EQ(rt, -1);
708    EXPECT_EQ(errno, EINVAL);
709}
710
711/**
712 * @tc.number   SUB_KERNEL_SCHED_API_GETSCHEDULER_0300
713 * @tc.name     sched_getscheduler api error test with not exist pid.
714 * @tc.desc     [C- SOFTWARE -0200]
715 */
716HWTEST_F(ProcessSchedApiTest, testSchedGetSchedulerError0300, Function | MediumTest | Level1)
717{
718    int rt;
719    errno = 0;
720    LOG("not exist pid test:");
721    pid_t nonExitPid = GetNonExistPid(); // valid but not exist pid
722    if (nonExitPid != -1) {
723        rt = sched_getscheduler(nonExitPid);
724        EXPECT_EQ(rt, -1);
725        EXPECT_EQ(errno, ESRCH);
726    }
727}
728
729/**
730 * @tc.number   SUB_KERNEL_SCHED_API_SETSCHEDULER_0100
731 * @tc.name     sched_setscheduler api test.
732 * @tc.desc     [C- SOFTWARE -0200]
733 */
734HWTEST_F(ProcessSchedApiTest, testSchedSetScheduler, Function | MediumTest | Level1)
735{
736    struct sched_param param;
737    int rt = sched_getparam(0, &param);
738    ASSERT_EQ(rt, 0) << "get sched param failed, errno=" << errno;
739
740    LOG("change policy and priority:");
741    rt = sched_setscheduler(0, SCHED_RR, &param);
742    ASSERT_EQ(rt, 0) << "set RR failed, errno=" << errno;
743    int policy = sched_getscheduler(0);
744    EXPECT_EQ(policy, SCHED_RR);
745    rt = sched_setscheduler(getpid(), SCHED_RR, &param);
746    EXPECT_EQ(rt, 0) << "set RR again failed, errno=" << errno;
747    policy = sched_getscheduler(0);
748    EXPECT_EQ(policy, SCHED_RR);
749
750    param.sched_priority = LOWEST_USER_PROCESS_PRIORITY;
751    rt = sched_setscheduler(getpid(), SCHED_RR, &param);
752    EXPECT_EQ(rt, 0) << "set RR again failed, errno=" << errno;
753    policy = sched_getscheduler(0);
754    EXPECT_EQ(policy, SCHED_RR);
755    int newPrio = getpriority(PRIO_PROCESS, 0);
756    EXPECT_EQ(newPrio, LOWEST_USER_PROCESS_PRIORITY);
757
758    LOG("set back to SCHED_RR and default priority:");
759    param.sched_priority = DEFAULT_SHELL_PROCESS_PRIORITY;
760    rt = sched_setscheduler(getpid(), SCHED_RR, &param);
761    EXPECT_EQ(rt, 0) << "set back to SCHED_RR failed, errno=" << errno;
762    policy = sched_getscheduler(0);
763    EXPECT_EQ(policy, SCHED_RR);
764}
765
766/**
767 * @tc.number   SUB_KERNEL_SCHED_API_SETSCHEDULER_0200
768 * @tc.name     sched_setscheduler api error test with invalid pid.
769 * @tc.desc     [C- SOFTWARE -0200]
770 */
771HWTEST_F(ProcessSchedApiTest, testSchedSetSchedulerError0200, Function | MediumTest | Level1)
772{
773    struct sched_param param;
774    int rt = sched_getparam(0, &param);
775    ASSERT_EQ(rt, 0) << "get sched param failed, errno=" << errno;
776
777    LOG("invalid pid test:");
778    errno = 0;
779    rt = sched_setscheduler(-1, SCHED_RR, &param);
780    EXPECT_EQ(rt, -1);
781    EXPECT_EQ(errno, EINVAL);
782    errno = 0;
783    rt = sched_setscheduler(MAX_PROCESS_NUMBER + 1, SCHED_RR, &param);
784    EXPECT_EQ(rt, -1);
785    EXPECT_EQ(errno, EINVAL);
786    errno = 0;
787    rt = sched_setscheduler(MAX_PROCESS_NUMBER + GetRandom(1000), SCHED_RR, &param);
788    EXPECT_EQ(rt, -1);
789    EXPECT_EQ(errno, EINVAL);
790}
791
792/**
793 * @tc.number   SUB_KERNEL_SCHED_API_SETSCHEDULER_0300
794 * @tc.name     sched_setscheduler api error test with not exist pid.
795 * @tc.desc     [C- SOFTWARE -0200]
796 */
797HWTEST_F(ProcessSchedApiTest, testSchedSetSchedulerError0300, Function | MediumTest | Level1)
798{
799    struct sched_param param;
800    int rt = sched_getparam(0, &param);
801    ASSERT_EQ(rt, 0) << "get sched param failed, errno=" << errno;
802
803    LOG("not exist pid test:");
804    pid_t nonExitPid = GetNonExistPid(); // valid but not exist pid
805    if (nonExitPid != -1) {
806        rt = sched_setscheduler(nonExitPid, SCHED_RR, &param);
807        EXPECT_EQ(rt, -1);
808        EXPECT_EQ(errno, ESRCH);
809    }
810}
811
812/**
813 * @tc.number   SUB_KERNEL_SCHED_API_SETSCHEDULER_0400
814 * @tc.name     sched_setscheduler api error test with unsupport policy.
815 * @tc.desc     [C- SOFTWARE -0200]
816 */
817HWTEST_F(ProcessSchedApiTest, testSchedSetSchedulerError0400, Function | MediumTest | Level1)
818{
819    struct sched_param param;
820    int rt = sched_getparam(0, &param);
821    ASSERT_EQ(rt, 0) << "get sched param failed, errno=" << errno;
822
823    LOG("invalid policy test:");
824    //and SCHED_RR is 2
825    int invalidPolicy[] = {SCHED_FIFO, SCHED_OTHER, SCHED_BATCH, SCHED_IDLE, SCHED_DEADLINE, SCHED_RESET_ON_FORK};
826    int testLoop = sizeof(invalidPolicy)/sizeof(int);
827    for (int i = 0; i < testLoop; i++) {
828        errno = 0;
829        rt = sched_setscheduler(0, invalidPolicy[i], &param);
830        EXPECT_EQ(rt, -1) << "sched_get_priority_min ok for policy=" << invalidPolicy[i];
831        EXPECT_EQ(errno, EINVAL) << "errno check fail for policy=" << invalidPolicy[i];
832    }
833
834    LOG("check the default priority not changed:");
835    int policy = sched_getscheduler(0);
836    if (policy != SCHED_RR) {
837        rt = sched_setscheduler(0, SCHED_RR, &param);
838        EXPECT_EQ(rt, 0);
839        FAIL() << "sched_setscheduler failed but policy has changed";
840    }
841}
842
843/**
844 * @tc.number   SUB_KERNEL_SCHED_API_SETSCHEDULER_0500
845 * @tc.name     sched_setscheduler api error test with invalid policy.
846 * @tc.desc     [C- SOFTWARE -0200]
847 */
848HWTEST_F(ProcessSchedApiTest, testSchedSetSchedulerError0500, Function | MediumTest | Level1)
849{
850    struct sched_param param;
851    int rt = sched_getparam(0, &param);
852    ASSERT_EQ(rt, 0) << "get sched param failed, errno=" << errno;
853
854    LOG("invalid policy test:");
855    int invalidPolicy = -GetRandom(10000);
856    errno = 0;
857    rt = sched_setscheduler(0, invalidPolicy, &param);
858    EXPECT_EQ(rt, -1) << "sched_get_priority_min ok for policy=" << invalidPolicy;
859    EXPECT_EQ(errno, EINVAL) << "errno check fail for policy=" << invalidPolicy;
860    invalidPolicy = GetRandom(10000) + SCHED_DEADLINE;
861    errno = 0;
862    rt = sched_setscheduler(0, invalidPolicy, &param);
863    EXPECT_EQ(rt, -1) << "sched_get_priority_min ok for policy=" << invalidPolicy;
864    EXPECT_EQ(errno, EINVAL) << "errno check fail for policy=" << invalidPolicy;
865
866    LOG("check the default priority not changed:");
867    int policy = sched_getscheduler(0);
868    if (policy != SCHED_RR) {
869        rt = sched_setscheduler(0, SCHED_RR, &param);
870        EXPECT_EQ(rt, 0);
871        FAIL() << "sched_setscheduler failed but policy has changed";
872    }
873}
874
875/**
876 * @tc.number   SUB_KERNEL_SCHED_API_SETSCHEDULER_0600
877 * @tc.name     sched_setscheduler api error test with invalid parameter.
878 * @tc.desc     [C- SOFTWARE -0200]
879 */
880HWTEST_F(ProcessSchedApiTest, testSchedSetSchedulerError0600, Function | MediumTest | Level1)
881{
882    struct sched_param param;
883    int rt = sched_getparam(0, &param);
884    ASSERT_EQ(rt, 0) << "get sched param failed, errno=" << errno;
885
886    LOG("invalid param test:");
887    rt = sched_setscheduler(0, SCHED_RR, NULL);
888    EXPECT_EQ(rt, -1);
889    EXPECT_EQ(errno, EINVAL);
890}
891
892/**
893 * @tc.number   SUB_KERNEL_SCHED_API_SETSCHEDULER_0700
894 * @tc.name     sched_setscheduler api error test with no permission.
895 * @tc.desc     [C- SOFTWARE -0200]
896 */
897HWTEST_F(ProcessSchedApiTest, testSchedSetSchedulerError0700, Function | MediumTest | Level1)
898{
899    struct sched_param param;
900    int rt = sched_getparam(0, &param);
901    ASSERT_EQ(rt, 0) << "get sched param failed, errno=" << errno;
902
903    LOG("no permission test:");
904    errno = 0;
905    rt = sched_setscheduler(INIT_PROCESS_ID, SCHED_RR, &param);
906    EXPECT_EQ(rt, -1);
907    EXPECT_EQ(errno, EPERM);
908    errno = 0;
909    rt = sched_setscheduler(KERNEL_PROCESS_ID, SCHED_RR, &param);
910    EXPECT_EQ(rt, -1);
911    EXPECT_EQ(errno, EPERM);
912}
913
914/**
915* @tc.number     SUB_KERNEL_SCHED_API_GETRRINTERVAL_0100
916* @tc.name       sched_rr_get_interval api test
917* @tc.desc       [C- SOFTWARE -0200]
918*/
919HWTEST_F(ProcessSchedApiTest, testSchedRRGetInterval, Function | MediumTest | Level1)
920{
921    struct timespec time1 = {1, 0};
922    int rt = sched_rr_get_interval(0, &time1);
923    printf("%llu, %u\n", time1.tv_sec, time1.tv_nsec);
924    EXPECT_EQ(rt, 0);
925    EXPECT_EQ(time1.tv_sec, 0);
926    EXPECT_GE (time1.tv_nsec, DEFAULT_RR_SCHED_INTERVAL);
927
928    time1.tv_sec = 1;
929    time1.tv_nsec = 0;
930    rt = sched_rr_get_interval(getpid(), &time1);
931    printf("%llu, %u\n", time1.tv_sec, time1.tv_nsec);
932    EXPECT_EQ(rt, 0);
933    EXPECT_EQ(time1.tv_sec, 0);
934    EXPECT_GE(time1.tv_nsec, DEFAULT_RR_SCHED_INTERVAL);
935}
936
937/**
938* @tc.number     SUB_KERNEL_SCHED_API_GETRRINTERVAL_0200
939* @tc.name       sched_rr_get_interval error test with invalid pid
940* @tc.desc       [C- SOFTWARE -0200]
941*/
942HWTEST_F(ProcessSchedApiTest, testSchedRRGetIntervalError0200, Function | MediumTest | Level1)
943{
944    struct timespec time1 = {0, 0};
945    LOG("invalid 'pid' test:");
946    errno = 0;
947    int rt = sched_rr_get_interval(-1, &time1);
948    EXPECT_EQ(rt, -1);
949    EXPECT_EQ(errno, EINVAL);
950    errno = 0;
951    rt = sched_rr_get_interval(MAX_PROCESS_NUMBER + 1, &time1);
952    EXPECT_EQ(rt, -1);
953    EXPECT_EQ(errno, EINVAL);
954    errno = 0;
955    rt = sched_rr_get_interval(MAX_PROCESS_NUMBER + GetRandom(1000), &time1);
956    EXPECT_EQ(rt, -1);
957    EXPECT_EQ(errno, EINVAL);
958}
959
960/**
961* @tc.number     SUB_KERNEL_SCHED_API_GETRRINTERVAL_0300
962* @tc.name       sched_rr_get_interval error test with not exist pid
963* @tc.desc       [C- SOFTWARE -0200]
964*/
965HWTEST_F(ProcessSchedApiTest, testSchedRRGetIntervalError0300, Function | MediumTest | Level1)
966{
967    struct timespec time1 = {0, 0};
968    int rt;
969
970    LOG("not exist pid test:");
971    pid_t nonExitPid = GetNonExistPid(); // valid but not exist pid
972    if (nonExitPid != -1) {
973        rt = sched_rr_get_interval(nonExitPid, &time1);
974        EXPECT_EQ(rt, -1);
975        EXPECT_EQ(errno, ESRCH);
976    }
977
978    LOG("invalid 'timespec' test:");
979    rt = sched_rr_get_interval(0, NULL);
980    EXPECT_EQ(rt, -1);
981    EXPECT_EQ(errno, EINVAL);
982}
983
984/**
985* @tc.number     SUB_KERNEL_SCHED_API_GETRRINTERVAL_0400
986* @tc.name       sched_rr_get_interval error test with invalid timespec
987* @tc.desc       [C- SOFTWARE -0200]
988*/
989HWTEST_F(ProcessSchedApiTest, testSchedRRGetIntervalError0400, Function | MediumTest | Level1)
990{
991    int rt;
992
993    LOG("invalid 'timespec' test:");
994    rt = sched_rr_get_interval(0, NULL);
995    EXPECT_EQ(rt, -1);
996    EXPECT_EQ(errno, EINVAL);
997}
998
999/**
1000 * @tc.number   SUB_KERNEL_SCHED_API_YIELD_0100
1001 * @tc.name     test sched_yield with two process
1002 * @tc.desc     [C- SOFTWARE -0200]
1003 */
1004HWTEST_F(ProcessSchedApiTest, testSchedYieldBasic, Function | MediumTest | Level1)
1005{
1006    int ret;
1007    int cpuCnt = 0;
1008    cpu_set_t oldMask;
1009    CPU_ZERO(&oldMask);
1010    cpuCnt = GetCpuCount();
1011    LOG("GetCpuCount=%d", cpuCnt);
1012    if (cpuCnt > 1) {
1013        ret = FixCurProcessToOneCpu(0, &oldMask);
1014        ASSERT_EQ(ret, 0);
1015    }
1016
1017    ASSERT_EQ(InitPipe(), 0) << "> parent: pipe errno = " << errno;
1018    EXPECT_NE(InitGlobalVariable(), -1);
1019    pid_t pid = fork();
1020    ASSERT_TRUE(pid >= 0) << "> parent: fork errno = " << errno;
1021    if (pid == 0) {
1022        if (cpuCnt > 1) {
1023            ret = FixCurProcessToOneCpu(0, &oldMask);
1024            EXPECT_EQ(ret, 0);
1025        }
1026        // control step 2
1027        BlockOnPipe();
1028        SetGlobalVariable(1);
1029        LOG("222");
1030        exit(0);
1031    }
1032    Msleep(50);
1033    // control step 1
1034    UnBlockPipe();
1035    LOG("111");
1036    EXPECT_EQ(sched_yield(), 0) << "> sched_yield error";
1037    // control step 3
1038    EXPECT_NE(SetGlobalVariable(2), -1);
1039    LOG("333");
1040    // control step 4
1041    WaitProcExitedOK(pid);
1042    EXPECT_EQ(GetGlobalVariable(), 2);
1043    EXPECT_NE(DeleteGlobalVariable(), -1);
1044    if (cpuCnt > 1) {
1045        ret = sched_setaffinity(0, sizeof(oldMask), &oldMask);
1046        ASSERT_EQ(ret, 0);
1047    }
1048}
1049