1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 
17 #include <fstream>
18 #include <gtest/gtest.h>
19 
20 #include "input_event_handler.h"
21 #include "mmi_log.h"
22 #include "switch_subscriber_handler.h"
23 #include "uds_server.h"
24 
25 #undef MMI_LOG_TAG
26 #define MMI_LOG_TAG "SwitchSubscriberHandlerTest"
27 
28 namespace OHOS {
29 namespace MMI {
30 namespace {
31 using namespace testing::ext;
32 constexpr int32_t INVAID_VALUE = -1;
33 constexpr int32_t SUBSCRIBER_ID = 0;
34 constexpr int32_t POINTER_EVENT_TYPE = 3;
35 constexpr int32_t SESSION_MODULE_TYPE = 3;
36 constexpr int32_t SESSION_FD = -1;
37 constexpr int32_t SESSION_UID = 0;
38 constexpr int32_t SESSION_PID = 0;
39 } // namespace
40 
41 class SwitchSubscriberHandlerTest : public testing::Test {
42 public:
SetUpTestCase(void)43     static void SetUpTestCase(void) {}
TearDownTestCase(void)44     static void TearDownTestCase(void) {}
45 };
46 
47 /**
48  * @tc.name: SwitchSubscriberHandlerTest_HandleKeyEvent_001
49  * @tc.desc: Test HandleKeyEvent
50  * @tc.type: FUNC
51  * @tc.require:
52  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_HandleKeyEvent_001, TestSize.Level1)53 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_HandleKeyEvent_001, TestSize.Level1)
54 {
55     auto keyEvent = KeyEvent::Create();
56     ASSERT_NE(keyEvent, nullptr);
57     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
58     ASSERT_NE(switchSubscriberHandler, nullptr);
59     auto nextSwitchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
60     ASSERT_NE(nextSwitchSubscriberHandler, nullptr);
61 
62     switchSubscriberHandler->HandleKeyEvent(nullptr);
63     switchSubscriberHandler->HandleKeyEvent(keyEvent);
64     switchSubscriberHandler->nextHandler_ = nextSwitchSubscriberHandler;
65     switchSubscriberHandler->HandleKeyEvent(keyEvent);
66 }
67 
68 /**
69  * @tc.name: SwitchSubscriberHandlerTest_HandlePointerEvent_001
70  * @tc.desc: Test HandlePointerEvent
71  * @tc.type: FUNC
72  * @tc.require:
73  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_HandlePointerEvent_001, TestSize.Level1)74 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_HandlePointerEvent_001, TestSize.Level1)
75 {
76     auto pointerEvent = std::make_shared<PointerEvent>(POINTER_EVENT_TYPE);
77     ASSERT_NE(pointerEvent, nullptr);
78     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
79     ASSERT_NE(switchSubscriberHandler, nullptr);
80     auto nextSwitchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
81     ASSERT_NE(nextSwitchSubscriberHandler, nullptr);
82 
83     switchSubscriberHandler->HandlePointerEvent(nullptr);
84     switchSubscriberHandler->HandlePointerEvent(pointerEvent);
85     switchSubscriberHandler->nextHandler_ = nextSwitchSubscriberHandler;
86     switchSubscriberHandler->HandlePointerEvent(pointerEvent);
87 }
88 
89 /**
90  * @tc.name: SwitchSubscriberHandlerTest_HandleTouchEvent_001
91  * @tc.desc: Test HandleTouchEvent
92  * @tc.type: FUNC
93  * @tc.require:
94  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_HandleTouchEvent_001, TestSize.Level1)95 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_HandleTouchEvent_001, TestSize.Level1)
96 {
97     auto pointerEvent = std::make_shared<PointerEvent>(POINTER_EVENT_TYPE);
98     ASSERT_NE(pointerEvent, nullptr);
99     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
100     ASSERT_NE(switchSubscriberHandler, nullptr);
101     auto nextSwitchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
102     ASSERT_NE(nextSwitchSubscriberHandler, nullptr);
103 
104     switchSubscriberHandler->HandleTouchEvent(nullptr);
105     switchSubscriberHandler->HandleTouchEvent(pointerEvent);
106     switchSubscriberHandler->nextHandler_ = nextSwitchSubscriberHandler;
107     switchSubscriberHandler->HandleTouchEvent(pointerEvent);
108 }
109 
110 /**
111  * @tc.name: SwitchSubscriberHandlerTest_HandleSwitchEvent_001
112  * @tc.desc: Test HandleSwitchEvent
113  * @tc.type: FUNC
114  * @tc.require:
115  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_HandleSwitchEvent_001, TestSize.Level1)116 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_HandleSwitchEvent_001, TestSize.Level1)
117 {
118     auto switchEvent = std::make_shared<SwitchEvent>(INVAID_VALUE);
119     ASSERT_NE(switchEvent, nullptr);
120     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
121     ASSERT_NE(switchSubscriberHandler, nullptr);
122     auto nextSwitchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
123     ASSERT_NE(nextSwitchSubscriberHandler, nullptr);
124 
125     switchSubscriberHandler->HandleSwitchEvent(nullptr);
126     switchEvent->SetSwitchType(SwitchEvent::SwitchType::SWITCH_PRIVACY);
127     switchEvent->SetSwitchValue(SwitchEvent::SWITCH_ON);
128     switchSubscriberHandler->HandleSwitchEvent(switchEvent);
129     switchSubscriberHandler->nextHandler_ = nextSwitchSubscriberHandler;
130     switchSubscriberHandler->HandleSwitchEvent(switchEvent);
131 
132     auto sess = std::make_shared<UDSSession>(
133         "switch_subscriber_handler_test", SESSION_MODULE_TYPE, SESSION_FD, SESSION_UID, SESSION_PID);
134     ASSERT_NE(sess, nullptr);
135     auto subscriber = std::make_shared<SwitchSubscriberHandler::Subscriber>(
136         SUBSCRIBER_ID, sess, SwitchEvent::SwitchType::SWITCH_PRIVACY);
137     ASSERT_NE(subscriber, nullptr);
138 
139     switchSubscriberHandler->InsertSubScriber(subscriber);
140     switchSubscriberHandler->HandleSwitchEvent(switchEvent);
141 }
142 
143 /**
144  * @tc.name: SwitchSubscriberHandlerTest_SubscribeSwitchEvent_001
145  * @tc.desc: Test SubscribeSwitchEvent
146  * @tc.type: FUNC
147  * @tc.require:
148  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_SubscribeSwitchEvent_001, TestSize.Level1)149 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_SubscribeSwitchEvent_001, TestSize.Level1)
150 {
151     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
152     ASSERT_NE(switchSubscriberHandler, nullptr);
153 
154     ASSERT_EQ(switchSubscriberHandler->SubscribeSwitchEvent(
155         nullptr, INVAID_VALUE, SwitchEvent::SwitchType::SWITCH_DEFAULT), RET_ERR);
156     ASSERT_EQ(switchSubscriberHandler->SubscribeSwitchEvent(nullptr, SUBSCRIBER_ID, INVAID_VALUE), RET_ERR);
157     ASSERT_EQ(switchSubscriberHandler->SubscribeSwitchEvent(
158         nullptr, SUBSCRIBER_ID, SwitchEvent::SwitchType::SWITCH_DEFAULT), ERROR_NULL_POINTER);
159     auto sess = std::make_shared<UDSSession>(
160         "switch_subscriber_handler_test", SESSION_MODULE_TYPE, SESSION_FD, SESSION_UID, SESSION_PID);
161     ASSERT_NE(sess, nullptr);
162 
163     ASSERT_EQ(switchSubscriberHandler->SubscribeSwitchEvent(
164         sess, SUBSCRIBER_ID, SwitchEvent::SwitchType::SWITCH_PRIVACY), RET_OK);
165 }
166 
167 /**
168  * @tc.name: SwitchSubscriberHandlerTest_UnsubscribeSwitchEvent_001
169  * @tc.desc: Test UnsubscribeSwitchEvent
170  * @tc.type: FUNC
171  * @tc.require:
172  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_UnsubscribeSwitchEvent_001, TestSize.Level1)173 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_UnsubscribeSwitchEvent_001, TestSize.Level1)
174 {
175     auto firstSess = std::make_shared<UDSSession>(
176         "switch_subscriber_handler_test", SESSION_MODULE_TYPE, SESSION_FD, SESSION_UID, SESSION_PID);
177     ASSERT_NE(firstSess, nullptr);
178     auto secondSess = std::make_shared<UDSSession>(
179         "switch_subscriber_handler_test", SESSION_MODULE_TYPE, SESSION_FD, SESSION_UID, SESSION_PID);
180     ASSERT_NE(secondSess, nullptr);
181     auto switchEvent = std::make_shared<SwitchEvent>(SwitchEvent::SwitchType::SWITCH_DEFAULT);
182     ASSERT_NE(switchEvent, nullptr);
183     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
184     ASSERT_NE(switchSubscriberHandler, nullptr);
185 
186     switchEvent->SetSwitchType(SwitchEvent::SwitchType::SWITCH_LID);
187     switchEvent->SetSwitchValue(SwitchEvent::SWITCH_ON);
188 
189     ASSERT_EQ(switchSubscriberHandler->UnsubscribeSwitchEvent(firstSess, SUBSCRIBER_ID), RET_ERR);
190     ASSERT_EQ(switchSubscriberHandler->SubscribeSwitchEvent(firstSess, SUBSCRIBER_ID,
191         SwitchEvent::SwitchType::SWITCH_DEFAULT), RET_OK);
192     ASSERT_EQ(switchSubscriberHandler->SubscribeSwitchEvent(secondSess, SUBSCRIBER_ID,
193         SwitchEvent::SwitchType::SWITCH_DEFAULT), RET_OK);
194     ASSERT_EQ(switchSubscriberHandler->UnsubscribeSwitchEvent(firstSess, SUBSCRIBER_ID), RET_OK);
195     ASSERT_EQ(switchSubscriberHandler->UnsubscribeSwitchEvent(firstSess, SUBSCRIBER_ID), RET_ERR);
196 }
197 
198 /**
199  * @tc.name: SwitchSubscriberHandlerTest_OnSubscribeSwitchEvent_001
200  * @tc.desc: Test OnSubscribeSwitchEvent
201  * @tc.type: FUNC
202  * @tc.require:
203  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_OnSubscribeSwitchEvent_001, TestSize.Level1)204 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_OnSubscribeSwitchEvent_001, TestSize.Level1)
205 {
206     auto sess = std::make_shared<UDSSession>(
207         "switch_subscriber_handler_test", SESSION_MODULE_TYPE, SESSION_FD, SESSION_UID, SESSION_PID);
208     ASSERT_NE(sess, nullptr);
209     auto switchEvent = std::make_shared<SwitchEvent>(SwitchEvent::SwitchType::SWITCH_DEFAULT);
210     ASSERT_NE(switchEvent, nullptr);
211     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
212     ASSERT_NE(switchSubscriberHandler, nullptr);
213 
214     switchEvent->SetSwitchType(SwitchEvent::SwitchType::SWITCH_PRIVACY);
215     switchEvent->SetSwitchValue(SwitchEvent::SWITCH_ON);
216     switchEvent->SetSwitchMask(INVAID_VALUE);
217     switchEvent->GetSwitchMask();
218 
219     ASSERT_EQ(switchSubscriberHandler->OnSubscribeSwitchEvent(nullptr), false);
220     ASSERT_EQ(switchSubscriberHandler->SubscribeSwitchEvent(sess, SUBSCRIBER_ID,
221         SwitchEvent::SwitchType::SWITCH_PRIVACY), RET_OK);
222     ASSERT_EQ(switchSubscriberHandler->OnSubscribeSwitchEvent(switchEvent), true);
223     ASSERT_EQ(switchSubscriberHandler->UnsubscribeSwitchEvent(sess, SUBSCRIBER_ID), RET_OK);
224 }
225 
226 /**
227  * @tc.name: SwitchSubscriberHandlerTest_OnSubscribeSwitchEvent_002
228  * @tc.desc: Test OnSubscribeSwitchEvent
229  * @tc.type: FUNC
230  * @tc.require:
231  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_OnSubscribeSwitchEvent_002, TestSize.Level1)232 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_OnSubscribeSwitchEvent_002, TestSize.Level1)
233 {
234     auto sess = std::make_shared<UDSSession>(
235         "switch_subscriber_handler_test", SESSION_MODULE_TYPE, SESSION_FD, SESSION_UID, SESSION_PID);
236     ASSERT_NE(sess, nullptr);
237     auto switchEvent = std::make_shared<SwitchEvent>(SwitchEvent::SwitchType::SWITCH_DEFAULT);
238     ASSERT_NE(switchEvent, nullptr);
239     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
240     ASSERT_NE(switchSubscriberHandler, nullptr);
241 
242     switchEvent->SetSwitchType(SwitchEvent::SwitchType::SWITCH_LID);
243     switchEvent->SetSwitchValue(SwitchEvent::SWITCH_ON);
244 
245     ASSERT_EQ(switchSubscriberHandler->SubscribeSwitchEvent(sess, SUBSCRIBER_ID,
246         SwitchEvent::SwitchType::SWITCH_DEFAULT), RET_OK);
247     ASSERT_EQ(switchSubscriberHandler->OnSubscribeSwitchEvent(switchEvent), true);
248     ASSERT_EQ(switchSubscriberHandler->UnsubscribeSwitchEvent(sess, SUBSCRIBER_ID), RET_OK);
249 }
250 
251 /**
252  * @tc.name: SwitchSubscriberHandlerTest_OnSubscribeSwitchEvent_003
253  * @tc.desc: Test OnSubscribeSwitchEvent
254  * @tc.type: FUNC
255  * @tc.require:
256  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_OnSubscribeSwitchEvent_003, TestSize.Level1)257 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_OnSubscribeSwitchEvent_003, TestSize.Level1)
258 {
259     auto sess = std::make_shared<UDSSession>(
260         "switch_subscriber_handler_test", SESSION_MODULE_TYPE, SESSION_FD, SESSION_UID, SESSION_PID);
261     ASSERT_NE(sess, nullptr);
262     auto switchEvent = std::make_shared<SwitchEvent>(SwitchEvent::SwitchType::SWITCH_DEFAULT);
263     ASSERT_NE(switchEvent, nullptr);
264     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
265     ASSERT_NE(switchSubscriberHandler, nullptr);
266 
267     switchEvent->SetSwitchType(SwitchEvent::SwitchType::SWITCH_PRIVACY);
268     switchEvent->SetSwitchValue(SwitchEvent::SWITCH_ON);
269 
270     ASSERT_EQ(switchSubscriberHandler->SubscribeSwitchEvent(sess, SUBSCRIBER_ID,
271         SwitchEvent::SwitchType::SWITCH_DEFAULT), RET_OK);
272     ASSERT_EQ(switchSubscriberHandler->OnSubscribeSwitchEvent(switchEvent), false);
273     ASSERT_EQ(switchSubscriberHandler->UnsubscribeSwitchEvent(sess, SUBSCRIBER_ID), RET_OK);
274 }
275 
276 /**
277  * @tc.name: SwitchSubscriberHandlerTest_InsertSubScriber_001
278  * @tc.desc: Test InsertSubScriber
279  * @tc.type: FUNC
280  * @tc.require:
281  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_InsertSubScriber_001, TestSize.Level1)282 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_InsertSubScriber_001, TestSize.Level1)
283 {
284     auto sess = std::make_shared<UDSSession>(
285         "switch_subscriber_handler_test", SESSION_MODULE_TYPE, SESSION_FD, SESSION_UID, SESSION_PID);
286     ASSERT_NE(sess, nullptr);
287     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
288     ASSERT_NE(switchSubscriberHandler, nullptr);
289     auto subscriber = std::make_shared<SwitchSubscriberHandler::Subscriber>(
290         SUBSCRIBER_ID, sess, SwitchEvent::SwitchType::SWITCH_PRIVACY);
291     ASSERT_NE(subscriber, nullptr);
292     auto repeatSubscriber = std::make_shared<SwitchSubscriberHandler::Subscriber>(
293         SUBSCRIBER_ID, sess, SwitchEvent::SwitchType::SWITCH_PRIVACY);
294     ASSERT_NE(repeatSubscriber, nullptr);
295 
296     switchSubscriberHandler->InsertSubScriber(nullptr);
297     switchSubscriberHandler->InsertSubScriber(subscriber);
298     switchSubscriberHandler->InsertSubScriber(repeatSubscriber);
299     repeatSubscriber->sess_ = nullptr;
300     switchSubscriberHandler->InsertSubScriber(repeatSubscriber);
301 }
302 
303 /**
304  * @tc.name: SwitchSubscriberHandlerTest_OnSessionDelete_001
305  * @tc.desc: Test OnSessionDelete
306  * @tc.type: FUNC
307  * @tc.require:
308  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_OnSessionDelete_001, TestSize.Level1)309 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_OnSessionDelete_001, TestSize.Level1)
310 {
311     auto firstSess = std::make_shared<UDSSession>(
312         "switch_subscriber_handler_test", SESSION_MODULE_TYPE, SESSION_FD, SESSION_UID, SESSION_PID);
313     ASSERT_NE(firstSess, nullptr);
314     auto secondSess = std::make_shared<UDSSession>(
315         "switch_subscriber_handler_test", SESSION_MODULE_TYPE, SESSION_FD, SESSION_UID, SESSION_PID);
316     ASSERT_NE(secondSess, nullptr);
317     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
318     ASSERT_NE(switchSubscriberHandler, nullptr);
319     auto firstSubscriber = std::make_shared<SwitchSubscriberHandler::Subscriber>(
320         SUBSCRIBER_ID, firstSess, SwitchEvent::SwitchType::SWITCH_PRIVACY);
321     ASSERT_NE(firstSubscriber, nullptr);
322     auto secondSubscriber = std::make_shared<SwitchSubscriberHandler::Subscriber>(
323         SUBSCRIBER_ID, secondSess, SwitchEvent::SwitchType::SWITCH_PRIVACY);
324     ASSERT_NE(secondSubscriber, nullptr);
325 
326     switchSubscriberHandler->OnSessionDelete(firstSess);
327     switchSubscriberHandler->InsertSubScriber(firstSubscriber);
328     switchSubscriberHandler->InsertSubScriber(secondSubscriber);
329     switchSubscriberHandler->OnSessionDelete(nullptr);
330     switchSubscriberHandler->OnSessionDelete(secondSess);
331 }
332 
333 /**
334  * @tc.name: SwitchSubscriberHandlerTest_NotifySubscriber_001
335  * @tc.desc: Test NotifySubscriber
336  * @tc.type: FUNC
337  * @tc.require:
338  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_NotifySubscriber_001, TestSize.Level1)339 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_NotifySubscriber_001, TestSize.Level1)
340 {
341     auto switchEvent = std::make_shared<SwitchEvent>(SwitchEvent::SwitchType::SWITCH_DEFAULT);
342     ASSERT_NE(switchEvent, nullptr);
343     auto sess = std::make_shared<UDSSession>(
344         "switch_subscriber_handler_test", SESSION_MODULE_TYPE, SESSION_FD, SESSION_UID, SESSION_PID);
345     ASSERT_NE(sess, nullptr);
346     auto subscriber = std::make_shared<SwitchSubscriberHandler::Subscriber>(
347         SUBSCRIBER_ID, sess, SwitchEvent::SwitchType::SWITCH_PRIVACY);
348     ASSERT_NE(subscriber, nullptr);
349     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
350     ASSERT_NE(switchSubscriberHandler, nullptr);
351 
352     switchSubscriberHandler->NotifySubscriber(nullptr, subscriber);
353     switchSubscriberHandler->NotifySubscriber(switchEvent, nullptr);
354     switchSubscriberHandler->NotifySubscriber(switchEvent, subscriber);
355 
356     UDSServer udsServer;
357     InputHandler->udsServer_ = &udsServer;
358     switchSubscriberHandler->NotifySubscriber(switchEvent, subscriber);
359     subscriber->sess_ = nullptr;
360     switchSubscriberHandler->NotifySubscriber(switchEvent, subscriber);
361     InputHandler->udsServer_ = nullptr;
362 }
363 
364 /**
365  * @tc.name: SwitchSubscriberHandlerTest_InitSessionDeleteCallback_001
366  * @tc.desc: Test InitSessionDeleteCallback
367  * @tc.type: FUNC
368  * @tc.require:
369  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_InitSessionDeleteCallback_001, TestSize.Level1)370 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_InitSessionDeleteCallback_001, TestSize.Level1)
371 {
372     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
373     ASSERT_NE(switchSubscriberHandler, nullptr);
374 
375     ASSERT_EQ(switchSubscriberHandler->InitSessionDeleteCallback(), false);
376 
377     UDSServer udsServer;
378     InputHandler->udsServer_ = &udsServer;
379     ASSERT_EQ(switchSubscriberHandler->InitSessionDeleteCallback(), true);
380     ASSERT_EQ(switchSubscriberHandler->InitSessionDeleteCallback(), true);
381     InputHandler->udsServer_ = nullptr;
382 }
383 
384 /**
385  * @tc.name: SwitchSubscriberHandlerTest_Dump_001
386  * @tc.desc: Test Dump
387  * @tc.type: FUNC
388  * @tc.require:
389  */
HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_Dump_001, TestSize.Level1)390 HWTEST_F(SwitchSubscriberHandlerTest, SwitchSubscriberHandlerTest_Dump_001, TestSize.Level1)
391 {
392     auto sess = std::make_shared<UDSSession>(
393         "switch_subscriber_handler_test", SESSION_MODULE_TYPE, SESSION_FD, SESSION_UID, SESSION_PID);
394     ASSERT_NE(sess, nullptr);
395     auto subscriber = std::make_shared<SwitchSubscriberHandler::Subscriber>(
396         SUBSCRIBER_ID, sess, SwitchEvent::SwitchType::SWITCH_PRIVACY);
397     ASSERT_NE(subscriber, nullptr);
398     auto switchSubscriberHandler = std::make_shared<SwitchSubscriberHandler>();
399     ASSERT_NE(switchSubscriberHandler, nullptr);
400 
401     switchSubscriberHandler->InsertSubScriber(subscriber);
402 
403     std::vector<std::string> args;
404     args.push_back("args0");
405     args.push_back("args1");
406 
407     switchSubscriberHandler->Dump(INVAID_VALUE, args);
408 }
409 
410 } // namespace MMI
411 } // namespace OHOS
412