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