1 /*
2 * Copyright (c) 2024-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 <dlfcn.h>
20 #include <gtest/gtest.h>
21 #include <gtest/hwext/gtest-multithread.h>
22 #include "res_type.h"
23 #define private public
24 #include "socperf_plugin.h"
25 #undef private
26
27 using namespace testing::ext;
28 using namespace testing::mt;
29
30 namespace OHOS {
31 namespace ResourceSchedule {
32 namespace {
33 std::string SOCPERF_PLUBIN_LIB_NAME = "libsocperf_plugin.z.so";
34 std::string ERROR_LIB_NAME = "";
35 using OnPluginInitFunc = bool (*)(std::string& libName);
36 using OnPluginDisableFunc = void (*)();
37 using OnDispatchResourceFunc = void (*)(const std::shared_ptr<ResData>& data);
38 }
39 class SocPerfPluginTest : public testing::Test {
40 public:
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase(void)47 void SocPerfPluginTest::SetUpTestCase(void)
48 {
49 SocPerfPlugin::GetInstance().Init();
50 }
51
TearDownTestCase(void)52 void SocPerfPluginTest::TearDownTestCase(void)
53 {
54 SocPerfPlugin::GetInstance().Disable();
55 }
56
SetUp(void)57 void SocPerfPluginTest::SetUp(void)
58 {
59 }
60
TearDown(void)61 void SocPerfPluginTest::TearDown(void)
62 {
63 }
64
65 /*
66 * @tc.name: SocPerfPluginTest_LibTest_001
67 * @tc.desc: test socperfplugin lib
68 * @tc.type FUNC
69 * @tc.require: issueI78T3V
70 */
71 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_LibTest_001, Function | MediumTest | Level0)
72 {
73 auto handle = dlopen(SOCPERF_PLUBIN_LIB_NAME.c_str(), RTLD_NOW);
74 EXPECT_NE(handle, nullptr);
75 OnPluginInitFunc onPluginInitFunc = reinterpret_cast<OnPluginInitFunc>(dlsym(handle, "OnPluginInit"));
76 EXPECT_NE(onPluginInitFunc, nullptr);
77 EXPECT_TRUE(onPluginInitFunc(SOCPERF_PLUBIN_LIB_NAME));
78 EXPECT_FALSE(onPluginInitFunc(ERROR_LIB_NAME));
79 OnPluginDisableFunc onPluginDisableFunc = reinterpret_cast<OnPluginDisableFunc>(dlsym(handle, "OnPluginDisable"));
80 EXPECT_NE(onPluginDisableFunc, nullptr);
81 onPluginDisableFunc();
82 OnDispatchResourceFunc onDispatchResourceFunc = reinterpret_cast<OnDispatchResourceFunc>(dlsym(handle,
83 "OnDispatchResource"));
84 EXPECT_NE(onDispatchResourceFunc, nullptr);
85 const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_APP_ABILITY_START,
86 ResType::AppStartType::APP_COLD_START, nullptr);
87 onDispatchResourceFunc(data);
88 const std::shared_ptr<ResData>& dataInvalid = std::make_shared<ResData>(-1, -1, nullptr);
89 onDispatchResourceFunc(dataInvalid);
90 SUCCEED();
91 }
92
93 /*
94 * @tc.name: SocPerfPluginTest_API_TEST_001
95 * @tc.desc: test socperfplugin api
96 * @tc.type FUNC
97 * @tc.require: issueI78T3V
98 */
99 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_001, Function | MediumTest | Level0)
100 {
101 const std::shared_ptr<ResData>& coldStartData = std::make_shared<ResData>(ResType::RES_TYPE_APP_ABILITY_START,
102 ResType::AppStartType::APP_COLD_START, nullptr);
103 SocPerfPlugin::GetInstance().HandleAppAbilityStart(coldStartData);
104 SocPerfPlugin::GetInstance().HandleAppAbilityStart(coldStartData);
105 const std::shared_ptr<ResData>& warmStartData = std::make_shared<ResData>(ResType::RES_TYPE_APP_ABILITY_START,
106 ResType::AppStartType::APP_WARM_START, nullptr);
107 SocPerfPlugin::GetInstance().HandleAppAbilityStart(warmStartData);
108 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
109 SocPerfPlugin::GetInstance().HandleAppAbilityStart(invalidData);
110 EXPECT_NE(coldStartData, nullptr);
111 }
112
113 /*
114 * @tc.name: SocPerfPluginTest_API_TEST_002
115 * @tc.desc: test socperfplugin api
116 * @tc.type FUNC
117 * @tc.require: issueI78T3V
118 */
119 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_002, Function | MediumTest | Level0)
120 {
121 const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_WINDOW_FOCUS,
122 ResType::WindowFocusStatus::WINDOW_FOCUS, nullptr);
123 SocPerfPlugin::GetInstance().HandleWindowFocus(data);
124 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
125 SocPerfPlugin::GetInstance().HandleWindowFocus(invalidData);
126 EXPECT_NE(data, nullptr);
127 }
128
129 /*
130 * @tc.name: SocPerfPluginTest_API_TEST_003
131 * @tc.desc: test socperfplugin api
132 * @tc.type FUNC
133 * @tc.require: issueI78T3V
134 */
135 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_003, Function | MediumTest | Level0)
136 {
137 const std::shared_ptr<ResData>& touchDownData = std::make_shared<ResData>(ResType::RES_TYPE_CLICK_RECOGNIZE,
138 ResType::ClickEventType::TOUCH_EVENT_DOWN, nullptr);
139 SocPerfPlugin::GetInstance().HandleEventClick(touchDownData);
140 const std::shared_ptr<ResData>& clickData = std::make_shared<ResData>(ResType::RES_TYPE_CLICK_RECOGNIZE,
141 ResType::ClickEventType::CLICK_EVENT, nullptr);
142 SocPerfPlugin::GetInstance().HandleEventClick(clickData);
143 const std::shared_ptr<ResData>& touchUpData = std::make_shared<ResData>(ResType::RES_TYPE_CLICK_RECOGNIZE,
144 ResType::ClickEventType::TOUCH_EVENT_UP, nullptr);
145 SocPerfPlugin::GetInstance().HandleEventClick(touchUpData);
146 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
147 SocPerfPlugin::GetInstance().HandleEventClick(invalidData);
148 EXPECT_NE(touchDownData, nullptr);
149 }
150
151 /*
152 * @tc.name: SocPerfPluginTest_API_TEST_004
153 * @tc.desc: test socperfplugin api
154 * @tc.type FUNC
155 * @tc.require: issueI78T3V
156 */
157 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_004, Function | MediumTest | Level0)
158 {
159 const std::shared_ptr<ResData>& loadPageStartData = std::make_shared<ResData>(ResType::RES_TYPE_LOAD_PAGE,
160 ResType::LOAD_PAGE_START, nullptr);
161 SocPerfPlugin::GetInstance().HandleLoadPage(loadPageStartData);
162 SocPerfPlugin::GetInstance().HandleLoadPage(loadPageStartData);
163 const std::shared_ptr<ResData>& loadPageEndData = std::make_shared<ResData>(ResType::RES_TYPE_LOAD_PAGE,
164 ResType::LOAD_PAGE_COMPLETE, nullptr);
165 SocPerfPlugin::GetInstance().HandleLoadPage(loadPageEndData);
166 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
167 SocPerfPlugin::GetInstance().HandleLoadPage(invalidData);
168 EXPECT_NE(loadPageStartData, nullptr);
169 }
170
171 /*
172 * @tc.name: SocPerfPluginTest_API_TEST_005
173 * @tc.desc: test socperfplugin api
174 * @tc.type FUNC
175 * @tc.require: issueI78T3V
176 */
177 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_005, Function | MediumTest | Level0)
178 {
179 const std::shared_ptr<ResData>& slideEventOnData = std::make_shared<ResData>(ResType::RES_TYPE_SLIDE_RECOGNIZE,
180 ResType::SlideEventStatus::SLIDE_EVENT_ON, nullptr);
181 SocPerfPlugin::GetInstance().HandleEventSlide(slideEventOnData);
182 const std::shared_ptr<ResData>& slideEventOffData = std::make_shared<ResData>(ResType::RES_TYPE_SLIDE_RECOGNIZE,
183 ResType::SlideEventStatus::SLIDE_EVENT_OFF, nullptr);
184 SocPerfPlugin::GetInstance().HandleEventSlide(slideEventOffData);
185 const std::shared_ptr<ResData>& slideNormalBeginData = std::make_shared<ResData>(ResType::RES_TYPE_SLIDE_RECOGNIZE,
186 ResType::SlideEventStatus::SLIDE_NORMAL_BEGIN, nullptr);
187 SocPerfPlugin::GetInstance().HandleEventSlide(slideNormalBeginData);
188 const std::shared_ptr<ResData>& slideNormalEndData = std::make_shared<ResData>(ResType::RES_TYPE_SLIDE_RECOGNIZE,
189 ResType::SlideEventStatus::SLIDE_NORMAL_END, nullptr);
190 SocPerfPlugin::GetInstance().HandleEventSlide(slideNormalEndData);
191 const std::shared_ptr<ResData>& moveData = std::make_shared<ResData>(ResType::RES_TYPE_SLIDE_RECOGNIZE,
192 ResType::SlideEventStatus::MOVE_EVENT_ON, nullptr);
193 SocPerfPlugin::GetInstance().HandleEventSlide(moveData);
194 SocPerfPlugin::GetInstance().HandleContinuousDrag(7);
195 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
196 SocPerfPlugin::GetInstance().HandleEventSlide(invalidData);
197 EXPECT_NE(slideEventOnData, nullptr);
198 }
199
200 /*
201 * @tc.name: SocPerfPluginTest_API_TEST_006
202 * @tc.desc: test socperfplugin api
203 * @tc.type FUNC
204 * @tc.require: issueI78T3V
205 */
206 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_006, Function | MediumTest | Level0)
207 {
208 const std::shared_ptr<ResData>& webGestureStartData = std::make_shared<ResData>(ResType::RES_TYPE_WEB_GESTURE,
209 ResType::WebGesture::WEB_GESTURE_START, nullptr);
210 SocPerfPlugin::GetInstance().HandleEventWebGesture(webGestureStartData);
211 const std::shared_ptr<ResData>& webGestureEndData = std::make_shared<ResData>(ResType::RES_TYPE_WEB_GESTURE,
212 ResType::WebGesture::WEB_GESTURE_END, nullptr);
213 SocPerfPlugin::GetInstance().HandleEventWebGesture(webGestureEndData);
214 SocPerfPlugin::GetInstance().HandleEventWebGesture(nullptr);
215 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
216 SocPerfPlugin::GetInstance().HandleEventWebGesture(invalidData);
217 EXPECT_NE(webGestureStartData, nullptr);
218 }
219
220 /*
221 * @tc.name: SocPerfPluginTest_API_TEST_007
222 * @tc.desc: test socperfplugin api
223 * @tc.type FUNC
224 * @tc.require: issueI78T3V
225 */
226 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_007, Function | MediumTest | Level0)
227 {
228 const std::shared_ptr<ResData>& windowResizingData = std::make_shared<ResData>(ResType::RES_TYPE_RESIZE_WINDOW,
229 ResType::WindowResizeType::WINDOW_RESIZING, nullptr);
230 SocPerfPlugin::GetInstance().HandleResizeWindow(windowResizingData);
231 const std::shared_ptr<ResData>& webGestureEndData = std::make_shared<ResData>(ResType::RES_TYPE_WEB_GESTURE,
232 ResType::WindowResizeType::WINDOW_RESIZE_STOP, nullptr);
233 SocPerfPlugin::GetInstance().HandleResizeWindow(webGestureEndData);
234 SocPerfPlugin::GetInstance().HandleResizeWindow(nullptr);
235 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
236 SocPerfPlugin::GetInstance().HandleResizeWindow(invalidData);
237 EXPECT_NE(windowResizingData, nullptr);
238 }
239
240 /*
241 * @tc.name: SocPerfPluginTest_API_TEST_008
242 * @tc.desc: test socperfplugin api
243 * @tc.type FUNC
244 * @tc.require: issueI78T3V
245 */
246 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_008, Function | MediumTest | Level0)
247 {
248 const std::shared_ptr<ResData>& windowMovingData = std::make_shared<ResData>(ResType::RES_TYPE_MOVE_WINDOW,
249 ResType::WindowMoveType::WINDOW_MOVING, nullptr);
250 SocPerfPlugin::GetInstance().HandleMoveWindow(windowMovingData);
251 const std::shared_ptr<ResData>& windowMoveStop = std::make_shared<ResData>(ResType::RES_TYPE_MOVE_WINDOW,
252 ResType::WindowMoveType::WINDOW_MOVE_STOP, nullptr);
253 SocPerfPlugin::GetInstance().HandleMoveWindow(windowMoveStop);
254 SocPerfPlugin::GetInstance().HandleMoveWindow(nullptr);
255 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
256 SocPerfPlugin::GetInstance().HandleMoveWindow(invalidData);
257 EXPECT_NE(windowMovingData, nullptr);
258 }
259
260 /*
261 * @tc.name: SocPerfPluginTest_API_TEST_009
262 * @tc.desc: test socperfplugin api
263 * @tc.type FUNC
264 * @tc.require: issueI78T3V
265 */
266 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_009, Function | MediumTest | Level0)
267 {
268 const std::shared_ptr<ResData>& animationEndData = std::make_shared<ResData>(
269 ResType::RES_TYPE_SHOW_REMOTE_ANIMATION, ResType::ShowRemoteAnimationStatus::ANIMATION_END, nullptr);
270 SocPerfPlugin::GetInstance().HandleRemoteAnimation(animationEndData);
271 const std::shared_ptr<ResData>& animationBeginData = std::make_shared<ResData>(
272 ResType::RES_TYPE_SHOW_REMOTE_ANIMATION, ResType::ShowRemoteAnimationStatus::ANIMATION_BEGIN, nullptr);
273 SocPerfPlugin::GetInstance().HandleRemoteAnimation(animationBeginData);
274 const std::shared_ptr<ResData>& unlockEndData = std::make_shared<ResData>(
275 ResType::RES_TYPE_SHOW_REMOTE_ANIMATION, ResType::ShowRemoteAnimationStatus::ANIMATION_UNLOCK_END, nullptr);
276 SocPerfPlugin::GetInstance().HandleRemoteAnimation(unlockEndData);
277 const std::shared_ptr<ResData>& unlockBeginData = std::make_shared<ResData>(
278 ResType::RES_TYPE_SHOW_REMOTE_ANIMATION, ResType::ShowRemoteAnimationStatus::ANIMATION_UNLOCK_BEGIN, nullptr);
279 SocPerfPlugin::GetInstance().HandleRemoteAnimation(unlockBeginData);
280 SocPerfPlugin::GetInstance().HandleRemoteAnimation(animationEndData);
281 SocPerfPlugin::GetInstance().HandleRemoteAnimation(unlockEndData);
282 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
283 SocPerfPlugin::GetInstance().HandleRemoteAnimation(invalidData);
284 EXPECT_NE(animationEndData, nullptr);
285 }
286
287 /*
288 * @tc.name: SocPerfPluginTest_API_TEST_010
289 * @tc.desc: test socperfplugin api
290 * @tc.type FUNC
291 * @tc.require: issueI78T3V
292 */
293 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_010, Function | MediumTest | Level0)
294 {
295 const std::shared_ptr<ResData>& dragStartData = std::make_shared<ResData>(ResType::RES_TYPE_DRAG_STATUS_BAR,
296 ResType::StatusBarDragStatus::DRAG_START, nullptr);
297 SocPerfPlugin::GetInstance().HandleDragStatusBar(dragStartData);
298 const std::shared_ptr<ResData>& dragEndData = std::make_shared<ResData>(ResType::RES_TYPE_DRAG_STATUS_BAR,
299 ResType::StatusBarDragStatus::DRAG_END, nullptr);
300 SocPerfPlugin::GetInstance().HandleDragStatusBar(dragEndData);
301 SocPerfPlugin::GetInstance().HandleDragStatusBar(nullptr);
302 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
303 SocPerfPlugin::GetInstance().HandleDragStatusBar(invalidData);
304 EXPECT_NE(dragStartData, nullptr);
305 }
306
307 /*
308 * @tc.name: SocPerfPluginTest_API_TEST_011
309 * @tc.desc: test socperfplugin api
310 * @tc.type FUNC
311 * @tc.require: issueI78T3V
312 */
313 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_011, Function | MediumTest | Level0)
314 {
315 const std::shared_ptr<ResData>& webGestureMoveStartData = std::make_shared<ResData>(
316 ResType::RES_TYPE_WEB_GESTURE_MOVE, ResType::WebGestureMove::WEB_GESTURE_MOVE_START, nullptr);
317 SocPerfPlugin::GetInstance().HandleWebGestureMove(webGestureMoveStartData);
318 const std::shared_ptr<ResData>& webGestureMoveEndData = std::make_shared<ResData>(
319 ResType::RES_TYPE_WEB_GESTURE_MOVE, ResType::WebGestureMove::WEB_GESTURE_MOVE_END, nullptr);
320 SocPerfPlugin::GetInstance().HandleWebGestureMove(webGestureMoveEndData);
321 SocPerfPlugin::GetInstance().HandleWebGestureMove(nullptr);
322 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
323 SocPerfPlugin::GetInstance().HandleWebGestureMove(invalidData);
324 EXPECT_NE(webGestureMoveStartData, nullptr);
325 }
326
327 /*
328 * @tc.name: SocPerfPluginTest_API_TEST_012
329 * @tc.desc: test socperfplugin api
330 * @tc.type FUNC
331 * @tc.require: issueI78T3V
332 */
333 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_012, Function | MediumTest | Level0)
334 {
335 const std::shared_ptr<ResData>& webSlideNormalStartData = std::make_shared<ResData>(
336 ResType::RES_TYPE_WEB_SLIDE_NORMAL, ResType::WebSlideNormal::WEB_SLIDE_NORMAL_START, nullptr);
337 SocPerfPlugin::GetInstance().HandleWebSlideNormal(webSlideNormalStartData);
338 const std::shared_ptr<ResData>& webSlideNormalEndData = std::make_shared<ResData>(
339 ResType::RES_TYPE_WEB_SLIDE_NORMAL, ResType::WebSlideNormal::WEB_SLIDE_NORMAL_END, nullptr);
340 SocPerfPlugin::GetInstance().HandleWebSlideNormal(webSlideNormalEndData);
341 SocPerfPlugin::GetInstance().HandleWebSlideNormal(nullptr);
342 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
343 SocPerfPlugin::GetInstance().HandleWebSlideNormal(invalidData);
344 EXPECT_NE(webSlideNormalStartData, nullptr);
345 }
346
347 /*
348 * @tc.name: SocPerfPluginTest_API_TEST_013
349 * @tc.desc: test socperfplugin api
350 * @tc.type FUNC
351 * @tc.require: issueI78T3V
352 */
353 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_013, Function | MediumTest | Level0)
354 {
355 const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_LOAD_URL, -1, nullptr);
356 SocPerfPlugin::GetInstance().HandleLoadUrl(data);
357 EXPECT_NE(data, nullptr);
358 }
359
360 /*
361 * @tc.name: SocPerfPluginTest_API_TEST_014
362 * @tc.desc: test socperfplugin api
363 * @tc.type FUNC
364 * @tc.require: issueI78T3V
365 */
366 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_014, Function | MediumTest | Level0)
367 {
368 const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_MOUSEWHEEL, -1, nullptr);
369 SocPerfPlugin::GetInstance().HandleMousewheel(data);
370 EXPECT_NE(data, nullptr);
371 }
372
373 /*
374 * @tc.name: SocPerfPluginTest_API_TEST_015
375 * @tc.desc: test socperfplugin api
376 * @tc.type FUNC
377 * @tc.require: issueI78T3V
378 */
379 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_015, Function | MediumTest | Level0)
380 {
381 const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_POP_PAGE, -1, nullptr);
382 SocPerfPlugin::GetInstance().HandlePopPage(data);
383 EXPECT_NE(data, nullptr);
384 }
385
386 /*
387 * @tc.name: SocPerfPluginTest_API_TEST_016
388 * @tc.desc: test socperfplugin api
389 * @tc.type FUNC
390 * @tc.require: issueI78T3V
391 */
392 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_016, Function | MediumTest | Level0)
393 {
394 std::shared_ptr<ResData> invalidValuedata = std::make_shared<ResData>(ResType::RES_TYPE_APP_STATE_CHANGE,
395 ResType::ProcessStatus::PROCESS_READY, nullptr);
396 bool ret = SocPerfPlugin::GetInstance().HandleAppStateChange(invalidValuedata);
397 EXPECT_FALSE(ret);
398
399 nlohmann::json invalidPayload;
400 invalidPayload["extensionType"] = 0;
401 std::shared_ptr<ResData> invalidPayloadTypedata = std::make_shared<ResData>(ResType::RES_TYPE_APP_STATE_CHANGE,
402 ResType::ProcessStatus::PROCESS_CREATED, invalidPayload);
403 ret = SocPerfPlugin::GetInstance().HandleAppStateChange(invalidPayloadTypedata);
404 EXPECT_FALSE(ret);
405
406 nlohmann::json payload;
407 payload["extensionType"] = 2;
408 std::shared_ptr<ResData> data = std::make_shared<ResData>(ResType::RES_TYPE_APP_STATE_CHANGE,
409 ResType::ProcessStatus::PROCESS_CREATED, payload);
410 ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
411 EXPECT_TRUE(ret);
412
413 payload["extensionType"] = 255;
414 data->payload = payload;
415 ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
416 EXPECT_TRUE(ret);
417
418 payload["extensionType"] = 256;
419 data->payload = payload;
420 ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
421 EXPECT_TRUE(ret);
422
423 payload["extensionType"] = 500;
424 data->payload = payload;
425 ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
426 EXPECT_TRUE(ret);
427
428 payload["extensionType"] = 600;
429 data->payload = payload;
430 ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
431 EXPECT_FALSE(ret);
432 }
433
434 /*
435 * @tc.name: SocPerfPluginTest_API_TEST_017
436 * @tc.desc: test socperfplugin api
437 * @tc.type FUNC
438 * @tc.require: issueI78T3V
439 */
440 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_017, Function | MediumTest | Level0)
441 {
442 nlohmann::json payload;
443 payload["deviceMode"] = "test";
444 std::shared_ptr<ResData> normalValuedata = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
445 ResType::DeviceModeStatus::MODE_ENTER, payload);
446 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(normalValuedata);
447 SUCCEED();
448
449 nlohmann::json payload2;
450 payload["test"] = "test";
451 std::shared_ptr<ResData> invalidPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
452 ResType::DeviceModeStatus::MODE_ENTER, payload2);
453 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidPayload);
454 SUCCEED();
455
456 nlohmann::json payload3;
457 payload["test"] = "test";
458 int64_t invalidType = 3;
459 std::shared_ptr<ResData> invalidValue = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
460 invalidType, payload3);
461 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidValue);
462 SUCCEED();
463
464 nlohmann::json payload4;
465 payload["deviceMode"] = "";
466 std::shared_ptr<ResData> emptyPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
467 ResType::DeviceModeStatus::MODE_ENTER, payload4);
468 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(emptyPayload);
469 SUCCEED();
470
471 nlohmann::json payload5;
472 payload["deviceMode"] = "ABCEDFGHABCEDFGHABCEDFGHABCEDFGHABCEDFGHABCEDFGHABCEDFGHABCEDFGHZ";
473 const std::shared_ptr<ResData>& maxLenPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
474 ResType::DeviceModeStatus::MODE_ENTER, payload5);
475 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(maxLenPayload);
476 EXPECT_NE(maxLenPayload, nullptr);
477 }
478
479 /*
480 * @tc.name: SocPerfPluginTest_API_TEST_018
481 * @tc.desc: test socperfplugin api
482 * @tc.type FUNC
483 * @tc.require: issueI78T3V
484 */
485 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_018, Function | MediumTest | Level0)
486 {
487 const std::shared_ptr<ResData>& scbAnimationEndData = std::make_shared<ResData>(
488 SocPerfPlugin::GetInstance().RES_TYPE_SCENE_BOARD_ID,
489 ResType::ShowRemoteAnimationStatus::ANIMATION_END, nullptr);
490 bool ret = SocPerfPlugin::GetInstance().HandleSocperfSceneBoard(scbAnimationEndData);
491 EXPECT_TRUE(ret);
492 const std::shared_ptr<ResData>& scbAnimationBeginData = std::make_shared<ResData>(
493 SocPerfPlugin::GetInstance().RES_TYPE_SCENE_BOARD_ID,
494 ResType::ShowRemoteAnimationStatus::ANIMATION_BEGIN, nullptr);
495 ret = SocPerfPlugin::GetInstance().HandleSocperfSceneBoard(scbAnimationBeginData);
496 EXPECT_TRUE(ret);
497 ret = SocPerfPlugin::GetInstance().HandleSocperfSceneBoard(nullptr);
498 EXPECT_FALSE(ret);
499 }
500
501 #ifdef RESSCHED_RESOURCESCHEDULE_CUST_SOC_PERF_ENABLE
502 /*
503 * @tc.name: SocPerfPluginTest_API_TEST_019
504 * @tc.desc: test socperfplugin api
505 * @tc.type FUNC
506 * @tc.require: issueI78T3V
507 */
508 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_019, Function | MediumTest | Level0)
509 {
510 const std::shared_ptr<ResData>& ancoEvnetData = std::make_shared<ResData>(
511 ResType::RES_TYPE_ANCO_CUST, 1001, nullptr);
512 bool ret = SocPerfPlugin::GetInstance().HandleCustEvent(ancoEvnetData);
513 EXPECT_TRUE(ret);
514 const std::shared_ptr<ResData>& ancoEvnetDataInvalid = std::make_shared<ResData>(
515 ResType::RES_TYPE_ANCO_CUST, -1, nullptr);
516 ret = SocPerfPlugin::GetInstance().HandleCustEvent(ancoEvnetDataInvalid);
517 EXPECT_FALSE(ret);
518 }
519
520 /*
521 * @tc.name: SocPerfPluginTest_API_TEST_020
522 * @tc.desc: test socperfplugin api
523 * @tc.type FUNC
524 * @tc.require: issueI78T3V
525 */
526 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_020, Function | MediumTest | Level0)
527 {
528 const std::shared_ptr<ResData>& socPerfCustEventBeginData = std::make_shared<ResData>(
529 ResType::RES_TYPE_SOCPERF_CUST_EVENT_BEGIN, 1001, nullptr);
530 bool ret = SocPerfPlugin::GetInstance().HandleCustEventBegin(socPerfCustEventBeginData);
531 EXPECT_TRUE(ret);
532 const std::shared_ptr<ResData>& socPerfCustEventBeginDataInvalid = std::make_shared<ResData>(
533 ResType::RES_TYPE_SOCPERF_CUST_EVENT_BEGIN, -1, nullptr);
534 ret = SocPerfPlugin::GetInstance().HandleCustEventBegin(socPerfCustEventBeginDataInvalid);
535 EXPECT_FALSE(ret);
536 }
537
538 /*
539 * @tc.name: SocPerfPluginTest_API_TEST_021
540 * @tc.desc: test socperfplugin api
541 * @tc.type FUNC
542 * @tc.require: issueI78T3V
543 */
544 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_021, Function | MediumTest | Level0)
545 {
546 const std::shared_ptr<ResData>& socPerfCustEventEndData = std::make_shared<ResData>(
547 ResType::RES_TYPE_SOCPERF_CUST_EVENT_END, 1001, nullptr);
548 bool ret = SocPerfPlugin::GetInstance().HandleCustEventEnd(socPerfCustEventEndData);
549 EXPECT_TRUE(ret);
550 const std::shared_ptr<ResData>& socPerfCustEventEndDataInvalid = std::make_shared<ResData>(
551 ResType::RES_TYPE_SOCPERF_CUST_EVENT_END, -1, nullptr);
552 ret = SocPerfPlugin::GetInstance().HandleCustEventEnd(socPerfCustEventEndDataInvalid);
553 EXPECT_FALSE(ret);
554 }
555
556 /*
557 * @tc.name: SocPerfPluginTest_API_TEST_055
558 * @tc.desc: test socperfplugin api
559 * @tc.type FUNC
560 * @tc.require: issueI78T3V
561 */
562 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_055, Function | MediumTest | Level0)
563 {
564 EXPECT_FALSE(SocPerfPlugin::GetInstance().HandleCustAction(nullptr));
565 const std::shared_ptr<ResData>& validData1 = std::make_shared<ResData>(
566 100, -1, nullptr);
567 EXPECT_FALSE(SocPerfPlugin::GetInstance().HandleCustAction(validData1));
568
569 SocPerfPlugin::GetInstance().custGameState_ = true;
570 const std::shared_ptr<ResData>& validData2 = std::make_shared<ResData>(
571 100, 1, nullptr);
572 EXPECT_FALSE(SocPerfPlugin::GetInstance().HandleCustAction(validData2));
573 SocPerfPlugin::GetInstance().custGameState_ = false;
574 EXPECT_TRUE(SocPerfPlugin::GetInstance().HandleCustAction(validData2));
575 }
576 #endif // RESSCHED_RESOURCESCHEDULE_CUST_SOC_PERF_ENABLE
577
578 /*
579 * @tc.name: SocPerfPluginTest_API_TEST_022
580 * @tc.desc: test socperfplugin api
581 * @tc.type FUNC
582 * @tc.require: issueI78T3V
583 */
584 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_022, Function | MediumTest | Level0)
585 {
586 const std::shared_ptr<ResData>& socPerfPowerModeChangedStartData = std::make_shared<ResData>(
587 ResType::RES_TYPE_POWER_MODE_CHANGED, 601, nullptr);
588 bool ret = SocPerfPlugin::GetInstance().HandlePowerModeChanged(socPerfPowerModeChangedStartData);
589 EXPECT_TRUE(ret);
590 const std::shared_ptr<ResData>& socPerfPowerModeChangedEndData = std::make_shared<ResData>(
591 ResType::RES_TYPE_POWER_MODE_CHANGED, 602, nullptr);
592 ret = SocPerfPlugin::GetInstance().HandlePowerModeChanged(socPerfPowerModeChangedEndData);
593 EXPECT_TRUE(ret);
594 }
595
596 /*
597 * @tc.name: SocPerfPluginTest_API_TEST_023
598 * @tc.desc: test socperfplugin api
599 * @tc.type FUNC
600 * @tc.require: issueI78T3V
601 */
602 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_023, Function | MediumTest | Level0)
603 {
604 const std::shared_ptr<ResData>& socPerfBmmMoniterStartData = std::make_shared<ResData>(
605 ResType::RES_TYPE_BMM_MONITER_CHANGE_EVENT, ResType::BmmMoniterStatus::BMM_BACKGROUND, nullptr);
606 bool ret = SocPerfPlugin::GetInstance().HandleBmmMoniterStatus(socPerfBmmMoniterStartData);
607 EXPECT_TRUE(ret);
608 const std::shared_ptr<ResData>& socPerfBmmMoniterEndData = std::make_shared<ResData>(
609 ResType::RES_TYPE_BMM_MONITER_CHANGE_EVENT, ResType::BmmMoniterStatus::BMM_CLOSE, nullptr);
610 ret = SocPerfPlugin::GetInstance().HandleBmmMoniterStatus(socPerfBmmMoniterEndData);
611 EXPECT_TRUE(ret);
612 const std::shared_ptr<ResData>& socPerfBmmMoniterDataInvalid = std::make_shared<ResData>(
613 ResType::RES_TYPE_BMM_MONITER_CHANGE_EVENT, -1, nullptr);
614 ret = SocPerfPlugin::GetInstance().HandleBmmMoniterStatus(socPerfBmmMoniterDataInvalid);
615 EXPECT_FALSE(ret);
616 }
617
618 /*
619 * @tc.name: SocPerfPluginTest_API_TEST_024
620 * @tc.desc: test socperfplugin api
621 * @tc.type FUNC
622 * @tc.require: issueI78T3V
623 */
624 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_024, Function | MediumTest | Level0)
625 {
626 const std::shared_ptr<ResData>& socPerfSceneRotationStartData = std::make_shared<ResData>(
627 ResType::RES_TYPE_SCENE_ROTATION, 0, nullptr);
628 bool ret = SocPerfPlugin::GetInstance().HandleSceneRotation(socPerfSceneRotationStartData);
629 EXPECT_TRUE(ret);
630 const std::shared_ptr<ResData>& socPerfSceneRotationEndData = std::make_shared<ResData>(
631 ResType::RES_TYPE_SCENE_ROTATION, 1, nullptr);
632 ret = SocPerfPlugin::GetInstance().HandleSceneRotation(socPerfSceneRotationEndData);
633 EXPECT_TRUE(ret);
634 }
635
636 /*
637 * @tc.name: SocPerfPluginTest_API_TEST_025
638 * @tc.desc: test socperfplugin api
639 * @tc.type FUNC
640 * @tc.require: issueI78T3V
641 */
642 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_025, Function | MediumTest | Level0)
643 {
644 const std::shared_ptr<ResData>& socPerfAppColdStartData = std::make_shared<ResData>(
645 ResType::RES_TYPE_ONLY_PERF_APP_COLD_START, 0, nullptr);
646 bool ret = SocPerfPlugin::GetInstance().HandleAppColdStartEx(socPerfAppColdStartData);
647 EXPECT_TRUE(ret);
648 const std::shared_ptr<ResData>& socPerfAppColdEndData = std::make_shared<ResData>(
649 ResType::RES_TYPE_ONLY_PERF_APP_COLD_START, 1, nullptr);
650 ret = SocPerfPlugin::GetInstance().HandleAppColdStartEx(socPerfAppColdEndData);
651 EXPECT_TRUE(ret);
652 }
653
654 /*
655 * @tc.name: SocPerfPluginTest_API_TEST_026
656 * @tc.desc: test socperfplugin api
657 * @tc.type FUNC
658 * @tc.require: issueI78T3V
659 */
660 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_026, Function | MediumTest | Level0)
661 {
662 const std::shared_ptr<ResData>& socPerfRgmBootingStartData = std::make_shared<ResData>(
663 SocPerfPlugin::GetInstance().RES_TYPE_RGM_BOOTING_STATUS, 0, nullptr);
664 bool ret = SocPerfPlugin::GetInstance().HandleRgmBootingStatus(socPerfRgmBootingStartData);
665 EXPECT_TRUE(ret);
666 const std::shared_ptr<ResData>& socPerfRgmBootingEndData = std::make_shared<ResData>(
667 SocPerfPlugin::GetInstance().RES_TYPE_RGM_BOOTING_STATUS, -1, nullptr);
668 ret = SocPerfPlugin::GetInstance().HandleRgmBootingStatus(socPerfRgmBootingEndData);
669 EXPECT_TRUE(ret);
670 }
671
672 /*
673 * @tc.name: SocPerfPluginTest_API_TEST_027
674 * @tc.desc: test socperfplugin api
675 * @tc.type FUNC
676 * @tc.require: issueI78T3V
677 */
678 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_027, Function | MediumTest | Level0)
679 {
680 const std::shared_ptr<ResData>& socPerfAccountActivatingData = std::make_shared<ResData>(
681 ResType::RES_TYPE_ACCOUNT_ACTIVATING, ResType::AccountActivatingStatus::ACCOUNT_ACTIVATING_START, nullptr);
682 bool ret = SocPerfPlugin::GetInstance().HandleSocperfAccountActivating(socPerfAccountActivatingData);
683 EXPECT_TRUE(ret);
684 const std::shared_ptr<ResData>& socPerfAccountActivatingInvalid = std::make_shared<ResData>(
685 ResType::RES_TYPE_ACCOUNT_ACTIVATING, -1, nullptr);
686 ret = SocPerfPlugin::GetInstance().HandleSocperfAccountActivating(socPerfAccountActivatingInvalid);
687 EXPECT_TRUE(ret);
688 }
689
690 /*
691 * @tc.name: SocPerfPluginTest_API_TEST_028
692 * @tc.desc: test socperfplugin api
693 * @tc.type FUNC
694 * @tc.require: issueI78T3V
695 */
696 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_028, Function | MediumTest | Level0)
697 {
698 nlohmann::json payload;
699 payload["deviceMode"] = "displayMain";
700 std::shared_ptr<ResData> invalidPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
701 ResType::DeviceModeStatus::MODE_ENTER, payload);
702 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidPayload);
703
704 std::shared_ptr<ResData> normalValuedata = std::make_shared<ResData>(ResType::RES_TYPE_SCREEN_STATUS,
705 ResType::ScreenStatus::SCREEN_ON, nullptr);
706 bool ret = SocPerfPlugin::GetInstance().HandleScreenStatusAnalysis(normalValuedata);
707 EXPECT_TRUE(ret);
708
709 std::shared_ptr<ResData> normalValuedata2 = std::make_shared<ResData>(ResType::RES_TYPE_SCREEN_STATUS,
710 ResType::ScreenStatus::SCREEN_OFF, nullptr);
711 ret = SocPerfPlugin::GetInstance().HandleScreenStatusAnalysis(normalValuedata2);
712 EXPECT_TRUE(ret);
713
714 nlohmann::json payload1;
715 payload1["deviceMode"] = "displayFull";
716 std::shared_ptr<ResData> invalidPayload1 = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
717 ResType::DeviceModeStatus::MODE_ENTER, payload1);
718 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidPayload1);
719
720 std::shared_ptr<ResData> normalValuedata3 = std::make_shared<ResData>(ResType::RES_TYPE_SCREEN_STATUS,
721 ResType::ScreenStatus::SCREEN_ON, nullptr);
722 ret = SocPerfPlugin::GetInstance().HandleScreenStatusAnalysis(normalValuedata3);
723 EXPECT_TRUE(ret);
724
725 std::shared_ptr<ResData> normalValuedata4 = std::make_shared<ResData>(ResType::RES_TYPE_SCREEN_STATUS,
726 ResType::ScreenStatus::SCREEN_OFF, nullptr);
727 ret = SocPerfPlugin::GetInstance().HandleScreenStatusAnalysis(normalValuedata4);
728 EXPECT_TRUE(ret);
729
730 ret = SocPerfPlugin::GetInstance().HandleScreenStatusAnalysis(nullptr);
731 EXPECT_FALSE(ret);
732 }
733
734 /*
735 * @tc.name: SocPerfPluginTest_API_TEST_029
736 * @tc.desc: test socperfplugin api
737 * @tc.type FUNC
738 * @tc.require: issueI78T3V
739 */
740 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_029, Function | MediumTest | Level0)
741 {
742 std::set<std::string> nameSet = {"baidu"};
743 bool ret = SocPerfPlugin::GetInstance().HandleSubValue("", nameSet);
744 EXPECT_FALSE(ret);
745 ret = SocPerfPlugin::GetInstance().HandleSubValue("tencent,alipay", nameSet);
746 EXPECT_TRUE(ret);
747 }
748
749 /*
750 * @tc.name: SocPerfPluginTest_API_TEST_031
751 * @tc.desc: test socperfplugin api
752 * @tc.type FUNC
753 * @tc.require: issueI78T3V
754 */
755 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_031, Function | MediumTest | Level0)
756 {
757 nlohmann::json payload1;
758 payload1["uid"] = "100111";
759 std::shared_ptr<ResData> normalData1 = std::make_shared<ResData>(111, 0, payload1);
760 int32_t appType = -1;
761 bool ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(normalData1, appType, "qq");
762 EXPECT_FALSE(ret);
763
764 appType = 0;
765 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(normalData1, appType, "qq");
766 EXPECT_FALSE(ret);
767
768 appType = 3;
769 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(normalData1, appType, "qq");
770 EXPECT_TRUE(ret);
771
772 nlohmann::json payload2;
773 payload2["uid"] = "-1";
774 std::shared_ptr<ResData> normalData2 = std::make_shared<ResData>(111, 0, payload2);
775 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(normalData2, appType, "qq");
776 EXPECT_FALSE(ret);
777 }
778
779 /*
780 * @tc.name: SocPerfPluginTest_API_TEST_032
781 * @tc.desc: test socperfplugin api
782 * @tc.type FUNC
783 * @tc.require: issueI78T3V
784 */
785 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_032, Function | MediumTest | Level0)
786 {
787 nlohmann::json payload1;
788 payload1["uid"] = "-1";
789 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(111, 0, payload1);
790 bool ret = SocPerfPlugin::GetInstance().UpdateFocusAppType(invalidData1, true);
791 EXPECT_FALSE(ret);
792
793 nlohmann::json payload2;
794 payload2["uid"] = "10011";
795 std::shared_ptr<ResData> validData2 = std::make_shared<ResData>(111, 0, payload2);
796 ret = SocPerfPlugin::GetInstance().UpdateFocusAppType(validData2, false);
797 EXPECT_TRUE(ret);
798
799 payload2["pid"] = "2025";
800 AppKeyMessage appMsg(3, "qq");
801 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10011] = appMsg;
802 ret = SocPerfPlugin::GetInstance().UpdateFocusAppType(validData2, true);
803 EXPECT_TRUE(ret);
804
805 nlohmann::json payload3;
806 payload3["uid"] = "10012";
807 payload3["pid"] = "2025";
808 std::shared_ptr<ResData> validData3 = std::make_shared<ResData>(111, 0, payload3);
809 SocPerfPlugin::GetInstance().reqAppTypeFunc_ = nullptr;
810 ret = SocPerfPlugin::GetInstance().UpdateFocusAppType(validData3, true);
811 EXPECT_FALSE(ret);
812
813 SocPerfPlugin::GetInstance().reqAppTypeFunc_ =
__anon6e6fb7150202(const std::string& bundleName) 814 [](const std::string& bundleName) { return -1; };
815 ret = SocPerfPlugin::GetInstance().UpdateFocusAppType(validData3, true);
816 EXPECT_TRUE(ret);
817 }
818
819 /*
820 * @tc.name: SocPerfPluginTest_API_TEST_033
821 * @tc.desc: test socperfplugin api
822 * @tc.type FUNC
823 * @tc.require: issueI78T3V
824 */
825 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_033, Function | MediumTest | Level0)
826 {
827 SocPerfPlugin::GetInstance().focusAppUids_.clear();
828 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
829 bool ret = SocPerfPlugin::GetInstance().IsFocusAppsAllGame();
830 EXPECT_FALSE(ret);
831
832 AppKeyMessage appMsg1(2, "qq");
833 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10010] = appMsg1;
834 AppKeyMessage appMsg2(3, "alipy");
835 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10011] = appMsg2;
836 AppKeyMessage appMsg3(2, "game");
837 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10012] = appMsg3;
838 SocPerfPlugin::GetInstance().focusAppUids_ = {10010, 10011};
839 ret = SocPerfPlugin::GetInstance().IsFocusAppsAllGame();
840 EXPECT_FALSE(ret);
841
842 SocPerfPlugin::GetInstance().focusAppUids_.insert(10012);
843 SocPerfPlugin::GetInstance().focusAppUids_.erase(10011);
844 ret = SocPerfPlugin::GetInstance().IsFocusAppsAllGame();
845 EXPECT_TRUE(ret);
846 SocPerfPlugin::GetInstance().focusAppUids_.clear();
847 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
848 }
849
850 /*
851 * @tc.name: SocPerfPluginTest_API_TEST_034
852 * @tc.desc: test socperfplugin api
853 * @tc.type FUNC
854 * @tc.require: issueI78T3V
855 */
856 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_034, Function | MediumTest | Level0)
857 {
858 SocPerfPlugin::GetInstance().focusAppUids_.clear();
859 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
860 SocPerfPlugin::GetInstance().focusAppUids_ = {10010};
861 bool ret = SocPerfPlugin::GetInstance().UpdatesFocusAppsType(2);
862 EXPECT_TRUE(ret);
863
864 ret = SocPerfPlugin::GetInstance().UpdatesFocusAppsType(3);
865 EXPECT_FALSE(ret);
866
867 SocPerfPlugin::GetInstance().focusAppUids_.insert(10011);
868 SocPerfPlugin::GetInstance().isFocusAppsGameType_ = false;
869 ret = SocPerfPlugin::GetInstance().UpdatesFocusAppsType(2);
870 EXPECT_FALSE(ret);
871
872 ret = SocPerfPlugin::GetInstance().UpdatesFocusAppsType(3);
873 EXPECT_FALSE(ret);
874
875 SocPerfPlugin::GetInstance().isFocusAppsGameType_ = true;
876 ret = SocPerfPlugin::GetInstance().UpdatesFocusAppsType(2);
877 EXPECT_TRUE(ret);
878
879 ret = SocPerfPlugin::GetInstance().UpdatesFocusAppsType(3);
880 EXPECT_FALSE(ret);
881
882 SocPerfPlugin::GetInstance().focusAppUids_.clear();
883 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
884 }
885
886 /*
887 * @tc.name: SocPerfPluginTest_API_TEST_035
888 * @tc.desc: test socperfplugin api
889 * @tc.type FUNC
890 * @tc.require: issueI78T3V
891 */
892 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_035, Function | MediumTest | Level0)
893 {
894 SocPerfPlugin::GetInstance().socperfGameBoostSwitch_ = false;
895 bool ret = SocPerfPlugin::GetInstance().HandleGameBoost(nullptr);
896 EXPECT_FALSE(ret);
897
898 SocPerfPlugin::GetInstance().socperfGameBoostSwitch_ = true;
899 ret = SocPerfPlugin::GetInstance().HandleGameBoost(nullptr);
900 EXPECT_FALSE(ret);
901
902 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(ResType::RES_TYPE_APP_GAME_BOOST_EVENT,
903 ResType::GameBoostState::GAME_BOOST_LEVEL0, nullptr);
904 ret = SocPerfPlugin::GetInstance().HandleGameBoost(validData1);
905 EXPECT_TRUE(ret);
906
907 std::shared_ptr<ResData> validData2 = std::make_shared<ResData>(ResType::RES_TYPE_APP_GAME_BOOST_EVENT,
908 ResType::GameBoostState::GAME_BOOST_LEVEL1, nullptr);
909 ret = SocPerfPlugin::GetInstance().HandleGameBoost(validData2);
910 EXPECT_TRUE(ret);
911
912 std::shared_ptr<ResData> validData3 = std::make_shared<ResData>(ResType::RES_TYPE_APP_GAME_BOOST_EVENT,
913 ResType::GameBoostState::GAME_BOOST_LEVEL2, nullptr);
914 ret = SocPerfPlugin::GetInstance().HandleGameBoost(validData3);
915 EXPECT_TRUE(ret);
916
917 std::shared_ptr<ResData> validData4 = std::make_shared<ResData>(ResType::RES_TYPE_APP_GAME_BOOST_EVENT,
918 ResType::GameBoostState::GAME_BOOST_LEVEL3, nullptr);
919 ret = SocPerfPlugin::GetInstance().HandleGameBoost(validData4);
920 EXPECT_TRUE(ret);
921 }
922
923 /*
924 * @tc.name: SocPerfPluginTest_API_TEST_036
925 * @tc.desc: test socperfplugin api
926 * @tc.type FUNC
927 * @tc.require: issueI78T3V
928 */
929 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_036, Function | MediumTest | Level0)
930 {
931 SocPerfPlugin::GetInstance().pidToAppTypeMap_.clear();
932 nlohmann::json payload1;
933 payload1["clientPid"] = "-1";
934 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(-1, -1, payload1);
935 bool ret = SocPerfPlugin::GetInstance().IsGameEvent(invalidData1);
936 EXPECT_FALSE(ret);
937
938 payload1["clientPid"] = "2025";
939 SocPerfPlugin::GetInstance().pidToAppTypeMap_[2025] = 3;
940 std::shared_ptr<ResData> invalidData2 = std::make_shared<ResData>(-1, -1, payload1);
941 ret = SocPerfPlugin::GetInstance().IsGameEvent(invalidData2);
942 EXPECT_FALSE(ret);
943
944 SocPerfPlugin::GetInstance().pidToAppTypeMap_[2025] = 2;
945 std::shared_ptr<ResData> validData = std::make_shared<ResData>(-1, -1, payload1);
946 ret = SocPerfPlugin::GetInstance().IsGameEvent(validData);
947 EXPECT_TRUE(ret);
948 }
949
950 /*
951 * @tc.name: SocPerfPluginTest_API_TEST_037
952 * @tc.desc: test socperfplugin api
953 * @tc.type FUNC
954 * @tc.require: issueI78T3V
955 */
956 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_037, Function | MediumTest | Level0)
957 {
958 bool ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(nullptr);
959 EXPECT_FALSE(ret);
960
961 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(-1, -1, nullptr);
962 ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(invalidData1);
963 EXPECT_FALSE(ret);
964
965 std::shared_ptr<ResData> invalidData2 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
966 ResType::AppInstallStatus::APP_UNINSTALL, nullptr);
967 ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(invalidData2);
968 EXPECT_FALSE(ret);
969
970 nlohmann::json payload1;
971 std::shared_ptr<ResData> invalidData3 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
972 ResType::AppInstallStatus::APP_UNINSTALL, payload1);
973 ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(invalidData3);
974 EXPECT_FALSE(ret);
975
976 payload1["uid"] = "str";
977 ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(invalidData3);
978 EXPECT_FALSE(ret);
979
980 nlohmann::json payload2;
981 payload2["uid"] = -1;
982 std::shared_ptr<ResData> invalidData4 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
983 ResType::AppInstallStatus::APP_UNINSTALL, payload2);
984 ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(invalidData4);
985 EXPECT_FALSE(ret);
986
987 nlohmann::json payload3;
988 payload3["uid"] = 10010;
989 std::shared_ptr<ResData> invalidData5 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
990 ResType::AppInstallStatus::APP_UNINSTALL, payload3);
991 ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(invalidData5);
992 EXPECT_TRUE(ret);
993 }
994
995 /*
996 * @tc.name: SocPerfPluginTest_API_TEST_038
997 * @tc.desc: test socperfplugin api
998 * @tc.type FUNC
999 * @tc.require: issueI78T3V
1000 */
1001 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_038, Function | MediumTest | Level0)
1002 {
1003 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(-1, -1, nullptr);
1004 bool ret = SocPerfPlugin::GetInstance().GetUidByData(invalidData1) == -1;
1005 EXPECT_TRUE(ret);
1006
1007 nlohmann::json payload1;
1008 std::shared_ptr<ResData> invalidData2 = std::make_shared<ResData>(-1, -1, payload1);
1009 ret = SocPerfPlugin::GetInstance().GetUidByData(invalidData2) == -1;
1010 EXPECT_TRUE(ret);
1011
1012 payload1["uid"] = 10010;
1013 std::shared_ptr<ResData> invalidData3 = std::make_shared<ResData>(-1, -1, payload1);
1014 ret = SocPerfPlugin::GetInstance().GetUidByData(invalidData3) == -1;
1015 EXPECT_TRUE(ret);
1016
1017 nlohmann::json payload2;
1018 payload2["uid"] = "10010";
1019 std::shared_ptr<ResData> invalidData4 = std::make_shared<ResData>(-1, -1, payload2);
1020 ret = SocPerfPlugin::GetInstance().GetUidByData(invalidData4) == 10010;
1021 EXPECT_TRUE(ret);
1022 }
1023
1024 /*
1025 * @tc.name: SocPerfPluginTest_API_TEST_039
1026 * @tc.desc: test socperfplugin api
1027 * @tc.type FUNC
1028 * @tc.require: issueI78T3V
1029 */
1030 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_039, Function | MediumTest | Level0)
1031 {
1032 SocPerfPlugin::GetInstance().appNameUseCamera_.clear();
1033 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
1034 SocPerfPlugin::GetInstance().focusAppUids_.clear();
1035 bool ret = SocPerfPlugin::GetInstance().HandleCameraStateChange(nullptr);
1036 EXPECT_FALSE(ret);
1037
1038 SocPerfPlugin::GetInstance().appNameUseCamera_.insert("qqlive");
1039 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
1040 ResType::CameraState::CAMERA_DISCONNECT, nullptr);
1041 ret = SocPerfPlugin::GetInstance().HandleCameraStateChange(validData1);
1042 EXPECT_TRUE(ret);
1043
1044 std::shared_ptr<ResData> validData2 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
1045 ResType::CameraState::CAMERA_CONNECT, nullptr);
1046 ret = SocPerfPlugin::GetInstance().HandleCameraStateChange(validData2);
1047 EXPECT_TRUE(ret);
1048
1049 SocPerfPlugin::GetInstance().focusAppUids_ = {10010, 10011};
1050 AppKeyMessage appMsg(2, "qqlive");
1051 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10010] = appMsg;
1052 std::shared_ptr<ResData> validData3 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
1053 ResType::CameraState::CAMERA_CONNECT, nullptr);
1054 ret = SocPerfPlugin::GetInstance().HandleCameraStateChange(validData3);
1055 EXPECT_TRUE(ret);
1056 SocPerfPlugin::GetInstance().appNameUseCamera_.clear();
1057 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
1058 SocPerfPlugin::GetInstance().focusAppUids_.clear();
1059 }
1060
1061 /*
1062 * @tc.name: SocPerfPluginTest_API_TEST_040
1063 * @tc.desc: test socperfplugin api
1064 * @tc.type FUNC
1065 * @tc.require: issueI78T3V
1066 */
1067 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_040, Function | MediumTest | Level0)
1068 {
1069 SocPerfPlugin::GetInstance().appNameUseCamera_.clear();
1070 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
1071 SocPerfPlugin::GetInstance().focusAppUids_.clear();
1072 bool ret = SocPerfPlugin::GetInstance().IsAllowBoostScene();
1073 EXPECT_FALSE(ret);
1074
1075 SocPerfPlugin::GetInstance().appNameUseCamera_.insert("qqlive");
1076 SocPerfPlugin::GetInstance().focusAppUids_ = {10010, 10011};
1077 AppKeyMessage appMsg(2, "qqlive");
1078 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10010] = appMsg;
1079 ret = SocPerfPlugin::GetInstance().IsAllowBoostScene();
1080 EXPECT_TRUE(ret);
1081 SocPerfPlugin::GetInstance().appNameUseCamera_.clear();
1082 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
1083 SocPerfPlugin::GetInstance().focusAppUids_.clear();
1084 }
1085
1086 /*
1087 * @tc.name: SocPerfPluginTest_API_TEST_041
1088 * @tc.desc: test socperfplugin api
1089 * @tc.type FUNC
1090 * @tc.require: issueI78T3V
1091 */
1092 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_041, Function | MediumTest | Level0)
1093 {
1094 bool ret = SocPerfPlugin::GetInstance().HandleProcessStateChange(nullptr);
1095 EXPECT_TRUE(ret);
1096
1097 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(ResType::RES_TYPE_PROCESS_STATE_CHANGE,
1098 ResType::ProcessStatus::PROCESS_DIED, nullptr);
1099 ret = SocPerfPlugin::GetInstance().HandleProcessStateChange(validData1);
1100 EXPECT_TRUE(ret);
1101 }
1102
1103 /*
1104 * @tc.name: SocPerfPluginTest_API_TEST_042
1105 * @tc.desc: test socperfplugin api
1106 * @tc.type FUNC
1107 * @tc.require: issueI78T3V
1108 */
1109 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_042, Function | MediumTest | Level0)
1110 {
1111 nlohmann::json payload1;
1112 payload1["pid"] = "-1";
1113 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(-1, -1, payload1);
1114 bool ret = SocPerfPlugin::GetInstance().HandleProcessStateChange(validData1);
1115 EXPECT_TRUE(ret);
1116
1117 payload1["pid"] = "2025";
1118 std::shared_ptr<ResData> validData2 = std::make_shared<ResData>(-1, -1, payload1);
1119 ret = SocPerfPlugin::GetInstance().HandleProcessStateChange(validData2);
1120 EXPECT_TRUE(ret);
1121 }
1122
1123 /*
1124 * @tc.name: SocPerfPluginTest_API_TEST_043
1125 * @tc.desc: test socperfplugin api
1126 * @tc.type FUNC
1127 * @tc.require: issueI78T3V
1128 */
1129 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_043, Function | MediumTest | Level0)
1130 {
1131 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(-1, -1, nullptr);
1132 bool ret = SocPerfPlugin::GetInstance().GetPidByData(invalidData1, "notKey") == -1;
1133 EXPECT_TRUE(ret);
1134
1135 nlohmann::json payload1;
1136 payload1["pid"] = "2025";
1137 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(-1, -1, payload1);
1138 ret = SocPerfPlugin::GetInstance().GetPidByData(validData1, "notPid") == -1;
1139 EXPECT_TRUE(ret);
1140
1141 ret = SocPerfPlugin::GetInstance().GetPidByData(validData1, "pid") == 2025;
1142 EXPECT_TRUE(ret);
1143
1144 nlohmann::json payload2;
1145 payload2["pid"] = 2025;
1146 std::shared_ptr<ResData> validData2 =
1147 std::make_shared<ResData>(-1, -1, payload2);
1148 ret = SocPerfPlugin::GetInstance().GetPidByData(validData2, "pid") == -1;
1149 EXPECT_TRUE(ret);
1150 }
1151
1152 /*
1153 * @tc.name: SocPerfPluginTest_API_TEST_044
1154 * @tc.desc: test socperfplugin api
1155 * @tc.type FUNC
1156 * @tc.require: issueI78T3V
1157 */
1158 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_044, Function | MediumTest | Level0)
1159 {
1160 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
1161 nlohmann::json payload1;
1162 payload1["uid"] = "-1";
1163 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(-1, -1, payload1);
1164 bool ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(invalidData1);
1165 EXPECT_FALSE(ret);
1166
1167 nlohmann::json payload2;
1168 payload2["uid"] = "10010";
1169 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(-1, -1, payload2);
1170 AppKeyMessage appMsg(2, "qq");
1171 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10010] = appMsg;
1172 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(validData1);
1173 EXPECT_TRUE(ret);
1174
1175 nlohmann::json payload3;
1176 payload3["uid"] = "10011";
1177 std::shared_ptr<ResData> invalidData2 = std::make_shared<ResData>(-1, -1, payload3);
1178 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(invalidData2);
1179 EXPECT_FALSE(ret);
1180
1181 payload3["bundleName"] = "wechat";
1182 std::shared_ptr<ResData> validData2 = std::make_shared<ResData>(-1, -1, payload3);
1183 SocPerfPlugin::GetInstance().reqAppTypeFunc_ = nullptr;
1184 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(validData2);
1185 EXPECT_FALSE(ret);
1186
__anon6e6fb7150302(const std::string& bundleName) 1187 SocPerfPlugin::GetInstance().reqAppTypeFunc_ = [](const std::string& bundleName) { return -1; };
1188 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(validData2);
1189 EXPECT_TRUE(ret);
1190 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
1191 }
1192
1193 /*
1194 * @tc.name: SocPerfPluginTest_API_TEST_045
1195 * @tc.desc: test socperfplugin api
1196 * @tc.type FUNC
1197 * @tc.require: issueI78T3V
1198 */
1199 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_045, Function | MediumTest | Level0)
1200 {
1201 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(-1, -1, nullptr);
1202 bool ret = SocPerfPlugin::GetInstance().HandleMoveEventBoost(invalidData1, true);
1203 EXPECT_FALSE(ret);
1204
1205 nlohmann::json payload1;
1206 payload1["bundleName"] = 19000;
1207 std::shared_ptr<ResData> invalidData2 = std::make_shared<ResData>(-1, -1, payload1);
1208 ret = SocPerfPlugin::GetInstance().HandleMoveEventBoost(invalidData2, true);
1209 EXPECT_FALSE(ret);
1210
1211 nlohmann::json payload2;
1212 payload2["bundleName"] = "appName";
1213 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(-1, -1, payload2);
1214 ret = SocPerfPlugin::GetInstance().HandleMoveEventBoost(validData1, true);
1215 EXPECT_TRUE(ret);
1216
1217 SocPerfPlugin::GetInstance().appNameMoveEvent_.insert("appName");
1218 ret = SocPerfPlugin::GetInstance().HandleMoveEventBoost(validData1, false);
1219 EXPECT_TRUE(ret);
1220 }
1221
1222 /*
1223 * @tc.name: SocPerfPluginTest_API_TEST_046
1224 * @tc.desc: test socperfplugin api
1225 * @tc.type FUNC
1226 * @tc.require: issueI78T3V
1227 */
1228 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_046, Function | MediumTest | Level0)
1229 {
1230 SocPerfPlugin::GetInstance().HandleWebSildeScroll(nullptr);
1231 const std::shared_ptr<ResData>& dragStartData = std::make_shared<ResData>(ResType::RES_TYPE_WEB_SLIDE_SCROLL,
1232 ResType::WebDragResizeStatus::WEB_DRAG_START, nullptr);
1233 SocPerfPlugin::GetInstance().HandleWebSildeScroll(dragStartData);
1234 const std::shared_ptr<ResData>& dragEndData = std::make_shared<ResData>(ResType::RES_TYPE_WEB_SLIDE_SCROLL,
1235 ResType::WebDragResizeStatus::WEB_DRAG_END, nullptr);
1236 SocPerfPlugin::GetInstance().HandleWebSildeScroll(dragEndData);
1237 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
1238 SocPerfPlugin::GetInstance().HandleWebSildeScroll(invalidData);
1239 EXPECT_NE(dragStartData, nullptr);
1240 }
1241
1242 /*
1243 * @tc.name: SocPerfPluginTest_API_TEST_047
1244 * @tc.desc: test socperfplugin api
1245 * @tc.type FUNC
1246 * @tc.require: issueI78T3V
1247 */
1248 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_047, Function | MediumTest | Level0)
1249 {
1250 SocPerfPlugin::GetInstance().HandleBatteryStatusChange(nullptr);
1251 std::shared_ptr<ResData> invalidData;
1252 bool rc = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(invalidData);
1253 EXPECT_EQ(rc, false);
1254
1255 invalidData = std::make_shared<ResData>(
1256 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 100, nullptr);
1257 rc = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(invalidData);
1258 EXPECT_EQ(rc, false);
1259
1260 struct Frequencies frequencies;
1261 SocPerfPlugin::GetInstance().socperfBatteryConfig_[90] = frequencies;
1262 rc = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(invalidData);
1263 EXPECT_EQ(rc, false);
1264
1265 nlohmann::json payload1;
1266 payload1["chargeState"] = "num";
1267 const std::shared_ptr<ResData>& invalidData2 = std::make_shared<ResData>(
1268 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 50, payload1);
1269 rc = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(invalidData2);
1270 EXPECT_EQ(rc, false);
1271
1272 nlohmann::json payload2;
1273 payload2["chargeState"] = 1;
1274 const std::shared_ptr<ResData>& validData1 = std::make_shared<ResData>(
1275 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 50, payload2);
1276 bool ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(validData1);
1277 EXPECT_TRUE(ret);
1278
1279 nlohmann::json payload3;
1280 payload3["chargeState"] = 2;
1281 const std::shared_ptr<ResData>& validData2 = std::make_shared<ResData>(
1282 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 50, payload3);
1283 ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(validData2);
1284 EXPECT_TRUE(ret);
1285 }
1286
1287 /*
1288 * @tc.name: SocPerfPluginTest_API_TEST_048
1289 * @tc.desc: test socperfplugin api
1290 * @tc.type FUNC
1291 * @tc.require: issueI78T3V
1292 */
1293 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_048, Function | MediumTest | Level0)
1294 {
1295 const std::string& subValue = "";
1296 SocPerfPlugin::GetInstance().AddKeyAppType(subValue);
1297 const std::string& subValue1 = "test";
1298 SocPerfPlugin::GetInstance().AddKeyAppType(subValue1);
1299 const std::string& keyAppName = "";
1300 SocPerfPlugin::GetInstance().AddKeyAppName(keyAppName);
1301 const std::string& keyAppName1 = "name";
1302 SocPerfPlugin::GetInstance().AddKeyAppName(keyAppName1);
1303 SocPerfPlugin::GetInstance().StringToSet("1,2,3,4", ',');
1304 SocPerfPlugin::GetInstance().HandleScreenOff();
1305 SocPerfPlugin::GetInstance().HandleWebDragResize(nullptr);
1306 const std::shared_ptr<ResData>& validData3 = std::make_shared<ResData>(
1307 ResType::RES_TYPE_WEB_DRAG_RESIZE, 0, nullptr);
1308 SocPerfPlugin::GetInstance().HandleWebDragResize(validData3);
1309 const std::shared_ptr<ResData>& validData4 = std::make_shared<ResData>(
1310 ResType::RES_TYPE_WEB_DRAG_RESIZE, 1, nullptr);
1311 SocPerfPlugin::GetInstance().HandleWebDragResize(validData4);
1312 EXPECT_FALSE(SocPerfPlugin::GetInstance().HandleRecentBuild(nullptr));
1313 const std::shared_ptr<ResData>& validData1 = std::make_shared<ResData>(
1314 ResType::RES_TYPE_RECENT_BUILD, 0, nullptr);
1315 EXPECT_TRUE(SocPerfPlugin::GetInstance().HandleRecentBuild(validData1));
1316 const std::shared_ptr<ResData>& validData2 = std::make_shared<ResData>(
1317 ResType::RES_TYPE_RECENT_BUILD, 1, nullptr);
1318 EXPECT_TRUE(SocPerfPlugin::GetInstance().HandleRecentBuild(validData2));
1319 }
1320
1321 /*
1322 * @tc.name: SocPerfPluginTest_API_TEST_049
1323 * @tc.desc: test socperfplugin api
1324 * @tc.type FUNC
1325 * @tc.require: issueI78T3V
1326 */
1327 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_049, Function | MediumTest | Level0)
1328 {
1329 SocPerfPlugin::GetInstance().HandleBatterySubValue(97, 1001, 692000);
1330 SocPerfPlugin::GetInstance().HandleBatterySubValue(97, 1003, 1152000);
1331 SocPerfPlugin::GetInstance().HandleBatterySubValue(97, 1005, 1997000);
1332 SocPerfPlugin::GetInstance().HandleBatterySubValue(93, 1001, 418000);
1333 SocPerfPlugin::GetInstance().HandleBatterySubValue(93, 1003, 749000);
1334 SocPerfPlugin::GetInstance().HandleBatterySubValue(93, 1005, 1210000);
1335 SocPerfPlugin::GetInstance().HandleBatterySubValue(95, 1001, 418000);
1336 SocPerfPlugin::GetInstance().HandleBatterySubValue(95, 1003, 1152000);
1337 SocPerfPlugin::GetInstance().HandleBatterySubValue(95, 1005, 1210000);
1338
1339 nlohmann::json payload1;
1340 payload1["chargeState"] = 2;
1341 const std::shared_ptr<ResData>& validData1 = std::make_shared<ResData>(
1342 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 98, payload1);
1343 bool ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(validData1);
1344 EXPECT_TRUE(ret);
1345 const std::shared_ptr<ResData>& validData2 = std::make_shared<ResData>(
1346 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 97, payload1);
1347 ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(validData2);
1348 EXPECT_TRUE(ret);
1349 const std::shared_ptr<ResData>& validData3 = std::make_shared<ResData>(
1350 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 96, payload1);
1351 ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(validData3);
1352 EXPECT_TRUE(ret);
1353 const std::shared_ptr<ResData>& validData4 = std::make_shared<ResData>(
1354 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 95, payload1);
1355 ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(validData4);
1356 EXPECT_TRUE(ret);
1357 const std::shared_ptr<ResData>& validData5 = std::make_shared<ResData>(
1358 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 94, payload1);
1359 ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(validData5);
1360 EXPECT_TRUE(ret);
1361 const std::shared_ptr<ResData>& validData51 = std::make_shared<ResData>(
1362 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 93, payload1);
1363 ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(validData51);
1364 EXPECT_TRUE(ret);
1365 const std::shared_ptr<ResData>& validData6 = std::make_shared<ResData>(
1366 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 92, payload1);
1367 ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(validData6);
1368 EXPECT_TRUE(ret);
1369 const std::shared_ptr<ResData>& validData7 = std::make_shared<ResData>(
1370 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 100, payload1);
1371 ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(validData7);
1372 EXPECT_TRUE(ret);
1373 }
1374
1375 /*
1376 * @tc.name: SocPerfPluginTest_API_TEST_050
1377 * @tc.desc: test socperfplugin api
1378 * @tc.type FUNC
1379 * @tc.require: issueI78T3V
1380 */
1381 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_050, Function | MediumTest | Level0)
1382 {
1383 SocPerfPlugin::GetInstance().HandleBatterySubValue(97, 1001, 692000);
1384 SocPerfPlugin::GetInstance().HandleBatterySubValue(97, 1003, 1152000);
1385 SocPerfPlugin::GetInstance().HandleBatterySubValue(97, 1005, 1997000);
1386 SocPerfPlugin::GetInstance().HandleBatterySubValue(93, 1001, 418000);
1387 SocPerfPlugin::GetInstance().HandleBatterySubValue(93, 1003, 749000);
1388 SocPerfPlugin::GetInstance().HandleBatterySubValue(93, 1005, 1210000);
1389 SocPerfPlugin::GetInstance().HandleBatterySubValue(95, 1001, 418000);
1390 SocPerfPlugin::GetInstance().HandleBatterySubValue(95, 1003, 1152000);
1391 SocPerfPlugin::GetInstance().HandleBatterySubValue(95, 1005, 1210000);
1392 nlohmann::json payload1;
1393 payload1["chargeState"] = 1;
1394 const std::shared_ptr<ResData>& validData1 = std::make_shared<ResData>(
1395 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 90, payload1);
1396 bool ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(validData1);
1397 EXPECT_TRUE(ret);
1398
1399 nlohmann::json payload2;
1400 payload2["chargeState"] = 3;
1401 const std::shared_ptr<ResData>& validData2 = std::make_shared<ResData>(
1402 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 90, payload2);
1403 ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(validData2);
1404 EXPECT_TRUE(ret);
1405
1406 nlohmann::json payload3;
1407 payload3["notChargeState"] = 3;
1408 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(
1409 ResType::RES_TYPE_REPORT_BATTERY_STATUS_CHANGE, 90, payload3);
1410 ret = SocPerfPlugin::GetInstance().HandleBatteryStatusChange(invalidData);
1411 EXPECT_FALSE(ret);
1412 }
1413
1414 /*
1415 * @tc.name: SocPerfPluginTest_API_TEST_051
1416 * @tc.desc: test socperfplugin api
1417 * @tc.type FUNC
1418 * @tc.require: issueI78T3V
1419 */
1420 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_051, Function | MediumTest | Level0)
1421 {
1422 EXPECT_FALSE(SocPerfPlugin::GetInstance().HandleGameStateChange(nullptr));
1423 const std::shared_ptr<ResData>& invalidData1 = std::make_shared<ResData>(
1424 ResType::RES_TYPE_REPORT_GAME_STATE_CHANGE, 90, nullptr);
1425 EXPECT_FALSE(SocPerfPlugin::GetInstance().HandleGameStateChange(invalidData1));
1426 nlohmann::json payload1;
1427 payload1["uuu"] = 3;
1428 const std::shared_ptr<ResData>& invalidData2 = std::make_shared<ResData>(
1429 ResType::RES_TYPE_REPORT_GAME_STATE_CHANGE, 1, payload1);
1430 EXPECT_FALSE(SocPerfPlugin::GetInstance().HandleGameStateChange(invalidData2));
1431 nlohmann::json payload2;
1432 payload2["uid"] = "er";
1433 const std::shared_ptr<ResData>& invalidData3 = std::make_shared<ResData>(
1434 ResType::RES_TYPE_REPORT_GAME_STATE_CHANGE, 1, payload2);
1435 EXPECT_FALSE(SocPerfPlugin::GetInstance().HandleGameStateChange(invalidData3));
1436 nlohmann::json payload3;
1437 payload3["uid"] = 123;
1438 const std::shared_ptr<ResData>& invalidData4 = std::make_shared<ResData>(
1439 ResType::RES_TYPE_REPORT_GAME_STATE_CHANGE, 1, payload3);
1440 EXPECT_FALSE(SocPerfPlugin::GetInstance().HandleGameStateChange(invalidData4));
1441
1442 payload3["env"] = "ert";
1443 const std::shared_ptr<ResData>& invalidData5 = std::make_shared<ResData>(
1444 ResType::RES_TYPE_REPORT_GAME_STATE_CHANGE, 1, payload3);
1445 EXPECT_FALSE(SocPerfPlugin::GetInstance().HandleGameStateChange(invalidData5));
1446
1447 nlohmann::json payload4;
1448 payload4["uid"] = 123;
1449 payload4["env"] = 1;
1450 const std::shared_ptr<ResData>& validData1 = std::make_shared<ResData>(
1451 ResType::RES_TYPE_REPORT_GAME_STATE_CHANGE, 4, payload4);
1452 EXPECT_TRUE(SocPerfPlugin::GetInstance().HandleGameStateChange(validData1));
1453 const std::shared_ptr<ResData>& validData2 = std::make_shared<ResData>(
1454 ResType::RES_TYPE_REPORT_GAME_STATE_CHANGE, 5, payload4);
1455 EXPECT_TRUE(SocPerfPlugin::GetInstance().HandleGameStateChange(validData2));
1456
1457 nlohmann::json payload5;
1458 payload5["uid"] = 123;
1459 payload5["env"] = 0;
1460 const std::shared_ptr<ResData>& validData3 = std::make_shared<ResData>(
1461 ResType::RES_TYPE_REPORT_GAME_STATE_CHANGE, 4, payload5);
1462 EXPECT_TRUE(SocPerfPlugin::GetInstance().HandleGameStateChange(validData3));
1463 }
1464
1465 /*
1466 * @tc.name: SocPerfPluginTest_API_TEST_052
1467 * @tc.desc: test socperfplugin api
1468 * @tc.type FUNC
1469 * @tc.require: issueI78T3V
1470 */
1471 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_052, Function | MediumTest | Level0)
1472 {
1473 EXPECT_FALSE(SocPerfPlugin::GetInstance().HandleSceenModeBoost(""));
1474 SocPerfPlugin::GetInstance().deviceMode_ = "displayFull";
1475 SocPerfPlugin::GetInstance().screenStatus_ = 1;
1476 SocPerfPlugin::GetInstance().HandleScreenOn();
1477 EXPECT_TRUE(SocPerfPlugin::GetInstance().HandleSceenModeBoost("display"));
1478 SocPerfPlugin::GetInstance().deviceMode_ = "displayMain";
1479 SocPerfPlugin::GetInstance().HandleScreenOn();
1480 EXPECT_TRUE(SocPerfPlugin::GetInstance().HandleSceenModeBoost("display"));
1481 }
1482
1483 /*
1484 * @tc.name: SocPerfPluginTest_API_TEST_053
1485 * @tc.desc: test socperfplugin api
1486 * @tc.type FUNC
1487 * @tc.require: issueI78T3V
1488 */
1489 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_053, Function | MediumTest | Level0)
1490 {
1491 nlohmann::json payload1;
1492 payload1["deviceModeType"] = 1;
1493 const std::shared_ptr<ResData>& invalidData1 = std::make_shared<ResData>(
1494 ResType::RES_TYPE_DEVICE_MODE_STATUS, 0, payload1);
1495 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidData1);
1496 nlohmann::json payload2;
1497 payload2["deviceModeType"] = "display";
1498 const std::shared_ptr<ResData>& invalidData2 = std::make_shared<ResData>(
1499 ResType::RES_TYPE_DEVICE_MODE_STATUS, 0, payload2);
1500 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidData2);
1501
1502 nlohmann::json payload3;
1503 payload3["deviceModeType"] = "display";
1504 payload3["deviceMode"] = 123;
1505 const std::shared_ptr<ResData>& invalidData3 = std::make_shared<ResData>(
1506 ResType::RES_TYPE_DEVICE_MODE_STATUS, 0, payload3);
1507 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidData3);
1508
1509 nlohmann::json payload4;
1510 payload4["deviceModeType"] = "display";
1511 payload4["deviceMode"] = "displayMain";
1512 const std::shared_ptr<ResData>& validData1 = std::make_shared<ResData>(
1513 ResType::RES_TYPE_DEVICE_MODE_STATUS, 0, payload4);
1514 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(validData1);
1515 EXPECT_NE(validData1, nullptr);
1516 }
1517
1518 /*
1519 * @tc.name: SocPerfPluginTest_API_TEST_054
1520 * @tc.desc: test socperfplugin api
1521 * @tc.type FUNC
1522 * @tc.require: issueI78T3V
1523 */
1524 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_054, Function | MediumTest | Level0)
1525 {
1526 const std::shared_ptr<ResData>& invalidData1 = std::make_shared<ResData>(
1527 ResType::RES_TYPE_KEY_EVENT, 0, nullptr);
1528 SocPerfPlugin::GetInstance().socperfGameBoostSwitch_ = false;
1529 SocPerfPlugin::GetInstance().HandleEventKey(invalidData1);
1530 SocPerfPlugin::GetInstance().socperfGameBoostSwitch_ = true;
1531 SocPerfPlugin::GetInstance().isFocusAppsGameType_ = false;
1532 SocPerfPlugin::GetInstance().HandleEventKey(invalidData1);
1533 SocPerfPlugin::GetInstance().isFocusAppsGameType_ = true;
1534 const std::shared_ptr<ResData>& validData1 = std::make_shared<ResData>(
1535 ResType::RES_TYPE_KEY_EVENT, 0, nullptr);
1536 SocPerfPlugin::GetInstance().HandleEventKey(validData1);
1537 const std::shared_ptr<ResData>& validData2 = std::make_shared<ResData>(
1538 ResType::RES_TYPE_KEY_EVENT, 1, nullptr);
1539 SocPerfPlugin::GetInstance().HandleEventKey(validData2);
1540 EXPECT_NE(validData2, nullptr);
1541 }
1542
1543 /*
1544 * @tc.name: SocPerfPluginTest_API_TEST_056
1545 * @tc.desc: test socperfplugin api
1546 * @tc.type FUNC
1547 * @tc.require: issueICBQWP
1548 */
1549 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_056, Function | MediumTest | Level0)
1550 {
1551 std::shared_ptr<ResData> invalidData;
1552 bool rc = SocPerfPlugin::GetInstance().HandleSchedModeChange(invalidData);
1553 EXPECT_EQ(rc, false);
1554 invalidData = std::make_shared<ResData>(
1555 ResType::RES_TYPE_SCHED_MODE_CHANGE, 1, nullptr);
1556 rc = SocPerfPlugin::GetInstance().HandleSchedModeChange(invalidData);
1557 EXPECT_EQ(rc, false);
1558 nlohmann::json payload1;
1559 payload1["invalidKey"] = "invalidKey";
1560 invalidData = std::make_shared<ResData>(
1561 ResType::RES_TYPE_SCHED_MODE_CHANGE, 1, payload1);
1562 rc = SocPerfPlugin::GetInstance().HandleSchedModeChange(invalidData);
1563 EXPECT_EQ(rc, false);
1564 payload1["schedMode"] = "perfMode";
1565
1566 std::shared_ptr<ResData> validData = std::make_shared<ResData>(
1567 ResType::RES_TYPE_SCHED_MODE_CHANGE, 1, payload1);
1568 rc = SocPerfPlugin::GetInstance().HandleSchedModeChange(validData);
1569 EXPECT_EQ(rc, true);
1570 }
1571
1572 /*
1573 * @tc.name: SocPerfPluginTest_API_TEST_057
1574 * @tc.desc: test socperfplugin api
1575 * @tc.type FUNC
1576 * @tc.require:
1577 */
1578 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_057, Function | MediumTest | Level0)
1579 {
1580 bool ret = SocPerfPlugin::GetInstance().HandleRssCloudConfigUpdate(nullptr);
1581 EXPECT_EQ(ret, false);
1582 nlohmann::json payload = nlohmann::json::parse(R"({
1583 "params" : {
1584 "SOCPERF": {
1585 "specialExtension": {
1586 "itemList": [
1587 {
1588 "itemProperties": {
1589 "key": "specialExtension"
1590 },
1591 "subItemList": [
1592 {
1593 "name": "info",
1594 "value": "0",
1595 "properties": {
1596 "bundleName" : "1",
1597 "callerBundleName" : ""
1598 }
1599 }
1600 ]
1601 }
1602 ]
1603 }
1604 }
1605 }
1606 })");
1607 const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_RSS_CLOUD_CONFIG_UPDATE,
1608 0, payload);
1609 ret = SocPerfPlugin::GetInstance().HandleRssCloudConfigUpdate(data);
1610 EXPECT_EQ(ret, true);
1611 }
1612
1613 /*
1614 * @tc.name: SocPerfPluginTest_API_TEST_058
1615 * @tc.desc: test socperfplugin api
1616 * @tc.type FUNC
1617 * @tc.require:
1618 */
1619 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_058, Function | MediumTest | Level0)
1620 {
1621 bool ret = SocPerfPlugin::GetInstance().HandleRssCloudConfigUpdate(nullptr);
1622 EXPECT_EQ(ret, false);
1623 nlohmann::json payload = nlohmann::json::parse(R"({
1624 "params" : {
1625 "SOCPERF": {
1626 "weakInterAction": {
1627 "itemList": [
1628 {
1629 "itemProperties": {
1630 "key": "enable"
1631 },
1632 "subItemList": [
1633 {
1634 "name": "enable",
1635 "value": "1",
1636 "properties": {}
1637 }
1638 ]
1639 }
1640 ]
1641 }
1642 }
1643 }
1644 })");
1645 const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_RSS_CLOUD_CONFIG_UPDATE,
1646 0, payload);
1647 ret = SocPerfPlugin::GetInstance().HandleRssCloudConfigUpdate(data);
1648 EXPECT_EQ(ret, true);
1649 }
1650
1651 /*
1652 * @tc.name: SocPerfPluginTest_API_TEST_059
1653 * @tc.desc: test socperfplugin api
1654 * @tc.type FUNC
1655 * @tc.require:
1656 */
1657 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_059, Function | MediumTest | Level0)
1658 {
1659 bool ret = SocPerfPlugin::GetInstance().HandleRssCloudConfigUpdate(nullptr);
1660 EXPECT_EQ(ret, false);
1661 nlohmann::json payload = nlohmann::json::parse(R"({
1662 "params" : {
1663 "SOCPERF": {
1664 "specialExtension": {
1665 "itemList": [
1666 {
1667 "itemProperties": {
1668 "key": "specialExtension"
1669 },
1670 "subItemList": [
1671 {
1672 "name": "info",
1673 "value": "0",
1674 "properties": {
1675 "bundleName" : "2",
1676 "callerBundleName" : "1"
1677 }
1678 }
1679 ]
1680 }
1681 ]
1682 },
1683 "weakInterAction": {
1684 "itemList": [
1685 {
1686 "itemProperties": {
1687 "key": "enable"
1688 },
1689 "subItemList": [
1690 {
1691 "name": "enable",
1692 "value": "0",
1693 "properties": {}
1694 }
1695 ]
1696 }
1697 ]
1698 }
1699 }
1700 }
1701 })");
1702 const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_RSS_CLOUD_CONFIG_UPDATE,
1703 0, payload);
1704 ret = SocPerfPlugin::GetInstance().HandleRssCloudConfigUpdate(data);
1705 EXPECT_EQ(ret, true);
1706 }
1707
1708 /*
1709 * @tc.name: SocPerfPluginTest_API_TEST_060
1710 * @tc.desc: test socperfplugin api
1711 * @tc.type FUNC
1712 * @tc.require:
1713 */
1714 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_060, Function | MediumTest | Level0)
1715 {
1716 nlohmann::json payload;
1717 payload["deviceModeType"] = "deviceModeType";
1718 payload["deviceMode"] = "displayGlobalFull";
1719 std::shared_ptr<ResData> invalidPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
1720 ResType::DeviceModeStatus::MODE_ENTER, payload);
1721 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidPayload);
1722 std::shared_ptr<ResData> normalValuedata = std::make_shared <ResData>(ResType::RES_TYPE_SCREEN_STATUS,
1723 ResType::ScreenStatus::SCREEN_ON, nullptr);
1724 SocPerfPlugin::GetInstance().HandleScreenStatusAnalysis(normalValuedata);
1725 nlohmann::json payload1;
1726 payload1["deviceModeType"] = "deviceOrientation";
1727 payload1["deviceMode"] = "displayLandscape";
1728 std::shared_ptr<ResData> invalidPayload1 = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_ORIENTATION_STATUS,
1729 ResType::DeviceModeStatus::MODE_ENTER, payload1);
1730 SocPerfPlugin::GetInstance().HandleDeviceOrientationStatusChange(invalidPayload1);
1731 std::string deviceOrientationType = "deviceOrientation";
1732 bool ret = SocPerfPlugin::GetInstance().HandleSceenOrientationBoost(deviceOrientationType);
1733 EXPECT_TRUE(ret);
1734 payload["deviceModeType"] = "deviceModeType";
1735 payload["deviceMode"] = "displayFull";
1736 invalidPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
1737 ResType::DeviceModeStatus::MODE_ENTER, payload);
1738 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidPayload);
1739 normalValuedata = std::make_shared <ResData>(ResType::RES_TYPE_SCREEN_STATUS,
1740 ResType::ScreenStatus::SCREEN_ON, nullptr);
1741 SocPerfPlugin::GetInstance().HandleScreenStatusAnalysis(normalValuedata);
1742 payload1["deviceModeType"] = "deviceOrientation";
1743 payload1["deviceMode"] = "displayPortrait";
1744 invalidPayload1 = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_ORIENTATION_STATUS,
1745 ResType::DeviceModeStatus::MODE_ENTER, payload1);
1746 SocPerfPlugin::GetInstance().HandleDeviceOrientationStatusChange(invalidPayload1);
1747 deviceOrientationType = "deviceOrientation";
1748 ret = SocPerfPlugin::GetInstance().HandleSceenOrientationBoost(deviceOrientationType);
1749 EXPECT_FALSE(ret);
1750 }
1751
1752 /*
1753 * @tc.name: SocPerfPluginTest_API_TEST_062
1754 * @tc.desc: test ReportConfiguredPolicyMode when SOC_PERF_SA online
1755 * @tc.type FUNC
1756 * @tc.require:
1757 */
1758 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_062, Function | MediumTest | Level0)
1759 {
1760 auto backupPower = SocPerfPlugin::GetInstance().powerLimit_;
1761 auto backupThermal = SocPerfPlugin::GetInstance().thermalLimit_;
1762 const int32_t SOC_PERF_SA_ID = 1906;
1763 nlohmann::json payload;
1764 payload["saId"] = SOC_PERF_SA_ID;
1765 const auto data = std::make_shared<ResData>(ResType::RES_TYPE_SYSTEM_ABILITY_STATUS_CHANGE,
1766 1, payload);
1767
1768 SocPerfPlugin::GetInstance().powerLimit_ = 0;
1769 SocPerfPlugin::GetInstance().thermalLimit_ = 1;
1770 auto ret = SocPerfPlugin::GetInstance().ReportAbilityStatus(data);
1771 EXPECT_TRUE(ret);
1772
1773 // Restore the environment
1774 SocPerfPlugin::GetInstance().powerLimit_ = backupPower;
1775 SocPerfPlugin::GetInstance().thermalLimit_ = backupThermal;
1776 ret = SocPerfPlugin::GetInstance().ReportAbilityStatus(data);
1777 EXPECT_TRUE(ret);
1778 }
1779 } // namespace SOCPERF
1780 } // namespace OHOS