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