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>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
192 SocPerfPlugin::GetInstance().HandleEventSlide(invalidData);
193 EXPECT_NE(slideEventOnData, nullptr);
194 }
195
196 /*
197 * @tc.name: SocPerfPluginTest_API_TEST_006
198 * @tc.desc: test socperfplugin api
199 * @tc.type FUNC
200 * @tc.require: issueI78T3V
201 */
202 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_006, Function | MediumTest | Level0)
203 {
204 const std::shared_ptr<ResData>& webGestureStartData = std::make_shared<ResData>(ResType::RES_TYPE_WEB_GESTURE,
205 ResType::WebGesture::WEB_GESTURE_START, nullptr);
206 SocPerfPlugin::GetInstance().HandleEventWebGesture(webGestureStartData);
207 const std::shared_ptr<ResData>& webGestureEndData = std::make_shared<ResData>(ResType::RES_TYPE_WEB_GESTURE,
208 ResType::WebGesture::WEB_GESTURE_END, nullptr);
209 SocPerfPlugin::GetInstance().HandleEventWebGesture(webGestureEndData);
210 SocPerfPlugin::GetInstance().HandleEventWebGesture(nullptr);
211 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
212 SocPerfPlugin::GetInstance().HandleEventWebGesture(invalidData);
213 EXPECT_NE(webGestureStartData, nullptr);
214 }
215
216 /*
217 * @tc.name: SocPerfPluginTest_API_TEST_007
218 * @tc.desc: test socperfplugin api
219 * @tc.type FUNC
220 * @tc.require: issueI78T3V
221 */
222 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_007, Function | MediumTest | Level0)
223 {
224 const std::shared_ptr<ResData>& windowResizingData = std::make_shared<ResData>(ResType::RES_TYPE_RESIZE_WINDOW,
225 ResType::WindowResizeType::WINDOW_RESIZING, nullptr);
226 SocPerfPlugin::GetInstance().HandleResizeWindow(windowResizingData);
227 const std::shared_ptr<ResData>& webGestureEndData = std::make_shared<ResData>(ResType::RES_TYPE_WEB_GESTURE,
228 ResType::WindowResizeType::WINDOW_RESIZE_STOP, nullptr);
229 SocPerfPlugin::GetInstance().HandleResizeWindow(webGestureEndData);
230 SocPerfPlugin::GetInstance().HandleResizeWindow(nullptr);
231 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
232 SocPerfPlugin::GetInstance().HandleResizeWindow(invalidData);
233 EXPECT_NE(windowResizingData, nullptr);
234 }
235
236 /*
237 * @tc.name: SocPerfPluginTest_API_TEST_008
238 * @tc.desc: test socperfplugin api
239 * @tc.type FUNC
240 * @tc.require: issueI78T3V
241 */
242 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_008, Function | MediumTest | Level0)
243 {
244 const std::shared_ptr<ResData>& windowMovingData = std::make_shared<ResData>(ResType::RES_TYPE_MOVE_WINDOW,
245 ResType::WindowMoveType::WINDOW_MOVING, nullptr);
246 SocPerfPlugin::GetInstance().HandleMoveWindow(windowMovingData);
247 const std::shared_ptr<ResData>& windowMoveStop = std::make_shared<ResData>(ResType::RES_TYPE_MOVE_WINDOW,
248 ResType::WindowMoveType::WINDOW_MOVE_STOP, nullptr);
249 SocPerfPlugin::GetInstance().HandleMoveWindow(windowMoveStop);
250 SocPerfPlugin::GetInstance().HandleMoveWindow(nullptr);
251 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
252 SocPerfPlugin::GetInstance().HandleMoveWindow(invalidData);
253 EXPECT_NE(windowMovingData, nullptr);
254 }
255
256 /*
257 * @tc.name: SocPerfPluginTest_API_TEST_009
258 * @tc.desc: test socperfplugin api
259 * @tc.type FUNC
260 * @tc.require: issueI78T3V
261 */
262 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_009, Function | MediumTest | Level0)
263 {
264 const std::shared_ptr<ResData>& animationEndData = std::make_shared<ResData>(
265 ResType::RES_TYPE_SHOW_REMOTE_ANIMATION, ResType::ShowRemoteAnimationStatus::ANIMATION_END, nullptr);
266 SocPerfPlugin::GetInstance().HandleRemoteAnimation(animationEndData);
267 const std::shared_ptr<ResData>& animationBeginData = std::make_shared<ResData>(
268 ResType::RES_TYPE_SHOW_REMOTE_ANIMATION, ResType::ShowRemoteAnimationStatus::ANIMATION_BEGIN, nullptr);
269 SocPerfPlugin::GetInstance().HandleRemoteAnimation(animationBeginData);
270 const std::shared_ptr<ResData>& unlockEndData = std::make_shared<ResData>(
271 ResType::RES_TYPE_SHOW_REMOTE_ANIMATION, ResType::ShowRemoteAnimationStatus::ANIMATION_UNLOCK_END, nullptr);
272 SocPerfPlugin::GetInstance().HandleRemoteAnimation(unlockEndData);
273 const std::shared_ptr<ResData>& unlockBeginData = std::make_shared<ResData>(
274 ResType::RES_TYPE_SHOW_REMOTE_ANIMATION, ResType::ShowRemoteAnimationStatus::ANIMATION_UNLOCK_BEGIN, nullptr);
275 SocPerfPlugin::GetInstance().HandleRemoteAnimation(unlockBeginData);
276 SocPerfPlugin::GetInstance().HandleRemoteAnimation(animationEndData);
277 SocPerfPlugin::GetInstance().HandleRemoteAnimation(unlockEndData);
278 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
279 SocPerfPlugin::GetInstance().HandleRemoteAnimation(invalidData);
280 EXPECT_NE(animationEndData, nullptr);
281 }
282
283 /*
284 * @tc.name: SocPerfPluginTest_API_TEST_010
285 * @tc.desc: test socperfplugin api
286 * @tc.type FUNC
287 * @tc.require: issueI78T3V
288 */
289 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_010, Function | MediumTest | Level0)
290 {
291 const std::shared_ptr<ResData>& dragStartData = std::make_shared<ResData>(ResType::RES_TYPE_DRAG_STATUS_BAR,
292 ResType::StatusBarDragStatus::DRAG_START, nullptr);
293 SocPerfPlugin::GetInstance().HandleDragStatusBar(dragStartData);
294 const std::shared_ptr<ResData>& dragEndData = std::make_shared<ResData>(ResType::RES_TYPE_DRAG_STATUS_BAR,
295 ResType::StatusBarDragStatus::DRAG_END, nullptr);
296 SocPerfPlugin::GetInstance().HandleDragStatusBar(dragEndData);
297 SocPerfPlugin::GetInstance().HandleDragStatusBar(nullptr);
298 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
299 SocPerfPlugin::GetInstance().HandleDragStatusBar(invalidData);
300 EXPECT_NE(dragStartData, nullptr);
301 }
302
303 /*
304 * @tc.name: SocPerfPluginTest_API_TEST_011
305 * @tc.desc: test socperfplugin api
306 * @tc.type FUNC
307 * @tc.require: issueI78T3V
308 */
309 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_011, Function | MediumTest | Level0)
310 {
311 const std::shared_ptr<ResData>& webGestureMoveStartData = std::make_shared<ResData>(
312 ResType::RES_TYPE_WEB_GESTURE_MOVE, ResType::WebGestureMove::WEB_GESTURE_MOVE_START, nullptr);
313 SocPerfPlugin::GetInstance().HandleWebGestureMove(webGestureMoveStartData);
314 const std::shared_ptr<ResData>& webGestureMoveEndData = std::make_shared<ResData>(
315 ResType::RES_TYPE_WEB_GESTURE_MOVE, ResType::WebGestureMove::WEB_GESTURE_MOVE_END, nullptr);
316 SocPerfPlugin::GetInstance().HandleWebGestureMove(webGestureMoveEndData);
317 SocPerfPlugin::GetInstance().HandleWebGestureMove(nullptr);
318 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
319 SocPerfPlugin::GetInstance().HandleWebGestureMove(invalidData);
320 EXPECT_NE(webGestureMoveStartData, nullptr);
321 }
322
323 /*
324 * @tc.name: SocPerfPluginTest_API_TEST_012
325 * @tc.desc: test socperfplugin api
326 * @tc.type FUNC
327 * @tc.require: issueI78T3V
328 */
329 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_012, Function | MediumTest | Level0)
330 {
331 const std::shared_ptr<ResData>& webSlideNormalStartData = std::make_shared<ResData>(
332 ResType::RES_TYPE_WEB_SLIDE_NORMAL, ResType::WebSlideNormal::WEB_SLIDE_NORMAL_START, nullptr);
333 SocPerfPlugin::GetInstance().HandleWebSlideNormal(webSlideNormalStartData);
334 const std::shared_ptr<ResData>& webSlideNormalEndData = std::make_shared<ResData>(
335 ResType::RES_TYPE_WEB_SLIDE_NORMAL, ResType::WebSlideNormal::WEB_SLIDE_NORMAL_END, nullptr);
336 SocPerfPlugin::GetInstance().HandleWebSlideNormal(webSlideNormalEndData);
337 SocPerfPlugin::GetInstance().HandleWebSlideNormal(nullptr);
338 const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
339 SocPerfPlugin::GetInstance().HandleWebSlideNormal(invalidData);
340 EXPECT_NE(webSlideNormalStartData, nullptr);
341 }
342
343 /*
344 * @tc.name: SocPerfPluginTest_API_TEST_013
345 * @tc.desc: test socperfplugin api
346 * @tc.type FUNC
347 * @tc.require: issueI78T3V
348 */
349 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_013, Function | MediumTest | Level0)
350 {
351 const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_LOAD_URL, -1, nullptr);
352 SocPerfPlugin::GetInstance().HandleLoadUrl(data);
353 EXPECT_NE(data, nullptr);
354 }
355
356 /*
357 * @tc.name: SocPerfPluginTest_API_TEST_014
358 * @tc.desc: test socperfplugin api
359 * @tc.type FUNC
360 * @tc.require: issueI78T3V
361 */
362 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_014, Function | MediumTest | Level0)
363 {
364 const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_MOUSEWHEEL, -1, nullptr);
365 SocPerfPlugin::GetInstance().HandleMousewheel(data);
366 EXPECT_NE(data, nullptr);
367 }
368
369 /*
370 * @tc.name: SocPerfPluginTest_API_TEST_015
371 * @tc.desc: test socperfplugin api
372 * @tc.type FUNC
373 * @tc.require: issueI78T3V
374 */
375 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_015, Function | MediumTest | Level0)
376 {
377 const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_POP_PAGE, -1, nullptr);
378 SocPerfPlugin::GetInstance().HandlePopPage(data);
379 EXPECT_NE(data, nullptr);
380 }
381
382 /*
383 * @tc.name: SocPerfPluginTest_API_TEST_016
384 * @tc.desc: test socperfplugin api
385 * @tc.type FUNC
386 * @tc.require: issueI78T3V
387 */
388 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_016, Function | MediumTest | Level0)
389 {
390 std::shared_ptr<ResData> invalidValuedata = std::make_shared<ResData>(ResType::RES_TYPE_APP_STATE_CHANGE,
391 ResType::ProcessStatus::PROCESS_READY, nullptr);
392 bool ret = SocPerfPlugin::GetInstance().HandleAppStateChange(invalidValuedata);
393 EXPECT_FALSE(ret);
394
395 nlohmann::json invalidPayload;
396 invalidPayload["extensionType"] = 0;
397 std::shared_ptr<ResData> invalidPayloadTypedata = std::make_shared<ResData>(ResType::RES_TYPE_APP_STATE_CHANGE,
398 ResType::ProcessStatus::PROCESS_CREATED, invalidPayload);
399 ret = SocPerfPlugin::GetInstance().HandleAppStateChange(invalidPayloadTypedata);
400 EXPECT_FALSE(ret);
401
402 nlohmann::json payload;
403 payload["extensionType"] = 2;
404 std::shared_ptr<ResData> data = std::make_shared<ResData>(ResType::RES_TYPE_APP_STATE_CHANGE,
405 ResType::ProcessStatus::PROCESS_CREATED, payload);
406 ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
407 EXPECT_TRUE(ret);
408
409 payload["extensionType"] = 255;
410 data->payload = payload;
411 ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
412 EXPECT_TRUE(ret);
413
414 payload["extensionType"] = 256;
415 data->payload = payload;
416 ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
417 EXPECT_TRUE(ret);
418
419 payload["extensionType"] = 500;
420 data->payload = payload;
421 ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
422 EXPECT_TRUE(ret);
423
424 payload["extensionType"] = 600;
425 data->payload = payload;
426 ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
427 EXPECT_FALSE(ret);
428 }
429
430 /*
431 * @tc.name: SocPerfPluginTest_API_TEST_017
432 * @tc.desc: test socperfplugin api
433 * @tc.type FUNC
434 * @tc.require: issueI78T3V
435 */
436 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_017, Function | MediumTest | Level0)
437 {
438 nlohmann::json payload;
439 payload["deviceMode"] = "test";
440 std::shared_ptr<ResData> normalValuedata = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
441 ResType::DeviceModeStatus::MODE_ENTER, payload);
442 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(normalValuedata);
443 SUCCEED();
444
445 nlohmann::json payload2;
446 payload["test"] = "test";
447 std::shared_ptr<ResData> invalidPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
448 ResType::DeviceModeStatus::MODE_ENTER, payload2);
449 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidPayload);
450 SUCCEED();
451
452 nlohmann::json payload3;
453 payload["test"] = "test";
454 int64_t invalidType = 3;
455 std::shared_ptr<ResData> invalidValue = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
456 invalidType, payload3);
457 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidValue);
458 SUCCEED();
459
460 nlohmann::json payload4;
461 payload["deviceMode"] = "";
462 std::shared_ptr<ResData> emptyPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
463 ResType::DeviceModeStatus::MODE_ENTER, payload4);
464 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(emptyPayload);
465 SUCCEED();
466
467 nlohmann::json payload5;
468 payload["deviceMode"] = "ABCEDFGHABCEDFGHABCEDFGHABCEDFGHABCEDFGHABCEDFGHABCEDFGHABCEDFGHZ";
469 const std::shared_ptr<ResData>& maxLenPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
470 ResType::DeviceModeStatus::MODE_ENTER, payload5);
471 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(maxLenPayload);
472 EXPECT_NE(maxLenPayload, nullptr);
473 }
474
475 /*
476 * @tc.name: SocPerfPluginTest_API_TEST_018
477 * @tc.desc: test socperfplugin api
478 * @tc.type FUNC
479 * @tc.require: issueI78T3V
480 */
481 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_018, Function | MediumTest | Level0)
482 {
483 const std::shared_ptr<ResData>& scbAnimationEndData = std::make_shared<ResData>(
484 SocPerfPlugin::GetInstance().RES_TYPE_SCENE_BOARD_ID,
485 ResType::ShowRemoteAnimationStatus::ANIMATION_END, nullptr);
486 bool ret = SocPerfPlugin::GetInstance().HandleSocperfSceneBoard(scbAnimationEndData);
487 EXPECT_TRUE(ret);
488 const std::shared_ptr<ResData>& scbAnimationBeginData = std::make_shared<ResData>(
489 SocPerfPlugin::GetInstance().RES_TYPE_SCENE_BOARD_ID,
490 ResType::ShowRemoteAnimationStatus::ANIMATION_BEGIN, nullptr);
491 ret = SocPerfPlugin::GetInstance().HandleSocperfSceneBoard(scbAnimationBeginData);
492 EXPECT_TRUE(ret);
493 ret = SocPerfPlugin::GetInstance().HandleSocperfSceneBoard(nullptr);
494 EXPECT_FALSE(ret);
495 }
496
497 #ifdef RESSCHED_RESOURCESCHEDULE_CUST_SOC_PERF_ENABLE
498 /*
499 * @tc.name: SocPerfPluginTest_API_TEST_019
500 * @tc.desc: test socperfplugin api
501 * @tc.type FUNC
502 * @tc.require: issueI78T3V
503 */
504 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_019, Function | MediumTest | Level0)
505 {
506 const std::shared_ptr<ResData>& ancoEvnetData = std::make_shared<ResData>(
507 ResType::RES_TYPE_ANCO_CUST, 1001, nullptr);
508 bool ret = SocPerfPlugin::GetInstance().HandleCustEvent(ancoEvnetData);
509 EXPECT_TRUE(ret);
510 const std::shared_ptr<ResData>& ancoEvnetDataInvalid = std::make_shared<ResData>(
511 ResType::RES_TYPE_ANCO_CUST, -1, nullptr);
512 ret = SocPerfPlugin::GetInstance().HandleCustEvent(ancoEvnetDataInvalid);
513 EXPECT_FALSE(ret);
514 }
515
516 /*
517 * @tc.name: SocPerfPluginTest_API_TEST_020
518 * @tc.desc: test socperfplugin api
519 * @tc.type FUNC
520 * @tc.require: issueI78T3V
521 */
522 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_020, Function | MediumTest | Level0)
523 {
524 const std::shared_ptr<ResData>& socPerfCustEventBeginData = std::make_shared<ResData>(
525 ResType::RES_TYPE_SOCPERF_CUST_EVENT_BEGIN, 1001, nullptr);
526 bool ret = SocPerfPlugin::GetInstance().HandleCustEventBegin(socPerfCustEventBeginData);
527 EXPECT_TRUE(ret);
528 const std::shared_ptr<ResData>& socPerfCustEventBeginDataInvalid = std::make_shared<ResData>(
529 ResType::RES_TYPE_SOCPERF_CUST_EVENT_BEGIN, -1, nullptr);
530 ret = SocPerfPlugin::GetInstance().HandleCustEventBegin(socPerfCustEventBeginDataInvalid);
531 EXPECT_FALSE(ret);
532 }
533
534 /*
535 * @tc.name: SocPerfPluginTest_API_TEST_021
536 * @tc.desc: test socperfplugin api
537 * @tc.type FUNC
538 * @tc.require: issueI78T3V
539 */
540 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_021, Function | MediumTest | Level0)
541 {
542 const std::shared_ptr<ResData>& socPerfCustEventEndData = std::make_shared<ResData>(
543 ResType::RES_TYPE_SOCPERF_CUST_EVENT_END, 1001, nullptr);
544 bool ret = SocPerfPlugin::GetInstance().HandleCustEventEnd(socPerfCustEventEndData);
545 EXPECT_TRUE(ret);
546 const std::shared_ptr<ResData>& socPerfCustEventEndDataInvalid = std::make_shared<ResData>(
547 ResType::RES_TYPE_SOCPERF_CUST_EVENT_END, -1, nullptr);
548 ret = SocPerfPlugin::GetInstance().HandleCustEventEnd(socPerfCustEventEndDataInvalid);
549 EXPECT_FALSE(ret);
550 }
551 #endif // RESSCHED_RESOURCESCHEDULE_CUST_SOC_PERF_ENABLE
552
553 /*
554 * @tc.name: SocPerfPluginTest_API_TEST_022
555 * @tc.desc: test socperfplugin api
556 * @tc.type FUNC
557 * @tc.require: issueI78T3V
558 */
559 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_022, Function | MediumTest | Level0)
560 {
561 const std::shared_ptr<ResData>& socPerfPowerModeChangedStartData = std::make_shared<ResData>(
562 ResType::RES_TYPE_POWER_MODE_CHANGED, 601, nullptr);
563 bool ret = SocPerfPlugin::GetInstance().HandlePowerModeChanged(socPerfPowerModeChangedStartData);
564 EXPECT_TRUE(ret);
565 const std::shared_ptr<ResData>& socPerfPowerModeChangedEndData = std::make_shared<ResData>(
566 ResType::RES_TYPE_POWER_MODE_CHANGED, 602, nullptr);
567 ret = SocPerfPlugin::GetInstance().HandlePowerModeChanged(socPerfPowerModeChangedEndData);
568 EXPECT_TRUE(ret);
569 }
570
571 /*
572 * @tc.name: SocPerfPluginTest_API_TEST_023
573 * @tc.desc: test socperfplugin api
574 * @tc.type FUNC
575 * @tc.require: issueI78T3V
576 */
577 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_023, Function | MediumTest | Level0)
578 {
579 const std::shared_ptr<ResData>& socPerfBmmMoniterStartData = std::make_shared<ResData>(
580 ResType::RES_TYPE_BMM_MONITER_CHANGE_EVENT, ResType::BmmMoniterStatus::BMM_BACKGROUND, nullptr);
581 bool ret = SocPerfPlugin::GetInstance().HandleBmmMoniterStatus(socPerfBmmMoniterStartData);
582 EXPECT_TRUE(ret);
583 const std::shared_ptr<ResData>& socPerfBmmMoniterEndData = std::make_shared<ResData>(
584 ResType::RES_TYPE_BMM_MONITER_CHANGE_EVENT, ResType::BmmMoniterStatus::BMM_CLOSE, nullptr);
585 ret = SocPerfPlugin::GetInstance().HandleBmmMoniterStatus(socPerfBmmMoniterEndData);
586 EXPECT_TRUE(ret);
587 const std::shared_ptr<ResData>& socPerfBmmMoniterDataInvalid = std::make_shared<ResData>(
588 ResType::RES_TYPE_BMM_MONITER_CHANGE_EVENT, -1, nullptr);
589 ret = SocPerfPlugin::GetInstance().HandleBmmMoniterStatus(socPerfBmmMoniterDataInvalid);
590 EXPECT_FALSE(ret);
591 }
592
593 /*
594 * @tc.name: SocPerfPluginTest_API_TEST_024
595 * @tc.desc: test socperfplugin api
596 * @tc.type FUNC
597 * @tc.require: issueI78T3V
598 */
599 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_024, Function | MediumTest | Level0)
600 {
601 const std::shared_ptr<ResData>& socPerfSceneRotationStartData = std::make_shared<ResData>(
602 ResType::RES_TYPE_SCENE_ROTATION, 0, nullptr);
603 bool ret = SocPerfPlugin::GetInstance().HandleSceneRotation(socPerfSceneRotationStartData);
604 EXPECT_TRUE(ret);
605 const std::shared_ptr<ResData>& socPerfSceneRotationEndData = std::make_shared<ResData>(
606 ResType::RES_TYPE_SCENE_ROTATION, 1, nullptr);
607 ret = SocPerfPlugin::GetInstance().HandleSceneRotation(socPerfSceneRotationEndData);
608 EXPECT_TRUE(ret);
609 }
610
611 /*
612 * @tc.name: SocPerfPluginTest_API_TEST_025
613 * @tc.desc: test socperfplugin api
614 * @tc.type FUNC
615 * @tc.require: issueI78T3V
616 */
617 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_025, Function | MediumTest | Level0)
618 {
619 const std::shared_ptr<ResData>& socPerfAppColdStartData = std::make_shared<ResData>(
620 ResType::RES_TYPE_ONLY_PERF_APP_COLD_START, 0, nullptr);
621 bool ret = SocPerfPlugin::GetInstance().HandleAppColdStartEx(socPerfAppColdStartData);
622 EXPECT_TRUE(ret);
623 const std::shared_ptr<ResData>& socPerfAppColdEndData = std::make_shared<ResData>(
624 ResType::RES_TYPE_ONLY_PERF_APP_COLD_START, 1, nullptr);
625 ret = SocPerfPlugin::GetInstance().HandleAppColdStartEx(socPerfAppColdEndData);
626 EXPECT_TRUE(ret);
627 }
628
629 /*
630 * @tc.name: SocPerfPluginTest_API_TEST_026
631 * @tc.desc: test socperfplugin api
632 * @tc.type FUNC
633 * @tc.require: issueI78T3V
634 */
635 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_026, Function | MediumTest | Level0)
636 {
637 const std::shared_ptr<ResData>& socPerfRgmBootingStartData = std::make_shared<ResData>(
638 SocPerfPlugin::GetInstance().RES_TYPE_RGM_BOOTING_STATUS, 0, nullptr);
639 bool ret = SocPerfPlugin::GetInstance().HandleRgmBootingStatus(socPerfRgmBootingStartData);
640 EXPECT_TRUE(ret);
641 const std::shared_ptr<ResData>& socPerfRgmBootingEndData = std::make_shared<ResData>(
642 SocPerfPlugin::GetInstance().RES_TYPE_RGM_BOOTING_STATUS, -1, nullptr);
643 ret = SocPerfPlugin::GetInstance().HandleRgmBootingStatus(socPerfRgmBootingEndData);
644 EXPECT_TRUE(ret);
645 }
646
647 /*
648 * @tc.name: SocPerfPluginTest_API_TEST_027
649 * @tc.desc: test socperfplugin api
650 * @tc.type FUNC
651 * @tc.require: issueI78T3V
652 */
653 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_027, Function | MediumTest | Level0)
654 {
655 const std::shared_ptr<ResData>& socPerfAccountActivatingData = std::make_shared<ResData>(
656 ResType::RES_TYPE_ACCOUNT_ACTIVATING, ResType::AccountActivatingStatus::ACCOUNT_ACTIVATING_START, nullptr);
657 bool ret = SocPerfPlugin::GetInstance().HandleSocperfAccountActivating(socPerfAccountActivatingData);
658 EXPECT_TRUE(ret);
659 const std::shared_ptr<ResData>& socPerfAccountActivatingInvalid = std::make_shared<ResData>(
660 ResType::RES_TYPE_ACCOUNT_ACTIVATING, -1, nullptr);
661 ret = SocPerfPlugin::GetInstance().HandleSocperfAccountActivating(socPerfAccountActivatingInvalid);
662 EXPECT_TRUE(ret);
663 }
664
665 /*
666 * @tc.name: SocPerfPluginTest_API_TEST_028
667 * @tc.desc: test socperfplugin api
668 * @tc.type FUNC
669 * @tc.require: issueI78T3V
670 */
671 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_028, Function | MediumTest | Level0)
672 {
673 nlohmann::json payload;
674 payload["deviceMode"] = "displayMain";
675 std::shared_ptr<ResData> invalidPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
676 ResType::DeviceModeStatus::MODE_ENTER, payload);
677 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidPayload);
678
679 std::shared_ptr<ResData> normalValuedata = std::make_shared<ResData>(ResType::RES_TYPE_SCREEN_STATUS,
680 ResType::ScreenStatus::SCREEN_ON, nullptr);
681 bool ret = SocPerfPlugin::GetInstance().HandleScreenStatusAnalysis(normalValuedata);
682 EXPECT_TRUE(ret);
683
684 std::shared_ptr<ResData> normalValuedata2 = std::make_shared<ResData>(ResType::RES_TYPE_SCREEN_STATUS,
685 ResType::ScreenStatus::SCREEN_OFF, nullptr);
686 ret = SocPerfPlugin::GetInstance().HandleScreenStatusAnalysis(normalValuedata2);
687 EXPECT_TRUE(ret);
688
689 nlohmann::json payload1;
690 payload1["deviceMode"] = "displayFull";
691 std::shared_ptr<ResData> invalidPayload1 = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
692 ResType::DeviceModeStatus::MODE_ENTER, payload1);
693 SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidPayload1);
694
695 std::shared_ptr<ResData> normalValuedata3 = std::make_shared<ResData>(ResType::RES_TYPE_SCREEN_STATUS,
696 ResType::ScreenStatus::SCREEN_ON, nullptr);
697 ret = SocPerfPlugin::GetInstance().HandleScreenStatusAnalysis(normalValuedata3);
698 EXPECT_TRUE(ret);
699
700 std::shared_ptr<ResData> normalValuedata4 = std::make_shared<ResData>(ResType::RES_TYPE_SCREEN_STATUS,
701 ResType::ScreenStatus::SCREEN_OFF, nullptr);
702 ret = SocPerfPlugin::GetInstance().HandleScreenStatusAnalysis(normalValuedata4);
703 EXPECT_TRUE(ret);
704
705 ret = SocPerfPlugin::GetInstance().HandleScreenStatusAnalysis(nullptr);
706 EXPECT_FALSE(ret);
707 }
708
709 /*
710 * @tc.name: SocPerfPluginTest_API_TEST_029
711 * @tc.desc: test socperfplugin api
712 * @tc.type FUNC
713 * @tc.require: issueI78T3V
714 */
715 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_029, Function | MediumTest | Level0)
716 {
717 bool ret = SocPerfPlugin::GetInstance().HandleSubValue("");
718 EXPECT_FALSE(ret);
719 ret = SocPerfPlugin::GetInstance().HandleSubValue("tencent,alipay");
720 EXPECT_TRUE(ret);
721 }
722
723 /*
724 * @tc.name: SocPerfPluginTest_API_TEST_031
725 * @tc.desc: test socperfplugin api
726 * @tc.type FUNC
727 * @tc.require: issueI78T3V
728 */
729 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_031, Function | MediumTest | Level0)
730 {
731 nlohmann::json payload1;
732 payload1["uid"] = "100111";
733 std::shared_ptr<ResData> normalData1 = std::make_shared<ResData>(111, 0, payload1);
734 int32_t appType = -1;
735 bool ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(normalData1, appType, "qq");
736 EXPECT_FALSE(ret);
737
738 appType = 0;
739 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(normalData1, appType, "qq");
740 EXPECT_FALSE(ret);
741
742 appType = 3;
743 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(normalData1, appType, "qq");
744 EXPECT_TRUE(ret);
745
746 nlohmann::json payload2;
747 payload2["uid"] = "-1";
748 std::shared_ptr<ResData> normalData2 = std::make_shared<ResData>(111, 0, payload2);
749 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(normalData2, appType, "qq");
750 EXPECT_FALSE(ret);
751 }
752
753 /*
754 * @tc.name: SocPerfPluginTest_API_TEST_032
755 * @tc.desc: test socperfplugin api
756 * @tc.type FUNC
757 * @tc.require: issueI78T3V
758 */
759 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_032, Function | MediumTest | Level0)
760 {
761 nlohmann::json payload1;
762 payload1["uid"] = "-1";
763 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(111, 0, payload1);
764 bool ret = SocPerfPlugin::GetInstance().UpdateFocusAppType(invalidData1, true);
765 EXPECT_FALSE(ret);
766
767 nlohmann::json payload2;
768 payload2["uid"] = "10011";
769 std::shared_ptr<ResData> validData2 = std::make_shared<ResData>(111, 0, payload2);
770 ret = SocPerfPlugin::GetInstance().UpdateFocusAppType(validData2, false);
771 EXPECT_TRUE(ret);
772
773 payload2["pid"] = "2025";
774 AppKeyMessage appMsg(3, "qq");
775 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10011] = appMsg;
776 ret = SocPerfPlugin::GetInstance().UpdateFocusAppType(validData2, true);
777 EXPECT_TRUE(ret);
778
779 nlohmann::json payload3;
780 payload3["uid"] = "10012";
781 payload3["pid"] = "2025";
782 std::shared_ptr<ResData> validData3 = std::make_shared<ResData>(111, 0, payload3);
783 SocPerfPlugin::GetInstance().reqAppTypeFunc_ = nullptr;
784 ret = SocPerfPlugin::GetInstance().UpdateFocusAppType(validData3, true);
785 EXPECT_FALSE(ret);
786
787 SocPerfPlugin::GetInstance().reqAppTypeFunc_ =
__anon43d9d7330202(const std::string& bundleName) 788 [](const std::string& bundleName) { return -1; };
789 ret = SocPerfPlugin::GetInstance().UpdateFocusAppType(validData3, true);
790 EXPECT_TRUE(ret);
791 }
792
793 /*
794 * @tc.name: SocPerfPluginTest_API_TEST_033
795 * @tc.desc: test socperfplugin api
796 * @tc.type FUNC
797 * @tc.require: issueI78T3V
798 */
799 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_033, Function | MediumTest | Level0)
800 {
801 SocPerfPlugin::GetInstance().focusAppUids_.clear();
802 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
803 bool ret = SocPerfPlugin::GetInstance().IsFocusAppsAllGame();
804 EXPECT_FALSE(ret);
805
806 AppKeyMessage appMsg1(2, "qq");
807 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10010] = appMsg1;
808 AppKeyMessage appMsg2(3, "alipy");
809 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10011] = appMsg2;
810 AppKeyMessage appMsg3(2, "game");
811 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10012] = appMsg3;
812 SocPerfPlugin::GetInstance().focusAppUids_ = {10010, 10011};
813 ret = SocPerfPlugin::GetInstance().IsFocusAppsAllGame();
814 EXPECT_FALSE(ret);
815
816 SocPerfPlugin::GetInstance().focusAppUids_.insert(10012);
817 SocPerfPlugin::GetInstance().focusAppUids_.erase(10011);
818 ret = SocPerfPlugin::GetInstance().IsFocusAppsAllGame();
819 EXPECT_TRUE(ret);
820 SocPerfPlugin::GetInstance().focusAppUids_.clear();
821 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
822 }
823
824 /*
825 * @tc.name: SocPerfPluginTest_API_TEST_034
826 * @tc.desc: test socperfplugin api
827 * @tc.type FUNC
828 * @tc.require: issueI78T3V
829 */
830 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_034, Function | MediumTest | Level0)
831 {
832 SocPerfPlugin::GetInstance().focusAppUids_.clear();
833 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
834 SocPerfPlugin::GetInstance().focusAppUids_ = {10010};
835 bool ret = SocPerfPlugin::GetInstance().UpdatesFocusAppsType(2);
836 EXPECT_TRUE(ret);
837
838 ret = SocPerfPlugin::GetInstance().UpdatesFocusAppsType(3);
839 EXPECT_FALSE(ret);
840
841 SocPerfPlugin::GetInstance().focusAppUids_.insert(10011);
842 SocPerfPlugin::GetInstance().isFocusAppsGameType_ = false;
843 ret = SocPerfPlugin::GetInstance().UpdatesFocusAppsType(2);
844 EXPECT_FALSE(ret);
845
846 ret = SocPerfPlugin::GetInstance().UpdatesFocusAppsType(3);
847 EXPECT_FALSE(ret);
848
849 SocPerfPlugin::GetInstance().isFocusAppsGameType_ = true;
850 ret = SocPerfPlugin::GetInstance().UpdatesFocusAppsType(2);
851 EXPECT_TRUE(ret);
852
853 ret = SocPerfPlugin::GetInstance().UpdatesFocusAppsType(3);
854 EXPECT_FALSE(ret);
855
856 SocPerfPlugin::GetInstance().focusAppUids_.clear();
857 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
858 }
859
860 /*
861 * @tc.name: SocPerfPluginTest_API_TEST_035
862 * @tc.desc: test socperfplugin api
863 * @tc.type FUNC
864 * @tc.require: issueI78T3V
865 */
866 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_035, Function | MediumTest | Level0)
867 {
868 SocPerfPlugin::GetInstance().socperfGameBoostSwitch_ = false;
869 bool ret = SocPerfPlugin::GetInstance().HandleGameBoost(nullptr);
870 EXPECT_FALSE(ret);
871
872 SocPerfPlugin::GetInstance().socperfGameBoostSwitch_ = true;
873 ret = SocPerfPlugin::GetInstance().HandleGameBoost(nullptr);
874 EXPECT_FALSE(ret);
875
876 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(ResType::RES_TYPE_APP_GAME_BOOST_EVENT,
877 ResType::GameBoostState::BOOST_START, nullptr);
878 ret = SocPerfPlugin::GetInstance().HandleGameBoost(validData1);
879 EXPECT_TRUE(ret);
880
881 std::shared_ptr<ResData> validData2 = std::make_shared<ResData>(ResType::RES_TYPE_APP_GAME_BOOST_EVENT,
882 ResType::GameBoostState::BOOST_END, nullptr);
883 ret = SocPerfPlugin::GetInstance().HandleGameBoost(validData2);
884 EXPECT_TRUE(ret);
885 }
886
887 /*
888 * @tc.name: SocPerfPluginTest_API_TEST_036
889 * @tc.desc: test socperfplugin api
890 * @tc.type FUNC
891 * @tc.require: issueI78T3V
892 */
893 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_036, Function | MediumTest | Level0)
894 {
895 SocPerfPlugin::GetInstance().pidToAppTypeMap_.clear();
896 nlohmann::json payload1;
897 payload1["clientPid"] = "-1";
898 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(-1, -1, payload1);
899 bool ret = SocPerfPlugin::GetInstance().IsGameEvent(invalidData1);
900 EXPECT_FALSE(ret);
901
902 payload1["clientPid"] = "2025";
903 SocPerfPlugin::GetInstance().pidToAppTypeMap_[2025] = 3;
904 std::shared_ptr<ResData> invalidData2 = std::make_shared<ResData>(-1, -1, payload1);
905 ret = SocPerfPlugin::GetInstance().IsGameEvent(invalidData2);
906 EXPECT_FALSE(ret);
907
908 SocPerfPlugin::GetInstance().pidToAppTypeMap_[2025] = 2;
909 std::shared_ptr<ResData> validData = std::make_shared<ResData>(-1, -1, payload1);
910 ret = SocPerfPlugin::GetInstance().IsGameEvent(validData);
911 EXPECT_TRUE(ret);
912 }
913
914 /*
915 * @tc.name: SocPerfPluginTest_API_TEST_037
916 * @tc.desc: test socperfplugin api
917 * @tc.type FUNC
918 * @tc.require: issueI78T3V
919 */
920 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_037, Function | MediumTest | Level0)
921 {
922 bool ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(nullptr);
923 EXPECT_FALSE(ret);
924
925 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(-1, -1, nullptr);
926 ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(invalidData1);
927 EXPECT_FALSE(ret);
928
929 std::shared_ptr<ResData> invalidData2 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
930 ResType::AppInstallStatus::APP_UNINSTALL, nullptr);
931 ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(invalidData2);
932 EXPECT_FALSE(ret);
933
934 nlohmann::json payload1;
935 std::shared_ptr<ResData> invalidData3 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
936 ResType::AppInstallStatus::APP_UNINSTALL, payload1);
937 ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(invalidData3);
938 EXPECT_FALSE(ret);
939
940 payload1["uid"] = "str";
941 ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(invalidData3);
942 EXPECT_FALSE(ret);
943
944 nlohmann::json payload2;
945 payload2["uid"] = -1;
946 std::shared_ptr<ResData> invalidData4 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
947 ResType::AppInstallStatus::APP_UNINSTALL, payload2);
948 ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(invalidData4);
949 EXPECT_FALSE(ret);
950
951 nlohmann::json payload3;
952 payload3["uid"] = 10010;
953 std::shared_ptr<ResData> invalidData5 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
954 ResType::AppInstallStatus::APP_UNINSTALL, payload3);
955 ret = SocPerfPlugin::GetInstance().HandleUninstallEvent(invalidData5);
956 EXPECT_TRUE(ret);
957 }
958
959 /*
960 * @tc.name: SocPerfPluginTest_API_TEST_038
961 * @tc.desc: test socperfplugin api
962 * @tc.type FUNC
963 * @tc.require: issueI78T3V
964 */
965 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_038, Function | MediumTest | Level0)
966 {
967 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(-1, -1, nullptr);
968 bool ret = SocPerfPlugin::GetInstance().GetUidByData(invalidData1) == -1;
969 EXPECT_TRUE(ret);
970
971 nlohmann::json payload1;
972 std::shared_ptr<ResData> invalidData2 = std::make_shared<ResData>(-1, -1, payload1);
973 ret = SocPerfPlugin::GetInstance().GetUidByData(invalidData2) == -1;
974 EXPECT_TRUE(ret);
975
976 payload1["uid"] = 10010;
977 std::shared_ptr<ResData> invalidData3 = std::make_shared<ResData>(-1, -1, payload1);
978 ret = SocPerfPlugin::GetInstance().GetUidByData(invalidData3) == -1;
979 EXPECT_TRUE(ret);
980
981 nlohmann::json payload2;
982 payload2["uid"] = "10010";
983 std::shared_ptr<ResData> invalidData4 = std::make_shared<ResData>(-1, -1, payload2);
984 ret = SocPerfPlugin::GetInstance().GetUidByData(invalidData4) == 10010;
985 EXPECT_TRUE(ret);
986 }
987
988 /*
989 * @tc.name: SocPerfPluginTest_API_TEST_039
990 * @tc.desc: test socperfplugin api
991 * @tc.type FUNC
992 * @tc.require: issueI78T3V
993 */
994 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_039, Function | MediumTest | Level0)
995 {
996 SocPerfPlugin::GetInstance().appNameUseCamera_.clear();
997 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
998 SocPerfPlugin::GetInstance().focusAppUids_.clear();
999 bool ret = SocPerfPlugin::GetInstance().HandleCameraStateChange(nullptr);
1000 EXPECT_FALSE(ret);
1001
1002 SocPerfPlugin::GetInstance().appNameUseCamera_.insert("qqlive");
1003 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
1004 ResType::CameraState::CAMERA_DISCONNECT, nullptr);
1005 ret = SocPerfPlugin::GetInstance().HandleCameraStateChange(validData1);
1006 EXPECT_TRUE(ret);
1007
1008 std::shared_ptr<ResData> validData2 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
1009 ResType::CameraState::CAMERA_CONNECT, nullptr);
1010 ret = SocPerfPlugin::GetInstance().HandleCameraStateChange(validData2);
1011 EXPECT_TRUE(ret);
1012
1013 SocPerfPlugin::GetInstance().focusAppUids_ = {10010, 10011};
1014 AppKeyMessage appMsg(2, "qqlive");
1015 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10010] = appMsg;
1016 std::shared_ptr<ResData> validData3 = std::make_shared<ResData>(ResType::RES_TYPE_APP_INSTALL_UNINSTALL,
1017 ResType::CameraState::CAMERA_CONNECT, nullptr);
1018 ret = SocPerfPlugin::GetInstance().HandleCameraStateChange(validData3);
1019 EXPECT_TRUE(ret);
1020 SocPerfPlugin::GetInstance().appNameUseCamera_.clear();
1021 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
1022 SocPerfPlugin::GetInstance().focusAppUids_.clear();
1023 }
1024
1025 /*
1026 * @tc.name: SocPerfPluginTest_API_TEST_040
1027 * @tc.desc: test socperfplugin api
1028 * @tc.type FUNC
1029 * @tc.require: issueI78T3V
1030 */
1031 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_040, Function | MediumTest | Level0)
1032 {
1033 SocPerfPlugin::GetInstance().appNameUseCamera_.clear();
1034 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
1035 SocPerfPlugin::GetInstance().focusAppUids_.clear();
1036 bool ret = SocPerfPlugin::GetInstance().IsAllowBoostScene();
1037 EXPECT_FALSE(ret);
1038
1039 SocPerfPlugin::GetInstance().appNameUseCamera_.insert("qqlive");
1040 SocPerfPlugin::GetInstance().focusAppUids_ = {10010, 10011};
1041 AppKeyMessage appMsg(2, "qqlive");
1042 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10010] = appMsg;
1043 ret = SocPerfPlugin::GetInstance().IsAllowBoostScene();
1044 EXPECT_TRUE(ret);
1045 SocPerfPlugin::GetInstance().appNameUseCamera_.clear();
1046 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
1047 SocPerfPlugin::GetInstance().focusAppUids_.clear();
1048 }
1049
1050 /*
1051 * @tc.name: SocPerfPluginTest_API_TEST_041
1052 * @tc.desc: test socperfplugin api
1053 * @tc.type FUNC
1054 * @tc.require: issueI78T3V
1055 */
1056 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_041, Function | MediumTest | Level0)
1057 {
1058 bool ret = SocPerfPlugin::GetInstance().HandleProcessStateChange(nullptr);
1059 EXPECT_TRUE(ret);
1060
1061 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(ResType::RES_TYPE_PROCESS_STATE_CHANGE,
1062 ResType::ProcessStatus::PROCESS_DIED, nullptr);
1063 ret = SocPerfPlugin::GetInstance().HandleProcessStateChange(validData1);
1064 EXPECT_TRUE(ret);
1065 }
1066
1067 /*
1068 * @tc.name: SocPerfPluginTest_API_TEST_042
1069 * @tc.desc: test socperfplugin api
1070 * @tc.type FUNC
1071 * @tc.require: issueI78T3V
1072 */
1073 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_042, Function | MediumTest | Level0)
1074 {
1075 nlohmann::json payload1;
1076 payload1["pid"] = "-1";
1077 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(-1, -1, payload1);
1078 bool ret = SocPerfPlugin::GetInstance().HandleProcessStateChange(validData1);
1079 EXPECT_TRUE(ret);
1080
1081 payload1["pid"] = "2025";
1082 std::shared_ptr<ResData> validData2 = std::make_shared<ResData>(-1, -1, payload1);
1083 ret = SocPerfPlugin::GetInstance().HandleProcessStateChange(validData2);
1084 EXPECT_TRUE(ret);
1085 }
1086
1087 /*
1088 * @tc.name: SocPerfPluginTest_API_TEST_043
1089 * @tc.desc: test socperfplugin api
1090 * @tc.type FUNC
1091 * @tc.require: issueI78T3V
1092 */
1093 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_043, Function | MediumTest | Level0)
1094 {
1095 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(-1, -1, nullptr);
1096 bool ret = SocPerfPlugin::GetInstance().GetPidByData(invalidData1, "notKey") == -1;
1097 EXPECT_TRUE(ret);
1098
1099 nlohmann::json payload1;
1100 payload1["pid"] = "2025";
1101 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(-1, -1, payload1);
1102 ret = SocPerfPlugin::GetInstance().GetPidByData(validData1, "notPid") == -1;
1103 EXPECT_TRUE(ret);
1104
1105 ret = SocPerfPlugin::GetInstance().GetPidByData(validData1, "pid") == 2025;
1106 EXPECT_TRUE(ret);
1107
1108 nlohmann::json payload2;
1109 payload2["pid"] = 2025;
1110 std::shared_ptr<ResData> validData2 =
1111 std::make_shared<ResData>(-1, -1, payload2);
1112 ret = SocPerfPlugin::GetInstance().GetPidByData(validData2, "pid") == -1;
1113 EXPECT_TRUE(ret);
1114 }
1115
1116 /*
1117 * @tc.name: SocPerfPluginTest_API_TEST_044
1118 * @tc.desc: test socperfplugin api
1119 * @tc.type FUNC
1120 * @tc.require: issueI78T3V
1121 */
1122 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_044, Function | MediumTest | Level0)
1123 {
1124 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
1125 nlohmann::json payload1;
1126 payload1["uid"] = "-1";
1127 std::shared_ptr<ResData> invalidData1 = std::make_shared<ResData>(-1, -1, payload1);
1128 bool ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(invalidData1);
1129 EXPECT_FALSE(ret);
1130
1131 nlohmann::json payload2;
1132 payload2["uid"] = "10010";
1133 std::shared_ptr<ResData> validData1 = std::make_shared<ResData>(-1, -1, payload2);
1134 AppKeyMessage appMsg(2, "qq");
1135 SocPerfPlugin::GetInstance().uidToAppMsgMap_[10010] = appMsg;
1136 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(validData1);
1137 EXPECT_TRUE(ret);
1138
1139 nlohmann::json payload3;
1140 payload3["uid"] = "10011";
1141 std::shared_ptr<ResData> invalidData2 = std::make_shared<ResData>(-1, -1, payload3);
1142 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(invalidData2);
1143 EXPECT_FALSE(ret);
1144
1145 payload3["bundleName"] = "wechat";
1146 std::shared_ptr<ResData> validData2 = std::make_shared<ResData>(-1, -1, payload3);
1147 SocPerfPlugin::GetInstance().reqAppTypeFunc_ = nullptr;
1148 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(validData2);
1149 EXPECT_FALSE(ret);
1150
__anon43d9d7330302(const std::string& bundleName) 1151 SocPerfPlugin::GetInstance().reqAppTypeFunc_ = [](const std::string& bundleName) { return -1; };
1152 ret = SocPerfPlugin::GetInstance().UpdateUidToAppMsgMap(validData2);
1153 EXPECT_TRUE(ret);
1154 SocPerfPlugin::GetInstance().uidToAppMsgMap_.clear();
1155 }
1156 } // namespace SOCPERF
1157 } // namespace OHOS