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, Function | MediumTest | 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(10000, 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(10000, 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[10000];
157
158 sleep(1);
159 std::string msg = "testBoost";
160 socPerfServer_->PerfRequest(10000, msg);
161
162 ret = socPerfServer_->socPerf.RequestCmdIdCount("");
163 std::stringstream sssecond(ret);
164 while (sssecond >> key >> colon >> value >> comma) {
165 myMap[key] = value;
166 }
167 sssecond >> key >> colon >> value;
168 myMap[key] = value;
169 secondCheckColdStartNum = myMap[10000];
170
171 EXPECT_TRUE(secondCheckColdStartNum == firstCheckColdStartNum + 1);
172 }
173
174 /*
175 * @tc.name: SocPerfServerTest_SocPerfServerAPI_001
176 * @tc.desc: test socperf server api
177 * @tc.type FUNC
178 * @tc.require: issueI78T3V
179 */
180 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocPerfServerAPI_001, Function | MediumTest | Level0)
181 {
182 std::string msg = "";
183 socPerfServer_->SetRequestStatus(false, msg);
184 socPerfServer_->socPerf.ClearAllAliveRequest();
185 EXPECT_FALSE(socPerfServer_->socPerf.perfRequestEnable_);
186 #ifdef SOCPERF_ADAPTOR_FFRT
187 auto socPerfThreadWrap = std::make_shared<SocPerfThreadWrap>();
188 #else
189 auto runner = AppExecFwk::EventRunner::Create("socperf#");
190 auto socPerfThreadWrap = std::make_shared<SocPerfThreadWrap>(runner);
191 #endif
192 socPerfThreadWrap->ClearAllAliveRequest();
193 for (const std::pair<int32_t, std::shared_ptr<ResStatus>>& item : socPerfThreadWrap->resStatusInfo_) {
194 if (item.second == nullptr) {
195 continue;
196 }
197 std::list<std::shared_ptr<ResAction>>& resActionList = item.second->resActionList[ACTION_TYPE_PERF];
198 EXPECT_TRUE(resActionList.empty());
199 }
200 }
201
202 /*
203 * @tc.name: SocPerfServerTest_SocPerfServerAPI_002
204 * @tc.desc: test socperf server api
205 * @tc.type FUNC
206 * @tc.require: issueI78T3V
207 */
208 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocPerfServerAPI_002, Function | MediumTest | Level0)
209 {
210 std::string msg = "test";
211 socPerfServer_->RequestDeviceMode(msg, true);
212 auto iter = socPerfServer_->socPerf.recordDeviceMode_.find(msg);
213 EXPECT_TRUE(iter == socPerfServer_->socPerf.recordDeviceMode_.end());
214
215 socPerfServer_->RequestDeviceMode(msg, false);
216 auto iter2 = socPerfServer_->socPerf.recordDeviceMode_.find(msg);
217 EXPECT_TRUE(iter2 == socPerfServer_->socPerf.recordDeviceMode_.end());
218
219 std::string msgEmpty = "";
220 socPerfServer_->RequestDeviceMode("", true);
221 auto iter3 = socPerfServer_->socPerf.recordDeviceMode_.find(msgEmpty);
222 EXPECT_TRUE(iter3 == socPerfServer_->socPerf.recordDeviceMode_.end());
223
224 std::string msgMax = "ABCDEFGHABCDEFGHABCDEFGHABCDEFGHABCDEFGHABCDEFGHABCDEFGHABCDEFGHZ";
225 socPerfServer_->RequestDeviceMode(msgMax, true);
226 auto iter4 = socPerfServer_->socPerf.recordDeviceMode_.find(msgMax);
227 EXPECT_TRUE(iter4 == socPerfServer_->socPerf.recordDeviceMode_.end());
228 }
229
230 /*
231 * @tc.name: SocPerfServerTest_SocperfMatchCmd_001
232 * @tc.desc: test socperf MatchDeviceModeCmd func
233 * @tc.type FUNC
234 * @tc.require: issueI9GCD8
235 */
236 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocperfMatchDeviceCmd_001, Function | MediumTest | Level0)
237 {
238 std::string modeStr = "displayMain";
239 int32_t cmdTest = 10000;
240 auto it_actions = socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_.find(cmdTest);
241 if (it_actions == socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_.end()) {
242 EXPECT_EQ(modeStr, "displayMain");
243 return;
244 }
245 std::shared_ptr<Actions> actions = socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_[cmdTest];
246 if (actions->modeMap.empty()) {
247 std::shared_ptr<ModeMap> newMode = std::make_shared<ModeMap>(modeStr, cmdTest);
248 actions->modeMap.push_back(newMode);
249 }
250
251 // case : normal match
252 int32_t ret = socPerfServer_->socPerf.MatchDeviceModeCmd(cmdTest, false);
253 auto iter_match = std::find_if(actions->modeMap.begin(), actions->modeMap.end(),
__anon5f9c0b890102(const std::shared_ptr<ModeMap>& modeItem) 254 [&modeStr](const std::shared_ptr<ModeMap>& modeItem) {
255 return modeItem->mode == modeStr;
256 });
257 if (iter_match != actions->modeMap.end()) {
258 EXPECT_EQ(ret, (*iter_match)->cmdId);
259 } else {
260 EXPECT_EQ(ret, cmdTest);
261 }
262
263 // case : match cmdid is not exist branch
264 int32_t cmdInvaild = 60000;
265 auto iter_invaild = socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_.find(cmdInvaild);
266 if (iter_invaild != socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_.end()) {
267 EXPECT_EQ(cmdInvaild, 60000);
268 } else {
269 auto iter_mode = std::find_if(actions->modeMap.begin(), actions->modeMap.end(),
__anon5f9c0b890202(const std::shared_ptr<ModeMap>& modeItem) 270 [&modeStr](const std::shared_ptr<ModeMap>& modeItem) {
271 return modeItem->mode == modeStr;
272 });
273 if (iter_mode == actions->modeMap.end()) {
274 EXPECT_EQ(cmdInvaild, 60000);
275 } else {
276 (*iter_mode)->cmdId = cmdInvaild;
277 int32_t retInvaild = socPerfServer_->socPerf.MatchDeviceModeCmd(cmdTest, false);
278 EXPECT_EQ(retInvaild, cmdTest);
279 }
280 }
281
282 // case : no match mode
283 std::string modeInvaild = "test";
284 socPerfServer_->RequestDeviceMode(modeStr, false);
285 socPerfServer_->RequestDeviceMode(modeInvaild, true);
286 int32_t retModeInvaild = socPerfServer_->socPerf.MatchDeviceModeCmd(cmdTest, false);
287 EXPECT_EQ(retModeInvaild, cmdTest);
288 }
289
290 /*
291 * @tc.name: SocPerfServerTest_SocperfMatchCmd_002
292 * @tc.desc: test socperf MatchDeviceModeCmd func
293 * @tc.type FUNC
294 * @tc.require: issueI9GCD8
295 */
296 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocperfMatchCmd_002, Function | MediumTest | Level0)
297 {
298 std::string modeStr = "displayMainTest";
299 int32_t cmdTest = 10000;
300 int32_t cmdMatch = 10001;
301
302 auto it_actions = socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_.find(cmdTest);
303 if (it_actions == socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_.end()) {
304 EXPECT_EQ(modeStr, "displayMainTest");
305 return;
306 }
307 std::shared_ptr<Actions> actions = socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_[cmdTest];
308 actions->isLongTimePerf = false;
309 std::shared_ptr<ModeMap> newMode = std::make_shared<ModeMap>(modeStr, cmdMatch);
310 actions->modeMap.push_back(newMode);
311
312 auto it_match = socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_.find(cmdMatch);
313 if (it_match == socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_.end()) {
314 EXPECT_EQ(modeStr, "displayMainTest");
315 return;
316 }
317
318 // case : match cmdid is long time perf branch
319 std::shared_ptr<Actions> actionsMatch = socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_[cmdMatch];
320 actionsMatch->isLongTimePerf = true;
321 int32_t retInvaild = socPerfServer_->socPerf.MatchDeviceModeCmd(cmdTest, true);
322 EXPECT_EQ(retInvaild, cmdTest);
323 }
324
325 /*
326 * @tc.name: SocPerfServerTest_SocperfMatchCmd_003
327 * @tc.desc: test socperf MatchDeviceModeCmd func
328 * @tc.type FUNC
329 * @tc.require: issueI9GCD8
330 */
331 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocperfMatchCmd_003, Function | MediumTest | Level0)
332 {
333 std::string modeStr = "displayMainTest";
334 int32_t cmdTest = 10002;
335
336 auto it_actions = socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_.find(cmdTest);
337 if (it_actions == socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_.end()) {
338 EXPECT_EQ(modeStr, "displayMainTest");
339 return;
340 }
341
342 std::shared_ptr<Actions> actions = socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_[cmdTest];
343 std::shared_ptr<ModeMap> newMode = std::make_shared<ModeMap>(modeStr, cmdTest);
344 actions->modeMap.push_back(newMode);
345 socPerfServer_->socPerf.recordDeviceMode_.clear();
346
347 // case : match device mode is empty branch
348 int32_t retInvaild = socPerfServer_->socPerf.MatchDeviceModeCmd(cmdTest, true);
349 EXPECT_EQ(retInvaild, cmdTest);
350 }
351
352 /*
353 * @tc.name: SocPerfServerTest_SocperfParseModeCmd_001
354 * @tc.desc: test socperf ParseModeCmd func
355 * @tc.type FUNC
356 * @tc.require: issueI78T3V
357 */
358 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocperfParseModeCmd_001, Function | MediumTest | Level0)
359 {
360 const char modePairInvaild[] = "parseTest";
361 const char modeNumberInvaild[] = "parseTest=abc";
362 const char modeCmdInvaild[] = "=12345";
363 const char modeSame[] = "parseTest=12345|parseTest=23456";
364 std::string cfgFile = "bootest.xml";
365 int32_t cmdTest = 10002;
366 int32_t exceptSame = 23456;
367 std::string deviceMode = "parseTest";
368
369 auto it_actions = socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_.find(cmdTest);
370 if (it_actions == socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_.end()) {
371 EXPECT_EQ(cmdTest, 10002);
372 return;
373 }
374
375 std::shared_ptr<Actions> actions = socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_[cmdTest];
376 socPerfServer_->socPerf.socPerfConfig_.ParseModeCmd(modePairInvaild, cfgFile, actions);
377 auto iter_mode = std::find_if(actions->modeMap.begin(), actions->modeMap.end(),
__anon5f9c0b890302(const std::shared_ptr<ModeMap>& modeItem) 378 [&deviceMode](const std::shared_ptr<ModeMap>& modeItem) {
379 return modeItem->mode == deviceMode;
380 });
381 EXPECT_TRUE(iter_mode == actions->modeMap.end());
382
383 socPerfServer_->socPerf.socPerfConfig_.ParseModeCmd(modeNumberInvaild, cfgFile, actions);
384 iter_mode = std::find_if(actions->modeMap.begin(), actions->modeMap.end(),
__anon5f9c0b890402(const std::shared_ptr<ModeMap>& modeItem) 385 [&deviceMode](const std::shared_ptr<ModeMap>& modeItem) {
386 return modeItem->mode == deviceMode;
387 });
388 EXPECT_TRUE(iter_mode == actions->modeMap.end());
389
390 socPerfServer_->socPerf.socPerfConfig_.ParseModeCmd(modeCmdInvaild, cfgFile, actions);
391 iter_mode = std::find_if(actions->modeMap.begin(), actions->modeMap.end(),
__anon5f9c0b890502(const std::shared_ptr<ModeMap>& modeItem) 392 [&deviceMode](const std::shared_ptr<ModeMap>& modeItem) {
393 return modeItem->mode == deviceMode;
394 });
395 EXPECT_TRUE(iter_mode == actions->modeMap.end());
396
397 int32_t size = actions->modeMap.size();
398 socPerfServer_->socPerf.socPerfConfig_.ParseModeCmd(modeSame, cfgFile, actions);
399 EXPECT_EQ(size + 1, actions->modeMap.size());
400 auto iterSame = std::find_if(actions->modeMap.begin(), actions->modeMap.end(),
__anon5f9c0b890602(const std::shared_ptr<ModeMap>& modeItem) 401 [&deviceMode](const std::shared_ptr<ModeMap>& modeItem) {
402 return modeItem->mode == deviceMode;
403 });
404 ASSERT_TRUE(iterSame != actions->modeMap.end());
405 EXPECT_EQ(exceptSame, (*iterSame)->cmdId);
406
407 int32_t sizeBefore = actions->modeMap.size();
408 const char *modeNullInvaild = nullptr;
409 socPerfServer_->socPerf.socPerfConfig_.ParseModeCmd(modeNullInvaild, cfgFile, actions);
410 EXPECT_EQ(sizeBefore, actions->modeMap.size());
411 }
412
413 /*
414 * @tc.name: SocPerfServerTest_SocperfThreadWrapp_001
415 * @tc.desc: test log switch func
416 * @tc.type FUNC
417 * @tc.require: issueI78T3V
418 */
419 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SocperfThreadWrapp_001, Function | MediumTest | Level0)
420 {
421 std::string msg = "";
422 #ifdef SOCPERF_ADAPTOR_FFRT
423 auto socPerfThreadWrap = std::make_shared<SocPerfThreadWrap>();
424 #else
425 auto runner = AppExecFwk::EventRunner::Create("socperf#");
426 auto socPerfThreadWrap = std::make_shared<SocPerfThreadWrap>(runner);
427 #endif
428 socPerfThreadWrap->PostDelayTask(1000, nullptr);
429 socPerfThreadWrap->InitResourceNodeInfo();
430 socPerfThreadWrap->socPerfConfig_.InitPerfFunc(nullptr, nullptr, nullptr);
431 socPerfThreadWrap->socPerfConfig_.InitPerfFunc(nullptr, msg.c_str(), msg.c_str());
432 socPerfThreadWrap->socPerfConfig_.InitPerfFunc(msg.c_str(), nullptr, nullptr);
433 socPerfThreadWrap->socPerfConfig_.InitPerfFunc(msg.c_str(), msg.c_str(), msg.c_str());
434 socPerfThreadWrap->DoFreqActionPack(nullptr);
435 socPerfThreadWrap->UpdateLimitStatus(0, nullptr, 0);
436 socPerfThreadWrap->DoFreqAction(0, nullptr);
437 socPerfThreadWrap->DoFreqAction(1000, nullptr);
438 EXPECT_NE(msg.c_str(), "-1");
439 bool ret = false;
440 int inValidResId = 9999;
441 ret = socPerfThreadWrap->socPerfConfig_.IsValidResId(inValidResId);
442 EXPECT_FALSE(ret);
443 ret = socPerfThreadWrap->socPerfConfig_.IsGovResId(inValidResId);
444 EXPECT_FALSE(ret);
445 int32_t level = 10;
446 int64_t value = 0;
447 ret = socPerfThreadWrap->GetResValueByLevel(inValidResId, level, value);
448 EXPECT_FALSE(ret);
449 }
450
451 class SocperfStubTest : public SocPerfStub {
452 public:
SocperfStubTest()453 SocperfStubTest() {}
PerfRequest(int32_t cmdId,const std::string & msg)454 ErrCode PerfRequest(int32_t cmdId, const std::string& msg) override
455 {
456 return ERR_OK;
457 }
PerfRequestEx(int32_t cmdId,bool onOffTag,const std::string & msg)458 ErrCode PerfRequestEx(int32_t cmdId, bool onOffTag, const std::string& msg) override
459 {
460 return ERR_OK;
461 }
PowerLimitBoost(bool onOffTag,const std::string & msg)462 ErrCode PowerLimitBoost(bool onOffTag, const std::string& msg) override
463 {
464 return ERR_OK;
465 }
ThermalLimitBoost(bool onOffTag,const std::string & msg)466 ErrCode ThermalLimitBoost(bool onOffTag, const std::string& msg) override
467 {
468 return ERR_OK;
469 }
LimitRequest(int32_t clientId,const std::vector<int32_t> & tags,const std::vector<int64_t> & configs,const std::string & msg)470 ErrCode LimitRequest(int32_t clientId,
471 const std::vector<int32_t>& tags, const std::vector<int64_t>& configs, const std::string& msg) override
472 {
473 return ERR_OK;
474 }
SetRequestStatus(bool status,const std::string & msg)475 ErrCode SetRequestStatus(bool status, const std::string& msg) override
476 {
477 return ERR_OK;
478 }
SetThermalLevel(int32_t level)479 ErrCode SetThermalLevel(int32_t level) override
480 {
481 return ERR_OK;
482 }
RequestDeviceMode(const std::string & mode,bool status)483 ErrCode RequestDeviceMode(const std::string& mode, bool status) override
484 {
485 return ERR_OK;
486 }
RequestCmdIdCount(const std::string & msg,std::string & funcResult)487 ErrCode RequestCmdIdCount(const std::string& msg, std::string& funcResult) override
488 {
489 return ERR_OK;
490 }
491 };
492
493 /*
494 * @tc.name: SocPerfStubTest_SocPerfServerAPI_001
495 * @tc.desc: test socperf stub api
496 * @tc.type FUNC
497 * @tc.require: issueI78T3V
498 */
499 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_001, Function | MediumTest | Level0)
500 {
501 SocperfStubTest socPerfStub;
502 MessageParcel data;
503 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
504 data.WriteInt32(10000);
505 data.WriteString("");
506 MessageParcel reply;
507 MessageOption option;
508 uint32_t requestIpcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_PERF_REQUEST);
509 int32_t ret = socPerfStub.OnRemoteRequest(requestIpcId, data, reply, option);
510 EXPECT_EQ(ret, ERR_OK);
511 }
512
513 /*
514 * @tc.name: SocPerfStubTest_SocPerfServerAPI_002
515 * @tc.desc: test socperf stub api
516 * @tc.type FUNC
517 * @tc.require: issueI78T3V
518 */
519 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_002, Function | MediumTest | Level0)
520 {
521 SocperfStubTest socPerfStub;
522 MessageParcel data;
523 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
524 data.WriteInt32(10000);
525 data.WriteBool(true);
526 data.WriteString("");
527 MessageParcel reply;
528 MessageOption option;
529 uint32_t requestExIpcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_PERF_REQUEST_EX);
530 int32_t ret = socPerfStub.OnRemoteRequest(requestExIpcId, data, reply, option);
531 EXPECT_EQ(ret, ERR_OK);
532 }
533
534 /*
535 * @tc.name: SocPerfStubTest_SocPerfServerAPI_003
536 * @tc.desc: test socperf stub api
537 * @tc.type FUNC
538 * @tc.require: issueI78T3V
539 */
540 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_003, Function | MediumTest | Level0)
541 {
542 SocperfStubTest socPerfStub;
543 MessageParcel data;
544 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
545 data.WriteInt32(1);
546 std::vector<int32_t> tags = {1001};
547 data.WriteInt32Vector(tags);
548 std::vector<int64_t> configs = {1416000};
549 data.WriteInt64Vector(configs);
550 data.WriteString("");
551 MessageParcel reply;
552 MessageOption option;
553 uint32_t powerLimitId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_LIMIT_REQUEST);
554 int32_t ret = socPerfStub.OnRemoteRequest(powerLimitId, data, reply, option);
555 EXPECT_EQ(ret, ERR_OK);
556 }
557
558 /*
559 * @tc.name: SocPerfStubTest_SocPerfServerAPI_004
560 * @tc.desc: test socperf stub api
561 * @tc.type FUNC
562 * @tc.require: issueI78T3V
563 */
564 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_004, Function | MediumTest | Level0)
565 {
566 SocperfStubTest socPerfStub;
567 MessageParcel data;
568 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
569 data.WriteBool(true);
570 data.WriteString("");
571 MessageParcel reply;
572 MessageOption option;
573 uint32_t powerLimitIpcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_POWER_LIMIT_BOOST);
574 int32_t ret = socPerfStub.OnRemoteRequest(powerLimitIpcId, data, reply, option);
575 EXPECT_EQ(ret, ERR_OK);
576 }
577
578 /*
579 * @tc.name: SocPerfStubTest_SocPerfServerAPI_005
580 * @tc.desc: test socperf stub api
581 * @tc.type FUNC
582 * @tc.require: issueI78T3V
583 */
584 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_005, Function | MediumTest | Level0)
585 {
586 SocperfStubTest socPerfStub;
587 MessageParcel data;
588 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
589 data.WriteBool(true);
590 data.WriteString("");
591 MessageParcel reply;
592 MessageOption option;
593 uint32_t thermalLimitIpcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_THERMAL_LIMIT_BOOST);
594 int32_t ret = socPerfStub.OnRemoteRequest(thermalLimitIpcId, data, reply, option);
595 EXPECT_EQ(ret, ERR_OK);
596 }
597
598 /*
599 * @tc.name: SocPerfStubTest_SocPerfServerAPI_006
600 * @tc.desc: test socperf stub api
601 * @tc.type FUNC
602 * @tc.require: issueI78T3V
603 */
604 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_006, Function | MediumTest | Level0)
605 {
606 SocperfStubTest socPerfStub;
607 MessageParcel data;
608 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
609 data.WriteBool(true);
610 MessageParcel reply;
611 MessageOption option;
612 uint32_t ipcId = 0x000f;
613 int32_t ret = socPerfStub.OnRemoteRequest(ipcId, data, reply, option);
614 EXPECT_NE(ret, ERR_OK);
615 }
616
617 /*
618 * @tc.name: SocPerfStubTest_SocPerfServerAPI_007
619 * @tc.desc: test socperf stub api
620 * @tc.type FUNC
621 * @tc.require: issueI78T3V
622 */
623 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_007, Function | MediumTest | Level0)
624 {
625 SocperfStubTest socPerfStub;
626 MessageParcel data;
627 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
628 data.WriteBool(false);
629 data.WriteString("");
630 MessageParcel reply;
631 MessageOption option;
632 uint32_t ipcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_SET_REQUEST_STATUS);
633 int32_t ret = socPerfStub.OnRemoteRequest(ipcId, data, reply, option);
634 EXPECT_EQ(ret, ERR_OK);
635
636 MessageParcel dataPerf;
637 dataPerf.WriteInterfaceToken(SocPerfStub::GetDescriptor());
638 dataPerf.WriteInt32(10000);
639 dataPerf.WriteString("");
640 MessageParcel replyPerf;
641 MessageOption optionPerf;
642 uint32_t requestPerfIpcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_PERF_REQUEST);
643 ret = socPerfStub.OnRemoteRequest(requestPerfIpcId, dataPerf, replyPerf, optionPerf);
644 EXPECT_EQ(ret, ERR_OK);
645
646 MessageParcel dataLimit;
647 dataLimit.WriteInterfaceToken(SocPerfStub::GetDescriptor());
648 dataLimit.WriteInt32(1);
649 std::vector<int32_t> tags = {1001};
650 dataLimit.WriteInt32Vector(tags);
651 std::vector<int64_t> configs = {1416000};
652 dataLimit.WriteInt64Vector(configs);
653 dataLimit.WriteString("");
654 MessageParcel replyLimit;
655 MessageOption optionLimit;
656 uint32_t powerLimitId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_LIMIT_REQUEST);
657 ret = socPerfStub.OnRemoteRequest(powerLimitId, dataLimit, reply, option);
658 EXPECT_EQ(ret, ERR_OK);
659 }
660
661
662 /*
663 * @tc.name: SocPerfStubTest_SocPerfServerAPI_008
664 * @tc.desc: test socperf requet device mode stub api
665 * @tc.type FUNC
666 * @tc.require: issue#I95U8S
667 */
668 HWTEST_F(SocPerfServerTest, SocPerfStubTest_SocPerfServerAPI_008, Function | MediumTest | Level0)
669 {
670 SocperfStubTest socPerfStub;
671 MessageParcel data;
672 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
673 data.WriteString("test");
674 data.WriteBool(true);
675 MessageParcel reply;
676 MessageOption option;
677 uint32_t ipcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_REQUEST_DEVICE_MODE);
678 int32_t ret = socPerfStub.OnRemoteRequest(ipcId, data, reply, option);
679 EXPECT_EQ(ret, ERR_OK);
680 }
681
682 /*
683 * @tc.name: SocPerfServerTest_SetThermalLevel_001
684 * @tc.desc: perf request lvl server API
685 * @tc.type FUNC
686 * @tc.require: issue#I95U8S
687 */
688 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SetThermalLevel_Server_001, Function | MediumTest | Level0)
689 {
690 SocperfStubTest socPerfStub;
691 MessageParcel data;
692 data.WriteInterfaceToken(SocPerfStub::GetDescriptor());
693 data.WriteInt32(3);
694 MessageParcel reply;
695 MessageOption option;
696 uint32_t ipcId = static_cast<uint32_t>(ISocPerfIpcCode::COMMAND_SET_THERMAL_LEVEL);
697 int32_t ret = socPerfStub.OnRemoteRequest(ipcId, data, reply, option);
698 EXPECT_EQ(ret, ERR_OK);
699 }
700
701 /*
702 * @tc.name: SocPerfServerTest_SetThermalLevel_Server_002
703 * @tc.desc: perf request lvl server API
704 * @tc.type FUNC
705 * @tc.require: issue#I95U8S
706 */
707 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SetThermalLevel_Server_002, Function | MediumTest | Level0)
708 {
709 socPerfServer_->SetThermalLevel(3);
710 EXPECT_EQ(socPerfServer_->socPerf.thermalLvl_, 3);
711 }
712
713 /*
714 * @tc.name: SocPerfServerTest_SetThermalLevel_Server_003
715 * @tc.desc: perf request lvl server API
716 * @tc.type FUNC
717 * @tc.require: issue#I95U8S
718 */
719 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SetThermalLevel_Server_003, Function | MediumTest | Level0)
720 {
721 const int32_t appColdStartCmdId = 10000;
722 const int32_t appWarmStartCmdId = 10001;
723 if (socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_[appColdStartCmdId] == nullptr ||
724 socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_[appWarmStartCmdId] == nullptr) {
725 SUCCEED();
726 return;
727 }
728 std::shared_ptr<Actions> appColdStartActions =
729 socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_[appColdStartCmdId];
730 std::list<std::shared_ptr<Action>> appColdStartActionList = appColdStartActions->actionList;
731 for (auto item : appColdStartActionList) {
732 item->thermalCmdId_ = 88888;
733 bool ret = socPerfServer_->socPerf.DoPerfRequestThremalLvl(appColdStartCmdId, item, EVENT_INVALID);
734 EXPECT_FALSE(ret);
735
736 item->thermalCmdId_ = appWarmStartCmdId;
737 ret = socPerfServer_->socPerf.DoPerfRequestThremalLvl(appColdStartCmdId, item, EVENT_INVALID);
738 EXPECT_TRUE(ret);
739 }
740 SUCCEED();
741 }
742
743 /*
744 * @tc.name: SocPerfServerTest_SetThermalLevel_Server_004
745 * @tc.desc: perf request lvl server API
746 * @tc.type FUNC
747 * @tc.require: issue#I95U8S
748 */
749 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SetThermalLevel_Server_004, Function | MediumTest | Level0)
750 {
751 const int32_t appColdStartCmdId = 10000;
752 const int32_t appWarmStartCmdId = 10001;
753 if (socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_[appColdStartCmdId] == nullptr ||
754 socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_[appWarmStartCmdId] == nullptr) {
755 SUCCEED();
756 return;
757 }
758 std::shared_ptr<Actions> appWarmStartActions =
759 socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_[appWarmStartCmdId];
760 std::shared_ptr<Actions> appColdStartActions =
761 socPerfServer_->socPerf.socPerfConfig_.perfActionsInfo_[appColdStartCmdId];
762 std::list<std::shared_ptr<Action>> appWarmStartActionList = appWarmStartActions->actionList;
763 int32_t minThermalLvl = 3;
764 for (auto item : appWarmStartActionList) {
765 (*item).thermalLvl_ = minThermalLvl;
766 minThermalLvl++;
767 }
768 std::list<std::shared_ptr<Action>> appColdStartActionList = appColdStartActions->actionList;
769 for (auto item : appColdStartActionList) {
770 (*item).thermalCmdId_ = appWarmStartCmdId;
771 socPerfServer_->SetThermalLevel(1);
772 bool ret = socPerfServer_->socPerf.DoPerfRequestThremalLvl(appColdStartCmdId, item, EVENT_INVALID);
773 EXPECT_FALSE(ret);
774
775 socPerfServer_->SetThermalLevel(3);
776 ret = socPerfServer_->socPerf.DoPerfRequestThremalLvl(appColdStartCmdId, item, EVENT_INVALID);
777 EXPECT_TRUE(ret);
778
779 socPerfServer_->SetThermalLevel(99);
780 ret = socPerfServer_->socPerf.DoPerfRequestThremalLvl(appColdStartCmdId, item, EVENT_INVALID);
781 EXPECT_TRUE(ret);
782 }
783 }
784
785 /*
786 * @tc.name: SocPerfServerTest_SetThermalLevel_Server_005
787 * @tc.desc: perf request lvl server API
788 * @tc.type FUNC
789 * @tc.require: issue#I95U8S
790 */
791 HWTEST_F(SocPerfServerTest, SocPerfServerTest_SetThermalLevel_Server_005, Function | MediumTest | Level0)
792 {
793 int32_t litCpuMinFreq = 1000;
794 int32_t litCpuMaxFreq = 1001;
795 std::shared_ptr<SocPerfThreadWrap> socPerfThreadWrap = socPerfServer_->socPerf.socperfThreadWrap_;
796 socPerfThreadWrap->resStatusInfo_[litCpuMinFreq]->candidatesValue[ACTION_TYPE_PERFLVL] = 1000;
797 bool ret = socPerfThreadWrap->ArbitratePairResInPerfLvl(litCpuMinFreq);
798 EXPECT_TRUE(ret);
799
800 socPerfThreadWrap->resStatusInfo_[litCpuMinFreq]->candidatesValue[ACTION_TYPE_PERFLVL] = INVALID_VALUE;
801 socPerfThreadWrap->resStatusInfo_[litCpuMaxFreq]->candidatesValue[ACTION_TYPE_PERFLVL] = 1000;
802 ret = socPerfThreadWrap->ArbitratePairResInPerfLvl(litCpuMinFreq);
803 EXPECT_TRUE(ret);
804
805 socPerfThreadWrap->resStatusInfo_[litCpuMinFreq]->candidatesValue[ACTION_TYPE_PERFLVL] = INVALID_VALUE;
806 socPerfThreadWrap->resStatusInfo_[litCpuMaxFreq]->candidatesValue[ACTION_TYPE_PERFLVL] = INVALID_VALUE;
807 ret = socPerfThreadWrap->ArbitratePairResInPerfLvl(litCpuMinFreq);
808 EXPECT_FALSE(ret);
809 }
810
811 /*
812 * @tc.name: SocPerfServerTest_End_001
813 * @tc.desc: perf end
814 * @tc.type FUNC
815 * @tc.require: issue#I95U8S
816 */
817 HWTEST_F(SocPerfServerTest, SocPerfServerTest_End_001, Function | MediumTest | Level0)
818 {
819 sleep(5);
820 EXPECT_TRUE(socPerfServer_->socPerf.enabled_);
821 }
822 } // namespace SOCPERF
823 } // namespace OHOS