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