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