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 
27 using namespace testing::ext;
28 using namespace testing::mt;
29 
30 namespace OHOS {
31 namespace SOCPERF {
32 class SocPerfServerTest : public testing::Test {
33 public:
34     static void SetUpTestCase(void);
35     static void TearDownTestCase(void);
36     void SetUp();
37     void TearDown();
38 private:
39     std::shared_ptr<SocPerfServer> socPerfServer_ = DelayedSingleton<SocPerfServer>::GetInstance();
40 };
41 
SetUpTestCase(void)42 void SocPerfServerTest::SetUpTestCase(void)
43 {
44 }
45 
TearDownTestCase(void)46 void SocPerfServerTest::TearDownTestCase(void)
47 {
48 }
49 
SetUp(void)50 void SocPerfServerTest::SetUp(void)
51 {
52 }
53 
TearDown(void)54 void 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  */
64 HWTEST_F(SocPerfServerTest, SocPerfServerTest_Init_Config_001, Function | MediumTest | Level0)
65 {
66     socPerfServer_->OnStart();
67     sleep(1);
68     SUCCEED();
69 }
70 
71 /*
72  * @tc.name: SocPerfServerTest_SocPerfAPI_001
73  * @tc.desc: test socperf api
74  * @tc.type FUNC
75  * @tc.require: issueI78T3V
76  */
77 HWTEST_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  */
113 HWTEST_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  */
142 HWTEST_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  */
181 HWTEST_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  */
209 HWTEST_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  */
237 HWTEST_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  */
293 HWTEST_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  */
327 HWTEST_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  */
353 HWTEST_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  */
399 HWTEST_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 
431 class SocperfStubTest : public SocPerfStub {
432 public:
SocperfStubTest()433     SocperfStubTest() {}
PerfRequest(int32_t cmdId,const std::string & msg)434     void PerfRequest(int32_t cmdId, const std::string& msg) override {}
PerfRequestEx(int32_t cmdId,bool onOffTag,const std::string & msg)435     void PerfRequestEx(int32_t cmdId, bool onOffTag, const std::string& msg) override {}
PowerLimitBoost(bool onOffTag,const std::string & msg)436     void PowerLimitBoost(bool onOffTag, const std::string& msg) override {}
ThermalLimitBoost(bool onOffTag,const std::string & msg)437     void ThermalLimitBoost(bool onOffTag, const std::string& msg) override {}
LimitRequest(int32_t clientId,const std::vector<int32_t> & tags,const std::vector<int64_t> & configs,const std::string & msg)438     void LimitRequest(int32_t clientId,
439         const std::vector<int32_t>& tags, const std::vector<int64_t>& configs, const std::string& msg) override {}
SetRequestStatus(bool status,const std::string & msg)440     void SetRequestStatus(bool status, const std::string& msg) override {};
SetThermalLevel(int32_t level)441     void SetThermalLevel(int32_t level) override {};
RequestDeviceMode(const std::string & mode,bool status)442     void RequestDeviceMode(const std::string& mode, bool status) override {};
RequestCmdIdCount(const std::string & msg)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  */
455 HWTEST_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  */
475 HWTEST_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  */
496 HWTEST_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  */
520 HWTEST_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  */
540 HWTEST_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  */
560 HWTEST_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  */
579 HWTEST_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  */
624 HWTEST_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  */
644 HWTEST_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  */
663 HWTEST_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  */
675 HWTEST_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  */
705 HWTEST_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  */
747 HWTEST_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 } // namespace SOCPERF
767 } // namespace OHOS