1/*
2 * Copyright (c) 2022 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 <cstring>
17#include <sys/utsname.h>
18
19#include "gtest/gtest.h"
20
21#include "qos_interface.h"
22
23namespace OHOS {
24namespace FFRT_TEST {
25using namespace testing;
26using namespace testing::ext;
27using namespace OHOS::FFRT_TEST;
28using namespace std;
29
30class QosInterfaceTest : public testing::Test {
31public:
32    static void SetUpTestCase();
33    static void TearDownTestCase();
34    void SetUp();
35    void TearDown();
36    bool IsLinuxOs();
37};
38
39bool QosInterfaceTest::IsLinuxOs()
40{
41    struct utsname nameData;
42    uname(&nameData);
43    int cmpNum = 5;
44    return strncmp(nameData.sysname, "Linux", cmpNum) == 0 ? true : false;
45}
46
47void QosInterfaceTest::SetUpTestCase()
48{
49}
50
51void QosInterfaceTest::TearDownTestCase()
52{
53}
54
55void QosInterfaceTest::SetUp()
56{
57}
58
59void QosInterfaceTest::TearDown()
60{
61}
62
63extern "C" {
64/**
65 * @tc.name: EnableRtgTest
66 * @tc.desc: Test whether the OnRemoteRequest interface are normal.
67 * @tc.type: FUNC
68 */
69HWTEST_F(QosInterfaceTest, EnableRtgTest, TestSize.Level1)
70{
71    bool flag = true;
72    int ret = EnableRtg(flag);
73    EXPECT_EQ(ret, 0);
74}
75
76/**
77 * @tc.name: AuthEnableTest
78 * @tc.desc: Test whether the OnRemoteRequest interface are normal.
79 * @tc.type: FUNC
80 */
81HWTEST_F(QosInterfaceTest, AuthEnableTest, TestSize.Level1)
82{
83    unsigned int pid = getpid();
84    unsigned int uaFlag = AF_RTG_ALL;
85    unsigned int status = static_cast<unsigned int>(AuthStatus::AUTH_STATUS_BACKGROUND);
86    int ret = AuthEnable(pid, uaFlag, status);
87    EXPECT_EQ(ret, 0);
88}
89
90/**
91 * @tc.name: AuthSwitchTest
92 * @tc.desc: Test whether the AuthSwitch interface are normal.
93 * @tc.type: FUNC
94 */
95HWTEST_F(QosInterfaceTest, AuthSwitchTest, TestSize.Level1)
96{
97    unsigned int pid = getpid();
98    unsigned int rtgFlag = AF_RTG_ALL;
99    unsigned int qosFlag = AF_QOS_ALL;
100    unsigned int status = static_cast<unsigned int>(AuthStatus::AUTH_STATUS_BACKGROUND);
101    AuthEnable(pid, rtgFlag, status);
102    status = static_cast<unsigned int>(AuthStatus::AUTH_STATUS_FOREGROUND);
103    int ret = AuthSwitch(pid, rtgFlag, qosFlag, status);
104    EXPECT_EQ(ret, 0);
105}
106
107/**
108 * @tc.name: AuthDeleteTest
109 * @tc.desc: Test whether the AuthDelete interface are normal.
110 * @tc.type: FUNC
111 */
112HWTEST_F(QosInterfaceTest, AuthDeleteTest, TestSize.Level1)
113{
114    unsigned int pid = getpid();
115    unsigned int uaFlag = AF_RTG_ALL;
116    unsigned int status = static_cast<unsigned int>(AuthStatus::AUTH_STATUS_BACKGROUND);
117    AuthEnable(pid, uaFlag, status);
118    int ret = AuthDelete(pid);
119    EXPECT_EQ(ret, 0);
120    AuthEnable(pid, uaFlag, status);
121}
122
123/**
124 * @tc.name: AuthPauseTest
125 * @tc.desc: Test whether the AuthPause interface are normal.
126 * @tc.type: FUNC
127 */
128HWTEST_F(QosInterfaceTest, AuthPauseTest, TestSize.Level1)
129{
130    unsigned int pid = getpid();
131    unsigned int uaFlag = AF_RTG_ALL;
132    unsigned int status = static_cast<unsigned int>(AuthStatus::AUTH_STATUS_BACKGROUND);
133    AuthEnable(pid, uaFlag, status);
134    int ret = AuthPause(pid);
135    EXPECT_EQ(ret, 0);
136    AuthEnable(pid, uaFlag, status);
137}
138
139/**
140 * @tc.name: QosApplyTest
141 * @tc.desc: Test whether the QosApply interface are normal.
142 * @tc.type: FUNC
143 */
144HWTEST_F(QosInterfaceTest, QosApplyTest, TestSize.Level1)
145{
146    unsigned int level = 1;
147    int ret = -1;
148    ret = QosApply(level);
149#if defined(ARM64_TEST) && ARM64_TEST
150    EXPECT_EQ(ret, 0);
151#else
152    (void)ret;
153#endif
154}
155
156/**
157 * @tc.name: AuthGetTest
158 * @tc.desc: Test whether the AuthGet interface are normal.
159 * @tc.type: FUNC
160 */
161HWTEST_F(QosInterfaceTest, AuthGetTest, TestSize.Level1)
162{
163    unsigned int pid = getpid();
164    unsigned int uaFlag1 = 0;
165    unsigned int *uaFlag = &uaFlag1;
166    unsigned int status1 = 0;
167    unsigned int *status = &status1;
168    int ret = AuthGet(pid);
169    if (!IsLinuxOs()) {
170        return;
171    }
172    EXPECT_GE(ret, 0);
173    pid = -1;
174    ret = AuthGet(pid);
175    EXPECT_EQ(ret, -1);
176}
177
178/**
179 * @tc.name: AuthEnhanceTest
180 * @tc.desc: Test whether the AuthEnhance interface are normal.
181 * @tc.type: FUNC
182 */
183HWTEST_F(QosInterfaceTest, AuthEnhanceTest, TestSize.Level1)
184{
185    unsigned int pid = getpid();
186    bool enhanceStatus = false;
187    int ret = AuthEnhance(pid, enhanceStatus);
188    EXPECT_EQ(ret, 0);
189    enhanceStatus = false;
190    ret = AuthEnhance(pid, enhanceStatus);
191    EXPECT_EQ(ret, 0);
192}
193
194/**
195 * @tc.name: QosApplyForOtherTest
196 * @tc.desc: Test whether the QosApplyForOther interface are normal.
197 * @tc.type: FUNC
198 */
199HWTEST_F(QosInterfaceTest, QosApplyForOtherTest, TestSize.Level1)
200{
201    unsigned int level = 1;
202    int tid = gettid();
203    int ret = -1;
204    ret = QosApplyForOther(level, tid);
205#if defined(ARM64_TEST) && ARM64_TEST
206    EXPECT_EQ(ret, 0);
207#else
208    (void)ret;
209#endif
210}
211
212/**
213 * @tc.name: QosLeaveTest
214 * @tc.desc: Test whether the QosLeave interface are normal.
215 * @tc.type: FUNC
216 */
217HWTEST_F(QosInterfaceTest, QosLeaveTest, TestSize.Level1)
218{
219    int ret = -1;
220    ret = QosLeave();
221#if defined(ARM64_TEST) && ARM64_TEST
222    EXPECT_EQ(ret, 0);
223#else
224    (void)ret;
225#endif
226}
227
228/**
229 * @tc.name: QosLeaveForOtherTest
230 * @tc.desc: Test whether the QosLeaveForOther interface are normal.
231 * @tc.type: FUNC
232 */
233HWTEST_F(QosInterfaceTest, QosLeaveForOtherTest, TestSize.Level1)
234{
235    int ret = -1;
236    int tid = gettid();
237    int level = 1;
238    ret = QosApplyForOther(level, tid);
239    ret = QosLeaveForOther(tid);
240#if defined(ARM64_TEST) && ARM64_TEST
241    EXPECT_EQ(ret, 0);
242#else
243    (void)ret;
244#endif
245}
246
247/**
248 * @tc.name: QosPolicyTest
249 * @tc.desc: Test whether the QosPolicy interface are normal.
250 * @tc.type: FUNC
251 */
252
253static struct QosPolicyDatas g_defaultQosPolicy = {
254    .policyType = QOS_POLICY_DEFAULT,
255    .policyFlag = QOS_FLAG_ALL,
256    .policys = {
257        {0, 0, 0, 1024, 0},
258        {0, 0, 0, 1024, 0},
259        {0, 0, 0, 1024, 0},
260        {0, 0, 0, 1024, 0},
261        {0, 0, 0, 1024, 0},
262        {0, 0, 0, 1024, 0},
263        {0, 0, 0, 1024, 0},
264    }
265};
266
267HWTEST_F(QosInterfaceTest, QosPolicyTest, TestSize.Level1)
268{
269    int ret = -1;
270    struct QosPolicyDatas *policyDatas = nullptr;
271    ret = QosPolicySet(policyDatas);
272    EXPECT_EQ(ret, -1);
273#if defined(ARM64_TEST) && ARM64_TEST
274    unsigned int pid = getpid();
275    unsigned int rtgFlag = AF_RTG_ALL;
276    unsigned int qosFlag = AF_QOS_ALL;
277    unsigned int status = static_cast<unsigned int>(AuthStatus::AUTH_STATUS_FOREGROUND);
278    ret = AuthSwitch(pid, rtgFlag, qosFlag, status);
279    EXPECT_EQ(ret, 0);
280    ret = QosPolicySet(&g_defaultQosPolicy);
281    EXPECT_EQ(ret, 0);
282#endif
283}
284
285/**
286 * @tc.name: QosGetTest
287 * @tc.desc: Test whether the QosGet interface are normal.
288 * @tc.type: FUNC
289 */
290HWTEST_F(QosInterfaceTest, QosGetTest, TestSize.Level1)
291{
292    int qos;
293    unsigned int level = 4;
294    int ret = QosApply(level);
295    EXPECT_EQ(ret, 0);
296    ret = QosGet(qos);
297    sleep(5);
298    EXPECT_EQ(ret, 0);
299    EXPECT_EQ(qos, level);
300}
301
302/**
303 * @tc.name: QosGetForOtherTest
304 * @tc.desc: Test whether the QosGetForOther interface are normal.
305 * @tc.type: FUNC
306 */
307HWTEST_F(QosInterfaceTest, QosGetForOtherTest, TestSize.Level1)
308{
309    int qos;
310    unsigned int level = 3;
311    int tid = gettid();
312    int ret = QosApplyForOther(level, tid);
313    EXPECT_EQ(ret, 0);
314    ret = QosGetForOther(tid, qos);
315    EXPECT_EQ(ret, 0);
316    EXPECT_EQ(qos, level);
317}
318}
319}
320}
321