1 /*
2 * Copyright (c) 2024 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 #define private public
17 #define protected public
18
19 #include <gtest/gtest.h>
20 #include <gtest/hwext/gtest-multithread.h>
21 #include "socperf_config.h"
22 #include "isoc_perf.h"
23 #include "socperf_server.h"
24 #include "socperf.h"
25
26 using namespace testing::ext;
27 using namespace testing::mt;
28
29 namespace OHOS {
30 namespace SOCPERF {
31 class SocPerfServerTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 private:
38 std::shared_ptr<SocPerfServer> socPerfServer_ = DelayedSingleton<SocPerfServer>::GetInstance();
39 };
40
SetUpTestCase(void)41 void SocPerfServerTest::SetUpTestCase(void)
42 {
43 }
44
TearDownTestCase(void)45 void SocPerfServerTest::TearDownTestCase(void)
46 {
47 }
48
SetUp(void)49 void SocPerfServerTest::SetUp(void)
50 {
51 }
52
TearDown(void)53 void SocPerfServerTest::TearDown(void)
54 {
55 }
56
57 /*
58 * @tc.name: SocPerfServerTest_Init_Config_001
59 * @tc.desc: test init config
60 * @tc.type FUNC
61 * @tc.require: issueI78T3V
62 */
63 HWTEST_F(SocPerfServerTest, SocPerfServerTest_Init_Config_001, TestSize.Level0)
64 {
65 socPerfServer_->OnStart();
66 sleep(1);
67 EXPECT_TRUE(socPerfServer_->socPerf.enabled_);
68 }
69
70 /*
71 * @tc.name: SocPerfServerTest_SocPerfAPI_001
72 * @tc.desc: test socperf api
73 * @tc.type FUNC
74 * @tc.require: issueI78T3V
75 */
76 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocPerfAPI_001, Function | MediumTest | Level0)
77 {
78 std::string msg = "testBoost";
79 socPerfServer_->socPerf.PerfRequest(10010, msg);
80 socPerfServer_->socPerf.PerfRequestEx(10000, true, msg);
81 socPerfServer_->socPerf.PerfRequestEx(10000, false, msg);
82 socPerfServer_->socPerf.PerfRequestEx(10028, true, msg);
83 socPerfServer_->socPerf.PerfRequestEx(10028, false, msg);
84 socPerfServer_->socPerf.LimitRequest(ActionType::ACTION_TYPE_POWER, {1001}, {999000}, msg);
85 socPerfServer_->socPerf.LimitRequest(ActionType::ACTION_TYPE_THERMAL, {1001}, {999000}, msg);
86 socPerfServer_->socPerf.LimitRequest(ActionType::ACTION_TYPE_POWER, {1001}, {1325000}, msg);
87 socPerfServer_->socPerf.LimitRequest(ActionType::ACTION_TYPE_THERMAL, {1001}, {1325000}, msg);
88 socPerfServer_->socPerf.PowerLimitBoost(true, msg);
89 socPerfServer_->socPerf.ThermalLimitBoost(true, msg);
90 EXPECT_EQ(msg, "testBoost");
91 std::string id = "1000";
92 std::string name = "lit_cpu_freq";
93 std::string pair = "1001";
94 std::string mode = "1";
95 std::string persisMode = "1";
96 std::string configFile = "";
97 bool ret = socPerfServer_->socPerf.socPerfConfig_.CheckResourceTag(id.c_str(),
98 name.c_str(), pair.c_str(), mode.c_str(),
99 persisMode.c_str(), configFile.c_str());
100 EXPECT_TRUE(ret);
101 ret = socPerfServer_->socPerf.socPerfConfig_.CheckResourceTag(nullptr, name.c_str(), pair.c_str(), mode.c_str(),
102 persisMode.c_str(), configFile.c_str());
103 EXPECT_FALSE(ret);
104 }
105
106 /*
107 * @tc.name: SocPerfServerTest_SocPerfServerAPI_000
108 * @tc.desc: test socperf server api
109 * @tc.type FUNC
110 * @tc.require: issueI78T3V
111 */
112 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocPerfServerAPI_000, Function | MediumTest | Level0)
113 {
114 std::string msg = "testBoost";
115 socPerfServer_->PerfRequest(10010, msg);
116 socPerfServer_->PerfRequestEx(10000, true, msg);
117 socPerfServer_->PerfRequestEx(10000, false, msg);
118 socPerfServer_->LimitRequest(ActionType::ACTION_TYPE_POWER, {1001}, {1364000}, msg);
119 socPerfServer_->LimitRequest(ActionType::ACTION_TYPE_POWER, {11001}, {2}, msg);
120 socPerfServer_->LimitRequest(ActionType::ACTION_TYPE_MAX, {11001}, {2}, msg);
121 socPerfServer_->PowerLimitBoost(true, msg);
122 socPerfServer_->LimitRequest(ActionType::ACTION_TYPE_THERMAL, {1001}, {1364000}, msg);
123 socPerfServer_->ThermalLimitBoost(true, msg);
124 socPerfServer_->PowerLimitBoost(false, msg);
125 socPerfServer_->ThermalLimitBoost(false, msg);
126 bool allowDump = socPerfServer_->AllowDump();
127 EXPECT_TRUE(allowDump);
128 int32_t fd = -1;
129 std::vector<std::u16string> args = {to_utf16("1"), to_utf16("2"), to_utf16("3"), to_utf16("-a"), to_utf16("-h")};
130 socPerfServer_->Dump(fd, args);
131 socPerfServer_->OnStop();
132 EXPECT_EQ(msg, "testBoost");
133 }
134
135 /*
136 * @tc.name: SocPerfSubTest_RequestCmdIdCount_001
137 * @tc.desc: RequestCmdIdCount
138 * @tc.type FUNC
139 * @tc.require: issueI9H4NS
140 */
141 HWTEST_F(SocPerfServerTest, SocPerfSubTest_RequestCmdIdCount_001, Function | MediumTest | Level0)
142 {
143 int firstCheckColdStartNum = 0;
144 int secondCheckColdStartNum = 0;
145 map<int, int> myMap;
146 char colon, comma;
147 int key, value;
148
149 std::string ret = socPerfServer_->socPerf.RequestCmdIdCount("");
150 std::stringstream ssfirst(ret);
151 while (ssfirst >> key >> colon >> value >> comma) {
152 myMap[key] = value;
153 }
154 ssfirst >> key >> colon >> value;
155 myMap[key] = value;
156 firstCheckColdStartNum = myMap[10010];
157
158 sleep(1);
159 std::string msg = "testBoost";
160 socPerfServer_->PerfRequest(10010, msg);
161
162 ret = socPerfServer_->socPerf.RequestCmdIdCount("");
163
164 socPerfServer_->RequestCmdIdCount(msg, msg);
165 std::stringstream sssecond(ret);
166 while (sssecond >> key >> colon >> value >> comma) {
167 myMap[key] = value;
168 }
169 sssecond >> key >> colon >> value;
170 myMap[key] = value;
171 secondCheckColdStartNum = myMap[10010];
172
173 EXPECT_TRUE(secondCheckColdStartNum == firstCheckColdStartNum + 1);
174 }
175
176 /*
177 * @tc.name: SocPerfServerTest_SocPerfServerAPI_001
178 * @tc.desc: test socperf server api
179 * @tc.type FUNC
180 * @tc.require: issueI78T3V
181 */
182 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocPerfServerAPI_001, Function | MediumTest | Level0)
183 {
184 std::string msg = "";
185 socPerfServer_->SetRequestStatus(false, msg);
186 socPerfServer_->socPerf.ClearAllAliveRequest();
187 EXPECT_FALSE(socPerfServer_->socPerf.perfRequestEnable_);
188 auto socPerfThreadWrap = std::make_shared<SocPerfThreadWrap>();
189 socPerfThreadWrap->ClearAllAliveRequest();
190 for (const std::pair<int32_t, std::shared_ptr<ResStatus>>& item : socPerfThreadWrap->resStatusInfo_) {
191 if (item.second == nullptr) {
192 continue;
193 }
194 std::list<std::shared_ptr<ResAction>>& resActionList = item.second->resActionList[ACTION_TYPE_PERF];
195 EXPECT_TRUE(resActionList.empty());
196 }
197 }
198
199 /*
200 * @tc.name: SocPerfServerTest_SocPerfServerAPI_002
201 * @tc.desc: test socperf server api
202 * @tc.type FUNC
203 * @tc.require: issueI78T3V
204 */
205 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocPerfServerAPI_002, Function | MediumTest | Level0)
206 {
207 std::string msg = "test";
208 socPerfServer_->RequestDeviceMode(msg, true);
209 auto iter = socPerfServer_->socPerf.recordDeviceMode_.find(msg);
210 EXPECT_TRUE(iter == socPerfServer_->socPerf.recordDeviceMode_.end());
211
212 socPerfServer_->RequestDeviceMode(msg, false);
213 auto iter2 = socPerfServer_->socPerf.recordDeviceMode_.find(msg);
214 EXPECT_TRUE(iter2 == socPerfServer_->socPerf.recordDeviceMode_.end());
215
216 std::string msgEmpty = "";
217 socPerfServer_->RequestDeviceMode("", true);
218 auto iter3 = socPerfServer_->socPerf.recordDeviceMode_.find(msgEmpty);
219 EXPECT_TRUE(iter3 == socPerfServer_->socPerf.recordDeviceMode_.end());
220
221 std::string msgMax = "ABCDEFGHABCDEFGHABCDEFGHABCDEFGHABCDEFGHABCDEFGHABCDEFGHABCDEFGHZ";
222 socPerfServer_->RequestDeviceMode(msgMax, true);
223 auto iter4 = socPerfServer_->socPerf.recordDeviceMode_.find(msgMax);
224 EXPECT_TRUE(iter4 == socPerfServer_->socPerf.recordDeviceMode_.end());
225
226 std::string msgWeakInteractionStatus = "actionmode:weakaction";
227 socPerfServer_->RequestDeviceMode(msgWeakInteractionStatus, true);
228 auto iter5 = socPerfServer_->socPerf.recordDeviceMode_.find(msgWeakInteractionStatus);
229 EXPECT_TRUE(iter5 == socPerfServer_->socPerf.recordDeviceMode_.end());
230
231 std::string msgWeakInteractionError = "actionmode:error";
232 socPerfServer_->RequestDeviceMode(msgWeakInteractionError, true);
233 auto iter6 = socPerfServer_->socPerf.recordDeviceMode_.find(msgWeakInteractionError);
234 EXPECT_TRUE(iter6 == socPerfServer_->socPerf.recordDeviceMode_.end());
235 }
236
237 /*
238 * @tc.name: SocPerfServerTest_SocperfMatchCmd_001
239 * @tc.desc: test socperf MatchDeviceModeCmd func
240 * @tc.type FUNC
241 * @tc.require: issueI9GCD8
242 */
243 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocperfMatchDeviceCmd_001, Function | MediumTest | Level0)
244 {
245 std::string modeStr = "displayMain";
246 int32_t cmdTest = 10000;
247 std::unordered_map<int32_t, std::shared_ptr<Actions>> perfActionsInfo =
248 socPerfServer_->socPerf.socPerfConfig_.configPerfActionsInfo_[DEFAULT_CONFIG_MODE];
249 auto it_actions = perfActionsInfo.find(cmdTest);
250 if (it_actions == perfActionsInfo.end()) {
251 EXPECT_EQ(modeStr, "displayMain");
252 return;
253 }
254 std::shared_ptr<Actions> actions = perfActionsInfo[cmdTest];
255 if (actions->modeMap.empty()) {
256 std::shared_ptr<ModeMap> newMode = std::make_shared<ModeMap>(modeStr, cmdTest);
257 actions->modeMap.push_back(newMode);
258 }
259
260 // case : normal match
261 int32_t ret = socPerfServer_->socPerf.MatchDeviceModeCmd(cmdTest, false);
262 auto iter_match = std::find_if(actions->modeMap.begin(), actions->modeMap.end(),
__anon89b0feeb0102(const std::shared_ptr<ModeMap>& modeItem) 263 [&modeStr](const std::shared_ptr<ModeMap>& modeItem) {
264 return modeItem->mode == modeStr;
265 });
266 if (iter_match != actions->modeMap.end()) {
267 EXPECT_EQ(ret, (*iter_match)->cmdId);
268 } else {
269 EXPECT_EQ(ret, cmdTest);
270 }
271
272 // case : match cmdid is not exist branch
273 int32_t cmdInvaild = 60000;
274 auto iter_invaild = perfActionsInfo.find(cmdInvaild);
275 if (iter_invaild != perfActionsInfo.end()) {
276 EXPECT_EQ(cmdInvaild, 60000);
277 } else {
278 auto iter_mode = std::find_if(actions->modeMap.begin(), actions->modeMap.end(),
__anon89b0feeb0202(const std::shared_ptr<ModeMap>& modeItem) 279 [&modeStr](const std::shared_ptr<ModeMap>& modeItem) {
280 return modeItem->mode == modeStr;
281 });
282 if (iter_mode == actions->modeMap.end()) {
283 EXPECT_EQ(cmdInvaild, 60000);
284 } else {
285 (*iter_mode)->cmdId = cmdInvaild;
286 int32_t retInvaild = socPerfServer_->socPerf.MatchDeviceModeCmd(cmdTest, false);
287 EXPECT_EQ(retInvaild, cmdTest);
288 }
289 }
290
291 // case : no match mode
292 std::string modeInvaild = "test";
293 socPerfServer_->RequestDeviceMode(modeStr, false);
294 socPerfServer_->RequestDeviceMode(modeInvaild, true);
295 int32_t retModeInvaild = socPerfServer_->socPerf.MatchDeviceModeCmd(cmdTest, false);
296 EXPECT_EQ(retModeInvaild, cmdTest);
297 }
298
299 /*
300 * @tc.name: SocPerfServerTest_SocperfMatchCmd_002
301 * @tc.desc: test socperf MatchDeviceModeCmd func
302 * @tc.type FUNC
303 * @tc.require: issueI9GCD8
304 */
305 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocperfMatchCmd_002, Function | MediumTest | Level0)
306 {
307 std::string modeStr = "displayMainTest";
308 int32_t cmdTest = 10000;
309 int32_t cmdMatch = 10001;
310 std::unordered_map<int32_t, std::shared_ptr<Actions>> perfActionsInfo =
311 socPerfServer_->socPerf.socPerfConfig_.configPerfActionsInfo_[DEFAULT_CONFIG_MODE];
312 auto it_actions = perfActionsInfo.find(cmdTest);
313 if (it_actions == perfActionsInfo.end()) {
314 EXPECT_EQ(modeStr, "displayMainTest");
315 return;
316 }
317 std::shared_ptr<Actions> actions = perfActionsInfo[cmdTest];
318 actions->isLongTimePerf = false;
319 std::shared_ptr<ModeMap> newMode = std::make_shared<ModeMap>(modeStr, cmdMatch);
320 actions->modeMap.push_back(newMode);
321
322 auto it_match = perfActionsInfo.find(cmdMatch);
323 if (it_match == perfActionsInfo.end()) {
324 EXPECT_EQ(modeStr, "displayMainTest");
325 return;
326 }
327
328 // case : match cmdid is long time perf branch
329 std::shared_ptr<Actions> actionsMatch = perfActionsInfo[cmdMatch];
330 actionsMatch->isLongTimePerf = true;
331 int32_t retInvaild = socPerfServer_->socPerf.MatchDeviceModeCmd(cmdTest, true);
332 EXPECT_EQ(retInvaild, cmdTest);
333 }
334
335 /*
336 * @tc.name: SocPerfServerTest_SocperfMatchCmd_003
337 * @tc.desc: test socperf MatchDeviceModeCmd func
338 * @tc.type FUNC
339 * @tc.require: issueI9GCD8
340 */
341 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocperfMatchCmd_003, Function | MediumTest | Level0)
342 {
343 std::string modeStr = "displayMainTest";
344 int32_t cmdTest = 10002;
345 std::unordered_map<int32_t, std::shared_ptr<Actions>> perfActionsInfo =
346 socPerfServer_->socPerf.socPerfConfig_.configPerfActionsInfo_[DEFAULT_CONFIG_MODE];
347 auto it_actions = perfActionsInfo.find(cmdTest);
348 if (it_actions == perfActionsInfo.end()) {
349 EXPECT_EQ(modeStr, "displayMainTest");
350 return;
351 }
352
353 std::shared_ptr<Actions> actions = perfActionsInfo[cmdTest];
354 std::shared_ptr<ModeMap> newMode = std::make_shared<ModeMap>(modeStr, cmdTest);
355 actions->modeMap.push_back(newMode);
356 socPerfServer_->socPerf.recordDeviceMode_.clear();
357
358 // case : match device mode is empty branch
359 int32_t retInvaild = socPerfServer_->socPerf.MatchDeviceModeCmd(cmdTest, true);
360 EXPECT_EQ(retInvaild, cmdTest);
361 }
362
363 /*
364 * @tc.name: SocPerfServerTest_SocperfParseModeCmd_001
365 * @tc.desc: test socperf ParseModeCmd func
366 * @tc.type FUNC
367 * @tc.require: issueI78T3V
368 */
369 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocperfParseModeCmd_001, Function | MediumTest | Level0)
370 {
371 const char modePairInvaild[] = "parseTest";
372 const char modeNumberInvaild[] = "parseTest=abc";
373 const char modeCmdInvaild[] = "=12345";
374 const char modeSame[] = "parseTest=12345|parseTest=23456";
375 std::string cfgFile = "bootest.xml";
376 int32_t cmdTest = 10002;
377 int32_t exceptSame = 23456;
378 std::string deviceMode = "parseTest";
379
380 std::unordered_map<int32_t, std::shared_ptr<Actions>> perfActionsInfo =
381 socPerfServer_->socPerf.socPerfConfig_.configPerfActionsInfo_[DEFAULT_CONFIG_MODE];
382 auto it_actions = perfActionsInfo.find(cmdTest);
383 if (it_actions == perfActionsInfo.end()) {
384 EXPECT_EQ(cmdTest, 10002);
385 return;
386 }
387
388 std::shared_ptr<Actions> actions = perfActionsInfo[cmdTest];
389 socPerfServer_->socPerf.socPerfConfig_.ParseModeCmd(modePairInvaild, cfgFile, actions);
390 auto iter_mode = std::find_if(actions->modeMap.begin(), actions->modeMap.end(),
__anon89b0feeb0302(const std::shared_ptr<ModeMap>& modeItem) 391 [&deviceMode](const std::shared_ptr<ModeMap>& modeItem) {
392 return modeItem->mode == deviceMode;
393 });
394 EXPECT_TRUE(iter_mode == actions->modeMap.end());
395
396 socPerfServer_->socPerf.socPerfConfig_.ParseModeCmd(modeNumberInvaild, cfgFile, actions);
397 iter_mode = std::find_if(actions->modeMap.begin(), actions->modeMap.end(),
__anon89b0feeb0402(const std::shared_ptr<ModeMap>& modeItem) 398 [&deviceMode](const std::shared_ptr<ModeMap>& modeItem) {
399 return modeItem->mode == deviceMode;
400 });
401 EXPECT_TRUE(iter_mode == actions->modeMap.end());
402
403 socPerfServer_->socPerf.socPerfConfig_.ParseModeCmd(modeCmdInvaild, cfgFile, actions);
404 iter_mode = std::find_if(actions->modeMap.begin(), actions->modeMap.end(),
__anon89b0feeb0502(const std::shared_ptr<ModeMap>& modeItem) 405 [&deviceMode](const std::shared_ptr<ModeMap>& modeItem) {
406 return modeItem->mode == deviceMode;
407 });
408 EXPECT_TRUE(iter_mode == actions->modeMap.end());
409
410 int32_t size = actions->modeMap.size();
411 socPerfServer_->socPerf.socPerfConfig_.ParseModeCmd(modeSame, cfgFile, actions);
412 EXPECT_EQ(size + 1, actions->modeMap.size());
413 auto iterSame = std::find_if(actions->modeMap.begin(), actions->modeMap.end(),
__anon89b0feeb0602(const std::shared_ptr<ModeMap>& modeItem) 414 [&deviceMode](const std::shared_ptr<ModeMap>& modeItem) {
415 return modeItem->mode == deviceMode;
416 });
417 ASSERT_TRUE(iterSame != actions->modeMap.end());
418 EXPECT_EQ(exceptSame, (*iterSame)->cmdId);
419
420 int32_t sizeBefore = actions->modeMap.size();
421 const char *modeNullInvaild = nullptr;
422 socPerfServer_->socPerf.socPerfConfig_.ParseModeCmd(modeNullInvaild, cfgFile, actions);
423 EXPECT_EQ(sizeBefore, actions->modeMap.size());
424 }
425
426 /*
427 * @tc.name: SocPerfServerTest_SocperfThreadWrapp_001
428 * @tc.desc: test log switch func
429 * @tc.type FUNC
430 * @tc.require: issueI78T3V
431 */
432 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocperfThreadWrapp_001, Function | MediumTest | Level0)
433 {
434 std::string msg = "";
435 auto socPerfThreadWrap = std::make_shared<SocPerfThreadWrap>();
436 socPerfThreadWrap->InitResourceNodeInfo();
437 socPerfThreadWrap->socPerfConfig_.InitPerfFunc(nullptr, nullptr, nullptr);
438 socPerfThreadWrap->socPerfConfig_.InitPerfFunc(nullptr, msg.c_str(), msg.c_str());
439 socPerfThreadWrap->socPerfConfig_.InitPerfFunc(msg.c_str(), nullptr, nullptr);
440 socPerfThreadWrap->socPerfConfig_.InitPerfFunc(msg.c_str(), msg.c_str(), msg.c_str());
441 socPerfThreadWrap->DoFreqActionPack(nullptr);
442 socPerfThreadWrap->UpdateLimitStatus(0, nullptr, 0);
443 socPerfThreadWrap->DoFreqAction(0, nullptr);
444 socPerfThreadWrap->DoFreqAction(1000, nullptr);
445 EXPECT_NE(msg.c_str(), "-1");
446 bool ret = false;
447 int inValidResId = 9999;
448 ret = socPerfThreadWrap->socPerfConfig_.IsValidResId(inValidResId);
449 EXPECT_FALSE(ret);
450 ret = socPerfThreadWrap->socPerfConfig_.IsGovResId(inValidResId);
451 EXPECT_FALSE(ret);
452 int32_t level = 10;
453 int64_t value = 0;
454 ret = socPerfThreadWrap->GetResValueByLevel(inValidResId, level, value);
455 EXPECT_FALSE(ret);
456 }
457
458 class SocperfStubTest : public SocPerfStub {
459 public:
SocperfStubTest()460 SocperfStubTest() {}
PerfRequest(int32_t cmdId,const std::string & msg)461 ErrCode PerfRequest(int32_t cmdId, const std::string& msg) override
462 {
463 return ERR_OK;
464 }
PerfRequestEx(int32_t cmdId,bool onOffTag,const std::string & msg)465 ErrCode PerfRequestEx(int32_t cmdId, bool onOffTag, const std::string& msg) override
466 {
467 return ERR_OK;
468 }
PowerLimitBoost(bool onOffTag,const std::string & msg)469 ErrCode PowerLimitBoost(bool onOffTag, const std::string& msg) override
470 {
471 return ERR_OK;
472 }
ThermalLimitBoost(bool onOffTag,const std::string & msg)473 ErrCode ThermalLimitBoost(bool onOffTag, const std::string& msg) override
474 {
475 return ERR_OK;
476 }
LimitRequest(int32_t clientId,const std::vector<int32_t> & tags,const std::vector<int64_t> & configs,const std::string & msg)477 ErrCode LimitRequest(int32_t clientId,
478 const std::vector<int32_t>& tags, const std::vector<int64_t>& configs, const std::string& msg) override
479 {
480 return ERR_OK;
481 }
SetRequestStatus(bool status,const std::string & msg)482 ErrCode SetRequestStatus(bool status, const std::string& msg) override
483 {
484 return ERR_OK;
485 }
SetThermalLevel(int32_t level)486 ErrCode SetThermalLevel(int32_t level) override
487 {
488 return ERR_OK;
489 }
RequestDeviceMode(const std::string & mode,bool status)490 ErrCode RequestDeviceMode(const std::string& mode, bool status) override
491 {
492 return ERR_OK;
493 }
RequestCmdIdCount(const std::string & msg,std::string & funcResult)494 ErrCode RequestCmdIdCount(const std::string& msg, std::string& funcResult) override
495 {
496 return ERR_OK;
497 }
498 };
499
500 /*
501 * @tc.name: SocPerfStubTest_SocPerfServerAPI_001
502 * @tc.desc: test socperf stub api
503 * @tc.type FUNC
504 * @tc.require: issueI78T3V
505 */
506 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_001, Function | MediumTest | Level0)
507 {
508 SocperfStubTest socPerfStub;
509 MessageParcel data;
510 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
511 data.WriteInt32(10000);
512 data.WriteString("");
513 MessageParcel reply;
514 MessageOption option;
515 uint32_t requestIpcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_PERF_REQUEST);
516 int32_t ret = socPerfStub.OnRemoteRequest(requestIpcId, data, reply, option);
517 EXPECT_EQ(ret, ERR_OK);
518 }
519
520 /*
521 * @tc.name: SocPerfStubTest_SocPerfServerAPI_002
522 * @tc.desc: test socperf stub api
523 * @tc.type FUNC
524 * @tc.require: issueI78T3V
525 */
526 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_002, Function | MediumTest | Level0)
527 {
528 SocperfStubTest socPerfStub;
529 MessageParcel data;
530 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
531 data.WriteInt32(10000);
532 data.WriteBool(true);
533 data.WriteString("");
534 MessageParcel reply;
535 MessageOption option;
536 uint32_t requestExIpcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_PERF_REQUEST_EX);
537 int32_t ret = socPerfStub.OnRemoteRequest(requestExIpcId, data, reply, option);
538 EXPECT_EQ(ret, ERR_OK);
539 }
540
541 /*
542 * @tc.name: SocPerfStubTest_SocPerfServerAPI_003
543 * @tc.desc: test socperf stub api
544 * @tc.type FUNC
545 * @tc.require: issueI78T3V
546 */
547 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_003, Function | MediumTest | Level0)
548 {
549 SocperfStubTest socPerfStub;
550 MessageParcel data;
551 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
552 data.WriteInt32(1);
553 std::vector<int32_t> tags = {1001};
554 data.WriteInt32Vector(tags);
555 std::vector<int64_t> configs = {1416000};
556 data.WriteInt64Vector(configs);
557 data.WriteString("");
558 MessageParcel reply;
559 MessageOption option;
560 uint32_t powerLimitId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_LIMIT_REQUEST);
561 int32_t ret = socPerfStub.OnRemoteRequest(powerLimitId, data, reply, option);
562 EXPECT_EQ(ret, ERR_OK);
563 }
564
565 /*
566 * @tc.name: SocPerfStubTest_SocPerfServerAPI_004
567 * @tc.desc: test socperf stub api
568 * @tc.type FUNC
569 * @tc.require: issueI78T3V
570 */
571 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_004, Function | MediumTest | Level0)
572 {
573 SocperfStubTest socPerfStub;
574 MessageParcel data;
575 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
576 data.WriteBool(true);
577 data.WriteString("");
578 MessageParcel reply;
579 MessageOption option;
580 uint32_t powerLimitIpcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_POWER_LIMIT_BOOST);
581 int32_t ret = socPerfStub.OnRemoteRequest(powerLimitIpcId, data, reply, option);
582 EXPECT_EQ(ret, ERR_OK);
583 }
584
585 /*
586 * @tc.name: SocPerfStubTest_SocPerfServerAPI_005
587 * @tc.desc: test socperf stub api
588 * @tc.type FUNC
589 * @tc.require: issueI78T3V
590 */
591 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_005, Function | MediumTest | Level0)
592 {
593 SocperfStubTest socPerfStub;
594 MessageParcel data;
595 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
596 data.WriteBool(true);
597 data.WriteString("");
598 MessageParcel reply;
599 MessageOption option;
600 uint32_t thermalLimitIpcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_THERMAL_LIMIT_BOOST);
601 int32_t ret = socPerfStub.OnRemoteRequest(thermalLimitIpcId, data, reply, option);
602 EXPECT_EQ(ret, ERR_OK);
603 }
604
605 /*
606 * @tc.name: SocPerfStubTest_SocPerfServerAPI_006
607 * @tc.desc: test socperf stub api
608 * @tc.type FUNC
609 * @tc.require: issueI78T3V
610 */
611 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_006, Function | MediumTest | Level0)
612 {
613 SocperfStubTest socPerfStub;
614 MessageParcel data;
615 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
616 data.WriteBool(true);
617 MessageParcel reply;
618 MessageOption option;
619 uint32_t ipcId = 0x000f;
620 int32_t ret = socPerfStub.OnRemoteRequest(ipcId, data, reply, option);
621 EXPECT_NE(ret, ERR_OK);
622 }
623
624 /*
625 * @tc.name: SocPerfStubTest_SocPerfServerAPI_007
626 * @tc.desc: test socperf stub api
627 * @tc.type FUNC
628 * @tc.require: issueI78T3V
629 */
630 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_007, Function | MediumTest | Level0)
631 {
632 SocperfStubTest socPerfStub;
633 MessageParcel data;
634 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
635 data.WriteBool(false);
636 data.WriteString("");
637 MessageParcel reply;
638 MessageOption option;
639 uint32_t ipcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_SET_REQUEST_STATUS);
640 int32_t ret = socPerfStub.OnRemoteRequest(ipcId, data, reply, option);
641 EXPECT_EQ(ret, ERR_OK);
642
643 MessageParcel dataPerf;
644 dataPerf.WriteInterfaceToken(SocPerfStub::GetDescriptor());
645 dataPerf.WriteInt32(10000);
646 dataPerf.WriteString("");
647 MessageParcel replyPerf;
648 MessageOption optionPerf;
649 uint32_t requestPerfIpcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_PERF_REQUEST);
650 ret = socPerfStub.OnRemoteRequest(requestPerfIpcId, dataPerf, replyPerf, optionPerf);
651 EXPECT_EQ(ret, ERR_OK);
652
653 MessageParcel dataLimit;
654 dataLimit.WriteInterfaceToken(SocPerfStub::GetDescriptor());
655 dataLimit.WriteInt32(1);
656 std::vector<int32_t> tags = {1001};
657 dataLimit.WriteInt32Vector(tags);
658 std::vector<int64_t> configs = {1416000};
659 dataLimit.WriteInt64Vector(configs);
660 dataLimit.WriteString("");
661 MessageParcel replyLimit;
662 MessageOption optionLimit;
663 uint32_t powerLimitId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_LIMIT_REQUEST);
664 ret = socPerfStub.OnRemoteRequest(powerLimitId, dataLimit, reply, option);
665 EXPECT_EQ(ret, ERR_OK);
666 }
667
668
669 /*
670 * @tc.name: SocPerfStubTest_SocPerfServerAPI_008
671 * @tc.desc: test socperf requet device mode stub api
672 * @tc.type FUNC
673 * @tc.require: issue#I95U8S
674 */
675 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_008, Function | MediumTest | Level0)
676 {
677 SocperfStubTest socPerfStub;
678 MessageParcel data;
679 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
680 data.WriteString("test");
681 data.WriteBool(true);
682 MessageParcel reply;
683 MessageOption option;
684 uint32_t ipcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_REQUEST_DEVICE_MODE);
685 int32_t ret = socPerfStub.OnRemoteRequest(ipcId, data, reply, option);
686 EXPECT_EQ(ret, ERR_OK);
687 }
688
689 /*
690 * @tc.name: SocPerfServerTest_SetThermalLevel_001
691 * @tc.desc: perf request lvl server API
692 * @tc.type FUNC
693 * @tc.require: issue#I95U8S
694 */
695 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SetThermalLevel_Server_001, Function | MediumTest | Level0)
696 {
697 SocperfStubTest socPerfStub;
698 MessageParcel data;
699 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
700 data.WriteInt32(3);
701 MessageParcel reply;
702 MessageOption option;
703 uint32_t ipcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_SET_THERMAL_LEVEL);
704 int32_t ret = socPerfStub.OnRemoteRequest(ipcId, data, reply, option);
705 EXPECT_EQ(ret, ERR_OK);
706 }
707
708 /*
709 * @tc.name: SocPerfServerTest_SetThermalLevel_Server_002
710 * @tc.desc: perf request lvl server API
711 * @tc.type FUNC
712 * @tc.require: issue#I95U8S
713 */
714 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SetThermalLevel_Server_002, Function | MediumTest | Level0)
715 {
716 socPerfServer_->SetThermalLevel(3);
717 EXPECT_EQ(socPerfServer_->socPerf.thermalLvl_, 3);
718 }
719
720 /*
721 * @tc.name: SocPerfServerTest_SetThermalLevel_Server_005
722 * @tc.desc: perf request lvl server API
723 * @tc.type FUNC
724 * @tc.require: issue#I95U8S
725 */
726 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SetThermalLevel_Server_005, Function | MediumTest | Level0)
727 {
728 int32_t litCpuMinFreq = 1000;
729 int32_t litCpuMaxFreq = 1001;
730 std::shared_ptr<SocPerfThreadWrap> socPerfThreadWrap = socPerfServer_->socPerf.socperfThreadWrap_;
731 socPerfThreadWrap->resStatusInfo_[litCpuMinFreq]->candidatesValue[ACTION_TYPE_PERFLVL] = 1000;
732 bool ret = socPerfThreadWrap->ArbitratePairResInPerfLvl(litCpuMinFreq);
733 EXPECT_TRUE(ret);
734
735 socPerfThreadWrap->resStatusInfo_[litCpuMinFreq]->candidatesValue[ACTION_TYPE_PERFLVL] = INVALID_VALUE;
736 socPerfThreadWrap->resStatusInfo_[litCpuMaxFreq]->candidatesValue[ACTION_TYPE_PERFLVL] = 1000;
737 ret = socPerfThreadWrap->ArbitratePairResInPerfLvl(litCpuMinFreq);
738 EXPECT_TRUE(ret);
739
740 socPerfThreadWrap->resStatusInfo_[litCpuMinFreq]->candidatesValue[ACTION_TYPE_PERFLVL] = INVALID_VALUE;
741 socPerfThreadWrap->resStatusInfo_[litCpuMaxFreq]->candidatesValue[ACTION_TYPE_PERFLVL] = INVALID_VALUE;
742 ret = socPerfThreadWrap->ArbitratePairResInPerfLvl(litCpuMinFreq);
743 EXPECT_FALSE(ret);
744 }
745
746 /*
747 * @tc.name: SocPerfServerTest_SetThermalLevel_Server_006
748 * @tc.desc: perf request lvl server API
749 * @tc.type FUNC
750 * @tc.require: issue#I95U8S
751 */
752 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SetThermalLevel_Server_006, Function | MediumTest | Level0)
753 {
754 bool ret = socPerfServer_->socPerf.socPerfConfig_.Init();
755 sleep(1);
756 EXPECT_TRUE(ret);
757 }
758
759 /*
760 * @tc.name: SocPerfServerTest_End_001
761 * @tc.desc: perf end
762 * @tc.type FUNC
763 * @tc.require: issue#I95U8S
764 */
765 HWTEST_F(SocPerfServerTest, SocPerfServerTest_End_001, TestSize.Level0)
766 {
767 sleep(5);
768 EXPECT_TRUE(socPerfServer_->socPerf.enabled_);
769 }
770 } // namespace SOCPERF
771 } // namespace OHOS