1 /*
2 * Copyright (c) 2022-2025 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 #include "dscreen_source_handler_test.h"
17 #include "if_system_ability_manager.h"
18 #include "dscreen_source_load_callback.h"
19 #include "iservice_registry.h"
20 #include "dscreen_constants.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace DistributedHardware {
SetUpTestCase(void)27 void DScreenSourceHandlerTest::SetUpTestCase(void) {}
28
TearDownTestCase(void)29 void DScreenSourceHandlerTest::TearDownTestCase(void) {}
30
SetUp(void)31 void DScreenSourceHandlerTest::SetUp(void)
32 {
33 if (DScreenSourceHandler::GetInstance().sourceSvrRecipient_ == nullptr) {
34 DScreenSourceHandler::GetInstance().sourceSvrRecipient_ = new DScreenSourceHandler::DScreenSourceSvrRecipient();
35 }
36 DScreenSourceHandler::GetInstance().InitSource("2.0");
37 }
38
TearDown(void)39 void DScreenSourceHandlerTest::TearDown(void)
40 {
41 DScreenSourceHandler::GetInstance().ReleaseSource();
42 }
43
44 /**
45 * @tc.name: InitSource_001
46 * @tc.desc: Verify the InitSource function.
47 * @tc.type: FUNC
48 * @tc.require: Issue Number
49 */
50 HWTEST_F(DScreenSourceHandlerTest, InitSource_001, TestSize.Level1)
51 {
52 std::string params = "";
53 int32_t ret = DScreenSourceHandler::GetInstance().InitSource(params);
54 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
55 }
56
57 /**
58 * @tc.name: InitSource_002
59 * @tc.desc: Verify the InitSource function.
60 * @tc.type: FUNC
61 * @tc.require: Issue Number
62 */
63 HWTEST_F(DScreenSourceHandlerTest, InitSource_002, TestSize.Level1)
64 {
65 std::string params = "DScreenSourceHandlerTestDScreenSourceHandlerTestDScreenSourceHandlerTest \
66 DScreenSourceHandlerTestDScreenSourceHandlerTestDScreenSourceHandlerTestDScreenSourceHandlerTest \
67 DScreenSourceHandlerTestDScreenSourceHandlerTestDScreenSourceHandlerTestDScreenSourceHandlerTest \
68 DScreenSourceHandlerTestDScreenSourceHandlerTestDScreenSourceHandlerTestDScreenSourceHandlerTest";
69 int32_t ret = DScreenSourceHandler::GetInstance().InitSource(params);
70 EXPECT_EQ(DH_SUCCESS, ret);
71 }
72
73 /**
74 * @tc.name: FinishStartSA_001
75 * @tc.desc: Verify the FinishStartSA function.
76 * @tc.type: FUNC
77 * @tc.require: Issue Number
78 */
79 HWTEST_F(DScreenSourceHandlerTest, FinishStartSA_001, TestSize.Level1)
80 {
81 const std::string param = "";
82 sptr<IRemoteObject> remoteObject = nullptr;
83 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = nullptr;
84 DScreenSourceHandler::GetInstance().FinishStartSA(param, remoteObject);
85 EXPECT_EQ(DScreenSourceHandler::GetInstance().dScreenSourceProxy_, nullptr);
86 }
87
88 /**
89 * @tc.name: FinishStartSA_002
90 * @tc.desc: Verify the FinishStartSA function.
91 * @tc.type: FUNC
92 * @tc.require: Issue Number
93 */
94 HWTEST_F(DScreenSourceHandlerTest, FinishStartSA_002, TestSize.Level1)
95 {
96 const std::string param = "";
97 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
98 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
99 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = nullptr;
100 DScreenSourceHandler::GetInstance().sourceSvrRecipient_ = nullptr;
101 DScreenSourceHandler::GetInstance().FinishStartSA(param, remoteObject);
102 EXPECT_EQ(DScreenSourceHandler::GetInstance().dScreenSourceProxy_, nullptr);
103 }
104
105 /**
106 * @tc.name: RegisterDistributedHardware_001
107 * @tc.desc: Verify the RegisterDistributedHardware function.
108 * @tc.type: FUNC
109 * @tc.require: Issue Number
110 */
111 HWTEST_F(DScreenSourceHandlerTest, RegisterDistributedHardware_001, TestSize.Level1)
112 {
113 const std::string devId = "devId";
114 const std::string dhId = "dhId";
115 EnableParam param;
116 param.sinkVersion = "2.0";
117 param.sinkAttrs = "attrs";
118 std::string callbackParam = "callbackParam";
119 sptr<DScreenSourceLoadCallback> loadCallback(new DScreenSourceLoadCallback(callbackParam));
120 loadCallback->OnLoadSystemAbilitySuccess(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, nullptr);
121 std::shared_ptr<RegisterCallback> registerCallback = std::make_shared<RegisterCallbackTest>();
122 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
123 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
124 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject);
125 int32_t ret = DScreenSourceHandler::GetInstance().RegisterDistributedHardware(devId, dhId, param, registerCallback);
126 EXPECT_EQ(DH_SUCCESS, ret);
127
128 std::shared_ptr<UnregisterCallbackTest> unregisterCallback = std::make_shared<UnregisterCallbackTest>();
129 ret = DScreenSourceHandler::GetInstance().UnregisterDistributedHardware(devId, dhId, unregisterCallback);
130 EXPECT_EQ(DH_SUCCESS, ret);
131 }
132
133 /**
134 * @tc.name: RegisterDistributedHardware_002
135 * @tc.desc: Verify the RegisterDistributedHardware function.
136 * @tc.type: FUNC
137 * @tc.require: Issue Number
138 */
139 HWTEST_F(DScreenSourceHandlerTest, RegisterDistributedHardware_002, TestSize.Level1)
140 {
141 const std::string devId = "devId";
142 const std::string dhId = "dhId";
143 EnableParam param;
144 param.sinkVersion = "1";
145 param.sinkAttrs = "attrs";
146 std::string callbackParam = "callbackParam";
147 sptr<DScreenSourceLoadCallback> loadCallback(new DScreenSourceLoadCallback(callbackParam));
148 loadCallback->OnLoadSystemAbilitySuccess(DISTRIBUTED_HARDWARE_SCREEN_SINK_SA_ID, nullptr);
149 std::shared_ptr<RegisterCallback> callback = std::make_shared<RegisterCallbackTest>();
150 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = nullptr;
151 int32_t ret = DScreenSourceHandler::GetInstance().RegisterDistributedHardware(devId, dhId, param, callback);
152 EXPECT_EQ(ERR_DH_SCREEN_SA_SOURCEPROXY_NOT_INIT, ret);
153 }
154
155 /**
156 * @tc.name: RegisterDistributedHardware_003
157 * @tc.desc: Verify the RegisterDistributedHardware function.
158 * @tc.type: FUNC
159 * @tc.require: Issue Number
160 */
161 HWTEST_F(DScreenSourceHandlerTest, RegisterDistributedHardware_003, TestSize.Level1)
162 {
163 const std::string devId = "devId";
164 const std::string dhId = "dhId";
165 EnableParam param;
166 param.sinkVersion = "1";
167 param.sinkAttrs = "attrs";
168 std::shared_ptr<RegisterCallback> callback = std::make_shared<RegisterCallbackTest>();
169 DScreenSourceHandler::GetInstance().dScreenSourceCallback_ = nullptr;
170 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
171 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
172 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject);
173 int32_t ret = DScreenSourceHandler::GetInstance().RegisterDistributedHardware(devId, dhId, param, callback);
174 EXPECT_EQ(ERR_DH_SCREEN_SA_SOURCEPCALLBACK_NOT_INIT, ret);
175 }
176
177 /**
178 * @tc.name: RegisterDistributedHardware_004
179 * @tc.desc: Verify the RegisterDistributedHardware function.
180 * @tc.type: FUNC
181 * @tc.require: Issue Number
182 */
183 HWTEST_F(DScreenSourceHandlerTest, RegisterDistributedHardware_004, TestSize.Level1)
184 {
185 const std::string devId = "";
186 const std::string dhId = "";
187 EnableParam param;
188 param.sinkVersion = "1";
189 param.sinkAttrs = "attrs";
190 std::shared_ptr<RegisterCallback> callback = std::make_shared<RegisterCallbackTest>();
191 int32_t ret = DScreenSourceHandler::GetInstance().RegisterDistributedHardware(devId, dhId, param, callback);
192 EXPECT_EQ(ERR_DH_SCREEN_STRING_PARAM_EMPTY, ret);
193
194 const std::string dhId1 = "test";
195 ret = DScreenSourceHandler::GetInstance().RegisterDistributedHardware(dhId1, dhId, param, callback);
196 EXPECT_EQ(ERR_DH_SCREEN_STRING_PARAM_EMPTY, ret);
197 }
198
199 /**
200 * @tc.name: RegisterDistributedHardware_005
201 * @tc.desc: Verify the RegisterDistributedHardware function.
202 * @tc.type: FUNC
203 * @tc.require: Issue Number
204 */
205 HWTEST_F(DScreenSourceHandlerTest, RegisterDistributedHardware_005, TestSize.Level1)
206 {
207 const std::string devId = "devId";
208 const std::string dhId = "dhId";
209 EnableParam param;
210 param.sinkVersion = "1";
211 param.sinkAttrs = "attrs";
212 std::shared_ptr<RegisterCallback> callback = nullptr;
213 int32_t ret = DScreenSourceHandler::GetInstance().RegisterDistributedHardware(devId, dhId, param, callback);
214 EXPECT_EQ(ERR_DH_SCREEN_REGISTER_CALLBACK_NOT_INIT, ret);
215 }
216
217 /**
218 * @tc.name: RegisterDistributedHardware_006
219 * @tc.desc: Verify the RegisterDistributedHardware function.
220 * @tc.type: FUNC
221 * @tc.require: Issue Number
222 */
223 HWTEST_F(DScreenSourceHandlerTest, RegisterDistributedHardware_006, TestSize.Level1)
224 {
225 const std::string devId = "devIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevId \
226 devIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevId \
227 devIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevId \
228 devIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevId";
229 const std::string dhId = "dhId";
230 EnableParam param;
231 param.sinkVersion = "1";
232 param.sinkAttrs = "attrs";
233 std::shared_ptr<RegisterCallback> callback = std::make_shared<RegisterCallbackTest>();
234 if (DScreenSourceHandler::GetInstance().dScreenSourceCallback_ == nullptr) {
235 DScreenSourceHandler::GetInstance().dScreenSourceCallback_ = new (std::nothrow) DScreenSourceCallback();
236 }
237 ASSERT_NE(DScreenSourceHandler::GetInstance().dScreenSourceCallback_, nullptr);
238 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
239 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
240 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject);
241 int32_t ret = DScreenSourceHandler::GetInstance().RegisterDistributedHardware(devId, dhId, param, callback);
242 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
243 }
244
245 /**
246 * @tc.name: UnregisterDistributedHardware_001
247 * @tc.desc: Verify the UnregisterDistributedHardware function.
248 * @tc.type: FUNC
249 * @tc.require: Issue Number
250 */
251 HWTEST_F(DScreenSourceHandlerTest, UnregisterDistributedHardware_001, TestSize.Level1)
252 {
253 const std::string devId = "devId";
254 const std::string dhId = "dhId";
255 std::shared_ptr<UnregisterCallbackTest> callback = std::make_shared<UnregisterCallbackTest>();
256 if (DScreenSourceHandler::GetInstance().dScreenSourceCallback_ == nullptr) {
257 DScreenSourceHandler::GetInstance().dScreenSourceCallback_ = new (std::nothrow) DScreenSourceCallback();
258 }
259 ASSERT_NE(DScreenSourceHandler::GetInstance().dScreenSourceCallback_, nullptr);
260 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
261 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
262 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject);
263 int32_t ret = DScreenSourceHandler::GetInstance().UnregisterDistributedHardware(devId, dhId, callback);
264 EXPECT_EQ(DH_SUCCESS, ret);
265 }
266
267 /**
268 * @tc.name: UnregisterDistributedHardware_002
269 * @tc.desc: Verify the UnregisterDistributedHardware function.
270 * @tc.type: FUNC
271 * @tc.require: Issue Number
272 */
273 HWTEST_F(DScreenSourceHandlerTest, UnregisterDistributedHardware_002, TestSize.Level1)
274 {
275 const std::string devId = "";
276 const std::string dhId = "";
277 std::shared_ptr<UnregisterCallbackTest> callback = std::make_shared<UnregisterCallbackTest>();
278 int32_t ret = DScreenSourceHandler::GetInstance().UnregisterDistributedHardware(devId, dhId, callback);
279 EXPECT_EQ(ERR_DH_SCREEN_STRING_PARAM_EMPTY, ret);
280
281 const std::string dhId1 = "test";
282 ret = DScreenSourceHandler::GetInstance().UnregisterDistributedHardware(dhId1, dhId, callback);
283 EXPECT_EQ(ERR_DH_SCREEN_STRING_PARAM_EMPTY, ret);
284 }
285
286 /**
287 * @tc.name: UnregisterDistributedHardware_003
288 * @tc.desc: Verify the UnregisterDistributedHardware function.
289 * @tc.type: FUNC
290 * @tc.require: Issue Number
291 */
292 HWTEST_F(DScreenSourceHandlerTest, UnregisterDistributedHardware_003, TestSize.Level1)
293 {
294 const std::string devId = "devId";
295 const std::string dhId = "dhId";
296 std::shared_ptr<UnregisterCallbackTest> callback = nullptr;
297 int32_t ret = DScreenSourceHandler::GetInstance().UnregisterDistributedHardware(devId, dhId, callback);
298 EXPECT_EQ(ERR_DH_SCREEN_REGISTER_CALLBACK_NOT_INIT, ret);
299 }
300
301 /**
302 * @tc.name: UnregisterDistributedHardware_004
303 * @tc.desc: Verify the UnregisterDistributedHardware function.
304 * @tc.type: FUNC
305 * @tc.require: Issue Number
306 */
307 HWTEST_F(DScreenSourceHandlerTest, UnregisterDistributedHardware_004, TestSize.Level1)
308 {
309 const std::string devId = "devId";
310 const std::string dhId = "dhId";
311 DScreenSourceHandler::GetInstance().InitSource("DScreenSourceHandlerTest");
312 std::shared_ptr<UnregisterCallbackTest> callback = std::make_shared<UnregisterCallbackTest>();
313 DScreenSourceHandler::GetInstance().dScreenSourceCallback_ = nullptr;
314 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
315 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
316 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject);
317
318 int32_t ret = DScreenSourceHandler::GetInstance().UnregisterDistributedHardware(devId, dhId, callback);
319 EXPECT_EQ(ERR_DH_SCREEN_SA_SOURCEPCALLBACK_NOT_INIT, ret);
320 }
321
322 /**
323 * @tc.name: UnregisterDistributedHardware_005
324 * @tc.desc: Verify the UnregisterDistributedHardware function.
325 * @tc.type: FUNC
326 * @tc.require: Issue Number
327 */
328 HWTEST_F(DScreenSourceHandlerTest, UnregisterDistributedHardware_005, TestSize.Level1)
329 {
330 const std::string devId = "devId";
331 const std::string dhId = "dhId";
332 std::shared_ptr<UnregisterCallbackTest> callback = std::make_shared<UnregisterCallbackTest>();
333 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = nullptr;
334
335 int32_t ret = DScreenSourceHandler::GetInstance().UnregisterDistributedHardware(devId, dhId, callback);
336 EXPECT_EQ(ERR_DH_SCREEN_SA_SOURCEPROXY_NOT_INIT, ret);
337 }
338
339 /**
340 * @tc.name: UnregisterDistributedHardware_006
341 * @tc.desc: Verify the UnregisterDistributedHardware function.
342 * @tc.type: FUNC
343 * @tc.require: Issue Number
344 */
345 HWTEST_F(DScreenSourceHandlerTest, UnregisterDistributedHardware_006, TestSize.Level1)
346 {
347 const std::string devId = "devIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevId \
348 devIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevId \
349 devIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevId \
350 devIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevIddevId";
351 const std::string dhId = "dhId";
352 std::shared_ptr<UnregisterCallbackTest> callback = std::make_shared<UnregisterCallbackTest>();
353 if (DScreenSourceHandler::GetInstance().dScreenSourceCallback_ == nullptr) {
354 DScreenSourceHandler::GetInstance().dScreenSourceCallback_ = new (std::nothrow) DScreenSourceCallback();
355 }
356 ASSERT_NE(DScreenSourceHandler::GetInstance().dScreenSourceCallback_, nullptr);
357 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
358 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
359 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject);
360
361 int32_t ret = DScreenSourceHandler::GetInstance().UnregisterDistributedHardware(devId, dhId, callback);
362 EXPECT_EQ(ERR_DH_SCREEN_INPUT_PARAM_INVALID, ret);
363 }
364
365 /**
366 * @tc.name: ConfigDistributedHardware_001
367 * @tc.desc: Verify the ConfigDistributedHardware function.
368 * @tc.type: FUNC
369 * @tc.require: Issue Number
370 */
371 HWTEST_F(DScreenSourceHandlerTest, ConfigDistributedHardware_001, TestSize.Level1)
372 {
373 const std::string devId = "devId";
374 const std::string dhId = "dhId";
375 const std::string key = "key";
376 const std::string value = "value";
377
378 int32_t ret = DScreenSourceHandler::GetInstance().ConfigDistributedHardware(devId, dhId, key, value);
379 EXPECT_EQ(DH_SUCCESS, ret);
380 }
381
382 /**
383 * @tc.name: ReleaseSource_001
384 * @tc.desc: Verify the ReleaseSource function.
385 * @tc.type: FUNC
386 * @tc.require: Issue Number
387 */
388 HWTEST_F(DScreenSourceHandlerTest, ReleaseSource_001, TestSize.Level1)
389 {
390 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = nullptr;
391 int32_t ret = DScreenSourceHandler::GetInstance().ReleaseSource();
392 EXPECT_EQ(ERR_DH_SCREEN_SA_SOURCEPROXY_NOT_INIT, ret);
393 }
394
395 /**
396 * @tc.name: OnRemoteDied_001
397 * @tc.desc: Verify the OnRemoteDied function.
398 * @tc.type: FUNC
399 * @tc.require: Issue Number
400 */
401 HWTEST_F(DScreenSourceHandlerTest, OnRemoteDied_001, TestSize.Level1)
402 {
403 sptr<IRemoteObject> remoteObject1 = nullptr;
404 wptr<IRemoteObject> remote1(remoteObject1);
405 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = nullptr;
406 DScreenSourceHandler::GetInstance().sourceSvrRecipient_->OnRemoteDied(remote1);
407 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
408 sptr<IRemoteObject> remoteObject2 = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
409 wptr<IRemoteObject> remote2(remoteObject2);
410 DScreenSourceHandler::GetInstance().dScreenSourceProxy_ = iface_cast<IDScreenSource>(remoteObject2);
411 DScreenSourceHandler::GetInstance().sourceSvrRecipient_->OnRemoteDied(remote2);
412 EXPECT_EQ(nullptr, DScreenSourceHandler::GetInstance().dScreenSourceProxy_);
413 }
414
415 /**
416 * @tc.name: OnRemoteSourceSvrDied_001
417 * @tc.desc: Verify the OnRemoteSourceSvrDied function.
418 * @tc.type: FUNC
419 * @tc.require: Issue Number
420 */
421 HWTEST_F(DScreenSourceHandlerTest, OnRemoteSourceSvrDied_001, TestSize.Level1)
422 {
423 sptr<ISystemAbilityManager> samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
424 sptr<IRemoteObject> remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID);
425 wptr<IRemoteObject> remote(remoteObject);
426 DScreenSourceHandler::GetInstance().OnRemoteSourceSvrDied(remote);
427 EXPECT_EQ(nullptr, DScreenSourceHandler::GetInstance().dScreenSourceProxy_);
428 DScreenSourceHandler::GetInstance().OnRemoteSourceSvrDied(remote);
429 }
430 } // namespace DistributedHardware
431 } // namespace OHOS
432