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 #include "socperf_plugin.h"
24 
25 using namespace testing::ext;
26 using namespace testing::mt;
27 
28 namespace OHOS {
29 namespace ResourceSchedule {
30 namespace {
31     std::string SOCPERF_PLUBIN_LIB_NAME = "libsocperf_plugin.z.so";
32     std::string ERROR_LIB_NAME = "";
33     using OnPluginInitFunc = bool (*)(std::string& libName);
34     using OnPluginDisableFunc = void (*)();
35     using OnDispatchResourceFunc = void (*)(const std::shared_ptr<ResData>& data);
36 }
37 class SocPerfPluginTest : public testing::Test {
38 public:
39     static void SetUpTestCase(void);
40     static void TearDownTestCase(void);
41     void SetUp();
42     void TearDown();
43 };
44 
SetUpTestCase(void)45 void SocPerfPluginTest::SetUpTestCase(void)
46 {
47     SocPerfPlugin::GetInstance().Init();
48 }
49 
TearDownTestCase(void)50 void SocPerfPluginTest::TearDownTestCase(void)
51 {
52     SocPerfPlugin::GetInstance().Disable();
53 }
54 
SetUp(void)55 void SocPerfPluginTest::SetUp(void)
56 {
57 }
58 
TearDown(void)59 void SocPerfPluginTest::TearDown(void)
60 {
61 }
62 
63 /*
64  * @tc.name: SocPerfPluginTest_LibTest_001
65  * @tc.desc: test socperfplugin lib
66  * @tc.type FUNC
67  * @tc.require: issueI78T3V
68  */
69 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_LibTest_001, Function | MediumTest | Level0)
70 {
71     auto handle = dlopen(SOCPERF_PLUBIN_LIB_NAME.c_str(), RTLD_NOW);
72     EXPECT_NE(handle, nullptr);
73     OnPluginInitFunc onPluginInitFunc = reinterpret_cast<OnPluginInitFunc>(dlsym(handle, "OnPluginInit"));
74     EXPECT_NE(onPluginInitFunc, nullptr);
75     EXPECT_TRUE(onPluginInitFunc(SOCPERF_PLUBIN_LIB_NAME));
76     EXPECT_FALSE(onPluginInitFunc(ERROR_LIB_NAME));
77     OnPluginDisableFunc onPluginDisableFunc = reinterpret_cast<OnPluginDisableFunc>(dlsym(handle, "OnPluginDisable"));
78     EXPECT_NE(onPluginDisableFunc, nullptr);
79     onPluginDisableFunc();
80     OnDispatchResourceFunc onDispatchResourceFunc = reinterpret_cast<OnDispatchResourceFunc>(dlsym(handle,
81         "OnDispatchResource"));
82     EXPECT_NE(onDispatchResourceFunc, nullptr);
83     const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_APP_ABILITY_START,
84         ResType::AppStartType::APP_COLD_START, nullptr);
85     onDispatchResourceFunc(data);
86     const std::shared_ptr<ResData>& dataInvalid = std::make_shared<ResData>(-1, -1, nullptr);
87     onDispatchResourceFunc(dataInvalid);
88     SUCCEED();
89 }
90 
91 /*
92  * @tc.name: SocPerfPluginTest_API_TEST_001
93  * @tc.desc: test socperfplugin api
94  * @tc.type FUNC
95  * @tc.require: issueI78T3V
96  */
97 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_001, Function | MediumTest | Level0)
98 {
99     const std::shared_ptr<ResData>& coldStartData = std::make_shared<ResData>(ResType::RES_TYPE_APP_ABILITY_START,
100         ResType::AppStartType::APP_COLD_START, nullptr);
101     SocPerfPlugin::GetInstance().HandleAppAbilityStart(coldStartData);
102     SocPerfPlugin::GetInstance().HandleAppAbilityStart(coldStartData);
103     const std::shared_ptr<ResData>& warmStartData = std::make_shared<ResData>(ResType::RES_TYPE_APP_ABILITY_START,
104         ResType::AppStartType::APP_WARM_START, nullptr);
105     SocPerfPlugin::GetInstance().HandleAppAbilityStart(warmStartData);
106     const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
107     SocPerfPlugin::GetInstance().HandleAppAbilityStart(invalidData);
108     SUCCEED();
109 }
110 
111 /*
112  * @tc.name: SocPerfPluginTest_API_TEST_002
113  * @tc.desc: test socperfplugin api
114  * @tc.type FUNC
115  * @tc.require: issueI78T3V
116  */
117 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_002, Function | MediumTest | Level0)
118 {
119     const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_WINDOW_FOCUS,
120         ResType::WindowFocusStatus::WINDOW_FOCUS, nullptr);
121     SocPerfPlugin::GetInstance().HandleWindowFocus(data);
122     const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
123     SocPerfPlugin::GetInstance().HandleWindowFocus(invalidData);
124     SUCCEED();
125 }
126 
127 /*
128  * @tc.name: SocPerfPluginTest_API_TEST_003
129  * @tc.desc: test socperfplugin api
130  * @tc.type FUNC
131  * @tc.require: issueI78T3V
132  */
133 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_003, Function | MediumTest | Level0)
134 {
135     const std::shared_ptr<ResData>& touchDownData = std::make_shared<ResData>(ResType::RES_TYPE_CLICK_RECOGNIZE,
136         ResType::ClickEventType::TOUCH_EVENT_DOWN, nullptr);
137     SocPerfPlugin::GetInstance().HandleEventClick(touchDownData);
138     const std::shared_ptr<ResData>& clickData = std::make_shared<ResData>(ResType::RES_TYPE_CLICK_RECOGNIZE,
139         ResType::ClickEventType::CLICK_EVENT, nullptr);
140     SocPerfPlugin::GetInstance().HandleEventClick(clickData);
141     const std::shared_ptr<ResData>& touchUpData = std::make_shared<ResData>(ResType::RES_TYPE_CLICK_RECOGNIZE,
142         ResType::ClickEventType::TOUCH_EVENT_UP, nullptr);
143     SocPerfPlugin::GetInstance().HandleEventClick(touchUpData);
144     const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
145     SocPerfPlugin::GetInstance().HandleEventClick(invalidData);
146     SUCCEED();
147 }
148 
149 /*
150  * @tc.name: SocPerfPluginTest_API_TEST_004
151  * @tc.desc: test socperfplugin api
152  * @tc.type FUNC
153  * @tc.require: issueI78T3V
154  */
155 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_004, Function | MediumTest | Level0)
156 {
157     const std::shared_ptr<ResData>& loadPageStartData = std::make_shared<ResData>(ResType::RES_TYPE_LOAD_PAGE,
158         ResType::LOAD_PAGE_START, nullptr);
159     SocPerfPlugin::GetInstance().HandleLoadPage(loadPageStartData);
160     SocPerfPlugin::GetInstance().HandleLoadPage(loadPageStartData);
161     const std::shared_ptr<ResData>& loadPageEndData = std::make_shared<ResData>(ResType::RES_TYPE_LOAD_PAGE,
162         ResType::LOAD_PAGE_COMPLETE, nullptr);
163     SocPerfPlugin::GetInstance().HandleLoadPage(loadPageEndData);
164     const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
165     SocPerfPlugin::GetInstance().HandleLoadPage(invalidData);
166     SUCCEED();
167 }
168 
169 /*
170  * @tc.name: SocPerfPluginTest_API_TEST_005
171  * @tc.desc: test socperfplugin api
172  * @tc.type FUNC
173  * @tc.require: issueI78T3V
174  */
175 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_005, Function | MediumTest | Level0)
176 {
177     const std::shared_ptr<ResData>& slideEventOnData = std::make_shared<ResData>(ResType::RES_TYPE_SLIDE_RECOGNIZE,
178         ResType::SlideEventStatus::SLIDE_EVENT_ON, nullptr);
179     SocPerfPlugin::GetInstance().HandleEventSlide(slideEventOnData);
180     const std::shared_ptr<ResData>& slideEventOffData = std::make_shared<ResData>(ResType::RES_TYPE_SLIDE_RECOGNIZE,
181         ResType::SlideEventStatus::SLIDE_EVENT_OFF, nullptr);
182     SocPerfPlugin::GetInstance().HandleEventSlide(slideEventOffData);
183     const std::shared_ptr<ResData>& slideNormalBeginData = std::make_shared<ResData>(ResType::RES_TYPE_SLIDE_RECOGNIZE,
184         ResType::SlideEventStatus::SLIDE_NORMAL_BEGIN, nullptr);
185     SocPerfPlugin::GetInstance().HandleEventSlide(slideNormalBeginData);
186     const std::shared_ptr<ResData>& slideNormalEndData = std::make_shared<ResData>(ResType::RES_TYPE_SLIDE_RECOGNIZE,
187         ResType::SlideEventStatus::SLIDE_NORMAL_END, nullptr);
188     SocPerfPlugin::GetInstance().HandleEventSlide(slideNormalEndData);
189     const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
190     SocPerfPlugin::GetInstance().HandleEventSlide(invalidData);
191     SUCCEED();
192 }
193 
194 /*
195  * @tc.name: SocPerfPluginTest_API_TEST_006
196  * @tc.desc: test socperfplugin api
197  * @tc.type FUNC
198  * @tc.require: issueI78T3V
199  */
200 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_006, Function | MediumTest | Level0)
201 {
202     const std::shared_ptr<ResData>& webGestureStartData = std::make_shared<ResData>(ResType::RES_TYPE_WEB_GESTURE,
203         ResType::WebGesture::WEB_GESTURE_START, nullptr);
204     SocPerfPlugin::GetInstance().HandleEventWebGesture(webGestureStartData);
205     const std::shared_ptr<ResData>& webGestureEndData = std::make_shared<ResData>(ResType::RES_TYPE_WEB_GESTURE,
206         ResType::WebGesture::WEB_GESTURE_END, nullptr);
207     SocPerfPlugin::GetInstance().HandleEventWebGesture(webGestureEndData);
208     SocPerfPlugin::GetInstance().HandleEventWebGesture(nullptr);
209     const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
210     SocPerfPlugin::GetInstance().HandleEventWebGesture(invalidData);
211     SUCCEED();
212 }
213 
214 /*
215  * @tc.name: SocPerfPluginTest_API_TEST_007
216  * @tc.desc: test socperfplugin api
217  * @tc.type FUNC
218  * @tc.require: issueI78T3V
219  */
220 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_007, Function | MediumTest | Level0)
221 {
222     const std::shared_ptr<ResData>& windowResizingData = std::make_shared<ResData>(ResType::RES_TYPE_RESIZE_WINDOW,
223         ResType::WindowResizeType::WINDOW_RESIZING, nullptr);
224     SocPerfPlugin::GetInstance().HandleResizeWindow(windowResizingData);
225     const std::shared_ptr<ResData>& webGestureEndData = std::make_shared<ResData>(ResType::RES_TYPE_WEB_GESTURE,
226         ResType::WindowResizeType::WINDOW_RESIZE_STOP, nullptr);
227     SocPerfPlugin::GetInstance().HandleResizeWindow(webGestureEndData);
228     SocPerfPlugin::GetInstance().HandleResizeWindow(nullptr);
229     const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
230     SocPerfPlugin::GetInstance().HandleResizeWindow(invalidData);
231     SUCCEED();
232 }
233 
234 /*
235  * @tc.name: SocPerfPluginTest_API_TEST_008
236  * @tc.desc: test socperfplugin api
237  * @tc.type FUNC
238  * @tc.require: issueI78T3V
239  */
240 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_008, Function | MediumTest | Level0)
241 {
242     const std::shared_ptr<ResData>& windowMovingData = std::make_shared<ResData>(ResType::RES_TYPE_MOVE_WINDOW,
243         ResType::WindowMoveType::WINDOW_MOVING, nullptr);
244     SocPerfPlugin::GetInstance().HandleMoveWindow(windowMovingData);
245     const std::shared_ptr<ResData>& windowMoveStop = std::make_shared<ResData>(ResType::RES_TYPE_MOVE_WINDOW,
246         ResType::WindowMoveType::WINDOW_MOVE_STOP, nullptr);
247     SocPerfPlugin::GetInstance().HandleMoveWindow(windowMoveStop);
248     SocPerfPlugin::GetInstance().HandleMoveWindow(nullptr);
249     const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
250     SocPerfPlugin::GetInstance().HandleMoveWindow(invalidData);
251     SUCCEED();
252 }
253 
254 /*
255  * @tc.name: SocPerfPluginTest_API_TEST_009
256  * @tc.desc: test socperfplugin api
257  * @tc.type FUNC
258  * @tc.require: issueI78T3V
259  */
260 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_009, Function | MediumTest | Level0)
261 {
262     const std::shared_ptr<ResData>& animationEndData = std::make_shared<ResData>(
263         ResType::RES_TYPE_SHOW_REMOTE_ANIMATION, ResType::ShowRemoteAnimationStatus::ANIMATION_END, nullptr);
264     SocPerfPlugin::GetInstance().HandleRemoteAnimation(animationEndData);
265     const std::shared_ptr<ResData>& animationBeginData = std::make_shared<ResData>(
266         ResType::RES_TYPE_SHOW_REMOTE_ANIMATION, ResType::ShowRemoteAnimationStatus::ANIMATION_BEGIN, nullptr);
267     SocPerfPlugin::GetInstance().HandleRemoteAnimation(animationBeginData);
268     const std::shared_ptr<ResData>& unlockEndData = std::make_shared<ResData>(
269         ResType::RES_TYPE_SHOW_REMOTE_ANIMATION, ResType::ShowRemoteAnimationStatus::ANIMATION_UNLOCK_END, nullptr);
270     SocPerfPlugin::GetInstance().HandleRemoteAnimation(unlockEndData);
271     const std::shared_ptr<ResData>& unlockBeginData = std::make_shared<ResData>(
272         ResType::RES_TYPE_SHOW_REMOTE_ANIMATION, ResType::ShowRemoteAnimationStatus::ANIMATION_UNLOCK_BEGIN, nullptr);
273     SocPerfPlugin::GetInstance().HandleRemoteAnimation(unlockBeginData);
274     SocPerfPlugin::GetInstance().HandleRemoteAnimation(animationEndData);
275     SocPerfPlugin::GetInstance().HandleRemoteAnimation(unlockEndData);
276     const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
277     SocPerfPlugin::GetInstance().HandleRemoteAnimation(invalidData);
278     SUCCEED();
279 }
280 
281 /*
282  * @tc.name: SocPerfPluginTest_API_TEST_010
283  * @tc.desc: test socperfplugin api
284  * @tc.type FUNC
285  * @tc.require: issueI78T3V
286  */
287 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_010, Function | MediumTest | Level0)
288 {
289     const std::shared_ptr<ResData>& dragStartData = std::make_shared<ResData>(ResType::RES_TYPE_DRAG_STATUS_BAR,
290         ResType::StatusBarDragStatus::DRAG_START, nullptr);
291     SocPerfPlugin::GetInstance().HandleDragStatusBar(dragStartData);
292     const std::shared_ptr<ResData>& dragEndData = std::make_shared<ResData>(ResType::RES_TYPE_DRAG_STATUS_BAR,
293         ResType::StatusBarDragStatus::DRAG_END, nullptr);
294     SocPerfPlugin::GetInstance().HandleDragStatusBar(dragEndData);
295     SocPerfPlugin::GetInstance().HandleDragStatusBar(nullptr);
296     const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
297     SocPerfPlugin::GetInstance().HandleDragStatusBar(invalidData);
298     SUCCEED();
299 }
300 
301 /*
302  * @tc.name: SocPerfPluginTest_API_TEST_011
303  * @tc.desc: test socperfplugin api
304  * @tc.type FUNC
305  * @tc.require: issueI78T3V
306  */
307 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_011, Function | MediumTest | Level0)
308 {
309     const std::shared_ptr<ResData>& webGestureMoveStartData = std::make_shared<ResData>(
310         ResType::RES_TYPE_WEB_GESTURE_MOVE, ResType::WebGestureMove::WEB_GESTURE_MOVE_START, nullptr);
311     SocPerfPlugin::GetInstance().HandleWebGestureMove(webGestureMoveStartData);
312     const std::shared_ptr<ResData>& webGestureMoveEndData = std::make_shared<ResData>(
313         ResType::RES_TYPE_WEB_GESTURE_MOVE, ResType::WebGestureMove::WEB_GESTURE_MOVE_END, nullptr);
314     SocPerfPlugin::GetInstance().HandleWebGestureMove(webGestureMoveEndData);
315     SocPerfPlugin::GetInstance().HandleWebGestureMove(nullptr);
316     const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
317     SocPerfPlugin::GetInstance().HandleWebGestureMove(invalidData);
318     SUCCEED();
319 }
320 
321 /*
322  * @tc.name: SocPerfPluginTest_API_TEST_012
323  * @tc.desc: test socperfplugin api
324  * @tc.type FUNC
325  * @tc.require: issueI78T3V
326  */
327 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_012, Function | MediumTest | Level0)
328 {
329     const std::shared_ptr<ResData>& webSlideNormalStartData = std::make_shared<ResData>(
330         ResType::RES_TYPE_WEB_SLIDE_NORMAL, ResType::WebSlideNormal::WEB_SLIDE_NORMAL_START, nullptr);
331     SocPerfPlugin::GetInstance().HandleWebSlideNormal(webSlideNormalStartData);
332     const std::shared_ptr<ResData>& webSlideNormalEndData = std::make_shared<ResData>(
333         ResType::RES_TYPE_WEB_SLIDE_NORMAL, ResType::WebSlideNormal::WEB_SLIDE_NORMAL_END, nullptr);
334     SocPerfPlugin::GetInstance().HandleWebSlideNormal(webSlideNormalEndData);
335     SocPerfPlugin::GetInstance().HandleWebSlideNormal(nullptr);
336     const std::shared_ptr<ResData>& invalidData = std::make_shared<ResData>(-1, -1, nullptr);
337     SocPerfPlugin::GetInstance().HandleWebSlideNormal(invalidData);
338     SUCCEED();
339 }
340 
341 /*
342  * @tc.name: SocPerfPluginTest_API_TEST_013
343  * @tc.desc: test socperfplugin api
344  * @tc.type FUNC
345  * @tc.require: issueI78T3V
346  */
347 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_013, Function | MediumTest | Level0)
348 {
349     const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_LOAD_URL, -1, nullptr);
350     SocPerfPlugin::GetInstance().HandleLoadUrl(data);
351     SUCCEED();
352 }
353 
354 /*
355  * @tc.name: SocPerfPluginTest_API_TEST_014
356  * @tc.desc: test socperfplugin api
357  * @tc.type FUNC
358  * @tc.require: issueI78T3V
359  */
360 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_014, Function | MediumTest | Level0)
361 {
362     const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_MOUSEWHEEL, -1, nullptr);
363     SocPerfPlugin::GetInstance().HandleMousewheel(data);
364     SUCCEED();
365 }
366 
367 /*
368  * @tc.name: SocPerfPluginTest_API_TEST_015
369  * @tc.desc: test socperfplugin api
370  * @tc.type FUNC
371  * @tc.require: issueI78T3V
372  */
373 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_015, Function | MediumTest | Level0)
374 {
375     const std::shared_ptr<ResData>& data = std::make_shared<ResData>(ResType::RES_TYPE_POP_PAGE, -1, nullptr);
376     SocPerfPlugin::GetInstance().HandlePopPage(data);
377     SUCCEED();
378 }
379 
380 /*
381  * @tc.name: SocPerfPluginTest_API_TEST_016
382  * @tc.desc: test socperfplugin api
383  * @tc.type FUNC
384  * @tc.require: issueI78T3V
385  */
386 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_016, Function | MediumTest | Level0)
387 {
388     std::shared_ptr<ResData> invalidValuedata = std::make_shared<ResData>(ResType::RES_TYPE_APP_STATE_CHANGE,
389         ResType::ProcessStatus::PROCESS_READY, nullptr);
390     bool ret = SocPerfPlugin::GetInstance().HandleAppStateChange(invalidValuedata);
391     EXPECT_FALSE(ret);
392 
393     nlohmann::json invalidPayload;
394     invalidPayload["extensionType"] = 0;
395     std::shared_ptr<ResData> invalidPayloadTypedata = std::make_shared<ResData>(ResType::RES_TYPE_APP_STATE_CHANGE,
396        ResType::ProcessStatus::PROCESS_CREATED, invalidPayload);
397     ret = SocPerfPlugin::GetInstance().HandleAppStateChange(invalidPayloadTypedata);
398     EXPECT_FALSE(ret);
399 
400     nlohmann::json payload;
401     payload["extensionType"] = 2;
402     std::shared_ptr<ResData> data = std::make_shared<ResData>(ResType::RES_TYPE_APP_STATE_CHANGE,
403         ResType::ProcessStatus::PROCESS_CREATED, payload);
404     ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
405     EXPECT_TRUE(ret);
406 
407     payload["extensionType"] = 255;
408     data->payload = payload;
409     ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
410     EXPECT_TRUE(ret);
411 
412     payload["extensionType"] = 256;
413     data->payload = payload;
414     ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
415     EXPECT_TRUE(ret);
416 
417     payload["extensionType"] = 500;
418     data->payload = payload;
419     ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
420     EXPECT_TRUE(ret);
421 
422     payload["extensionType"] = 600;
423     data->payload = payload;
424     ret = SocPerfPlugin::GetInstance().HandleAppStateChange(data);
425     EXPECT_FALSE(ret);
426 }
427 
428 /*
429  * @tc.name: SocPerfPluginTest_API_TEST_017
430  * @tc.desc: test socperfplugin api
431  * @tc.type FUNC
432  * @tc.require: issueI78T3V
433  */
434 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_017, Function | MediumTest | Level0)
435 {
436     nlohmann::json payload;
437     payload["deviceMode"] = "test";
438     std::shared_ptr<ResData> normalValuedata = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
439         ResType::DeviceModeStatus::MODE_ENTER, payload);
440     SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(normalValuedata);
441     SUCCEED();
442 
443     nlohmann::json payload2;
444     payload["test"] = "test";
445     std::shared_ptr<ResData> invalidPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
446         ResType::DeviceModeStatus::MODE_ENTER, payload2);
447     SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidPayload);
448     SUCCEED();
449 
450     nlohmann::json payload3;
451     payload["test"] = "test";
452     int64_t invalidType = 3;
453     std::shared_ptr<ResData> invalidValue = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
454         invalidType, payload3);
455     SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(invalidValue);
456     SUCCEED();
457 
458     nlohmann::json payload4;
459     payload["deviceMode"] = "";
460     std::shared_ptr<ResData> emptyPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
461         ResType::DeviceModeStatus::MODE_ENTER, payload4);
462     SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(emptyPayload);
463     SUCCEED();
464 
465     nlohmann::json payload5;
466     payload["deviceMode"] = "ABCEDFGHABCEDFGHABCEDFGHABCEDFGHABCEDFGHABCEDFGHABCEDFGHABCEDFGHZ";
467     std::shared_ptr<ResData> maxLenPayload = std::make_shared<ResData>(ResType::RES_TYPE_DEVICE_MODE_STATUS,
468         ResType::DeviceModeStatus::MODE_ENTER, payload5);
469     SocPerfPlugin::GetInstance().HandleDeviceModeStatusChange(maxLenPayload);
470     SUCCEED();
471 }
472 
473 /*
474  * @tc.name: SocPerfPluginTest_API_TEST_018
475  * @tc.desc: test socperfplugin api
476  * @tc.type FUNC
477  * @tc.require: issueI78T3V
478  */
479 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_018, Function | MediumTest | Level0)
480 {
481     const std::shared_ptr<ResData>& scbAnimationEndData = std::make_shared<ResData>(
482         SocPerfPlugin::GetInstance().RES_TYPE_SCENE_BOARD_ID,
483         ResType::ShowRemoteAnimationStatus::ANIMATION_END, nullptr);
484     bool ret = SocPerfPlugin::GetInstance().HandleSocperfSceneBoard(scbAnimationEndData);
485     EXPECT_TRUE(ret);
486     const std::shared_ptr<ResData>& scbAnimationBeginData = std::make_shared<ResData>(
487         SocPerfPlugin::GetInstance().RES_TYPE_SCENE_BOARD_ID,
488         ResType::ShowRemoteAnimationStatus::ANIMATION_BEGIN, nullptr);
489     ret = SocPerfPlugin::GetInstance().HandleSocperfSceneBoard(scbAnimationBeginData);
490     EXPECT_TRUE(ret);
491     ret = SocPerfPlugin::GetInstance().HandleSocperfSceneBoard(nullptr);
492     EXPECT_FALSE(ret);
493 }
494 
495 /*
496  * @tc.name: SocPerfPluginTest_API_TEST_019
497  * @tc.desc: test socperfplugin api
498  * @tc.type FUNC
499  * @tc.require: issueI78T3V
500  */
501 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_019, Function | MediumTest | Level0)
502 {
503     const std::shared_ptr<ResData>& ancoEvnetData = std::make_shared<ResData>(
504         ResType::RES_TYPE_ANCO_CUST, 1001, nullptr);
505     bool ret = SocPerfPlugin::GetInstance().HandleCustEvent(ancoEvnetData);
506     EXPECT_TRUE(ret);
507     const std::shared_ptr<ResData>& ancoEvnetDataInvalid = std::make_shared<ResData>(
508         ResType::RES_TYPE_ANCO_CUST, -1, nullptr);
509     ret = SocPerfPlugin::GetInstance().HandleCustEvent(ancoEvnetDataInvalid);
510     EXPECT_FALSE(ret);
511 }
512 
513 /*
514  * @tc.name: SocPerfPluginTest_API_TEST_020
515  * @tc.desc: test socperfplugin api
516  * @tc.type FUNC
517  * @tc.require: issueI78T3V
518  */
519 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_020, Function | MediumTest | Level0)
520 {
521     const std::shared_ptr<ResData>& socPerfCustEventBeginData = std::make_shared<ResData>(
522         ResType::RES_TYPE_SOCPERF_CUST_EVENT_BEGIN, 1001, nullptr);
523     bool ret = SocPerfPlugin::GetInstance().HandleCustEventBegin(socPerfCustEventBeginData);
524     EXPECT_TRUE(ret);
525     const std::shared_ptr<ResData>& socPerfCustEventBeginDataInvalid = std::make_shared<ResData>(
526         ResType::RES_TYPE_SOCPERF_CUST_EVENT_BEGIN, -1, nullptr);
527     ret = SocPerfPlugin::GetInstance().HandleCustEventBegin(socPerfCustEventBeginDataInvalid);
528     EXPECT_FALSE(ret);
529 }
530 
531 /*
532  * @tc.name: SocPerfPluginTest_API_TEST_021
533  * @tc.desc: test socperfplugin api
534  * @tc.type FUNC
535  * @tc.require: issueI78T3V
536  */
537 HWTEST_F(SocPerfPluginTest, SocPerfPluginTest_API_TEST_021, Function | MediumTest | Level0)
538 {
539     const std::shared_ptr<ResData>& socPerfCustEventEndData = std::make_shared<ResData>(
540         ResType::RES_TYPE_SOCPERF_CUST_EVENT_END, 1001, nullptr);
541     bool ret = SocPerfPlugin::GetInstance().HandleCustEventEnd(socPerfCustEventEndData);
542     EXPECT_TRUE(ret);
543     const std::shared_ptr<ResData>& socPerfCustEventEndDataInvalid = std::make_shared<ResData>(
544         ResType::RES_TYPE_SOCPERF_CUST_EVENT_END, -1, nullptr);
545     ret = SocPerfPlugin::GetInstance().HandleCustEventEnd(socPerfCustEventEndDataInvalid);
546     EXPECT_FALSE(ret);
547 }
548 } // namespace SOCPERF
549 } // namespace OHOS