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 sinkDev_ 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 "daudio_sink_dev_test.h"
17
18 #include "audio_event.h"
19 #include "daudio_constants.h"
20 #include "daudio_errorcode.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace DistributedHardware {
SetUpTestCase(void)26 void DAudioSinkDevTest::SetUpTestCase(void) {}
27
TearDownTestCase(void)28 void DAudioSinkDevTest::TearDownTestCase(void) {}
29
SetUp()30 void DAudioSinkDevTest::SetUp()
31 {
32 std::string networkId = "networkId";
33 sinkDev_ = std::make_shared<DAudioSinkDev>(networkId);
34 }
35
TearDown()36 void DAudioSinkDevTest::TearDown()
37 {
38 sinkDev_ = nullptr;
39 }
40
41 /**
42 * @tc.name: InitAVTransEngines_001
43 * @tc.desc: Verify the InitAVTransEngines function.
44 * @tc.type: FUNC
45 * @tc.require: AR000H0E5F
46 */
47 HWTEST_F(DAudioSinkDevTest, InitAVTransEngines_001, TestSize.Level1)
48 {
49 std::shared_ptr<IAVEngineProvider> senderPtr = std::make_shared<IAVEngineProvider>();
50 std::shared_ptr<IAVEngineProvider> receiverPtr = std::make_shared<IAVEngineProvider>();
51 ChannelState type = ChannelState::UNKNOWN;
52
53 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->InitAVTransEngines(type, receiverPtr.get()));
54 type = ChannelState::MIC_CONTROL_OPENED;
55 EXPECT_EQ(DH_SUCCESS, sinkDev_->InitAVTransEngines(type, senderPtr.get()));
56 type = ChannelState::SPK_CONTROL_OPENED;
57 EXPECT_EQ(DH_SUCCESS, sinkDev_->InitAVTransEngines(type, receiverPtr.get()));
58 }
59
60 /**
61 * @tc.name: TaskPlayStatusChange_001
62 * @tc.desc: Verify the TaskPlayStatusChange function.
63 * @tc.type: FUNC
64 * @tc.require: AR000H0E5F
65 */
66 HWTEST_F(DAudioSinkDevTest, TaskPlayStatusChange_001, TestSize.Level1)
67 {
68 sinkDev_->speakerClient_ = nullptr;
69 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskPlayStatusChange(""));
70
71 std::string devId = "devid";
72 sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, sinkDev_);
73 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskPlayStatusChange(AUDIO_EVENT_PAUSE));
74 }
75
76 /**
77 * @tc.name: TaskOpenCtrlChannel_001
78 * @tc.desc: Verify the TaskOpenCtrlChannel function.
79 * @tc.type: FUNC
80 * @tc.require: AR000H0E5F
81 */
82 HWTEST_F(DAudioSinkDevTest, TaskOpenCtrlChannel_001, TestSize.Level1)
83 {
84 std::string args;
85 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskOpenCtrlChannel(args));
86 }
87
88 /**
89 * @tc.name: TaskOpenCtrlChannel_002
90 * @tc.desc: Verify the TaskOpenCtrlChannel function.
91 * @tc.type: FUNC
92 * @tc.require: AR000H0E5F
93 */
94 HWTEST_F(DAudioSinkDevTest, TaskOpenCtrlChannel_002, TestSize.Level1)
95 {
96 std::string args = "args";
97 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskOpenCtrlChannel(args));
98 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskOpenCtrlChannel(args));
99 }
100
101 /**
102 * @tc.name: TaskCloseCtrlChannel_001
103 * @tc.desc: Verify the TaskCloseCtrlChannel function.
104 * @tc.type: FUNC
105 * @tc.require: AR000H0E5F
106 */
107 HWTEST_F(DAudioSinkDevTest, TaskCloseCtrlChannel_001, TestSize.Level1)
108 {
109 std::string args;
110 sinkDev_->audioCtrlMgr_ = nullptr;
111 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseCtrlChannel(args));
112 }
113
114 /**
115 * @tc.name: TaskCloseCtrlChannel_002
116 * @tc.desc: Verify the TaskCloseCtrlChannel function.
117 * @tc.type: FUNC
118 * @tc.require: AR000H0E5F
119 */
120 HWTEST_F(DAudioSinkDevTest, TaskCloseCtrlChannel_002, TestSize.Level1)
121 {
122 std::string args;
123 std::string devId = "devId";
124 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseCtrlChannel(args));
125 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseCtrlChannel(args));
126 sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
127 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseCtrlChannel(args));
128 }
129
130 /**
131 * @tc.name: TaskOpenDSpeaker_001
132 * @tc.desc: Verify the TaskOpenDSpeaker function.
133 * @tc.type: FUNC
134 * @tc.require: AR000H0E5F
135 */
136 HWTEST_F(DAudioSinkDevTest, TaskOpenDSpeaker_001, TestSize.Level1)
137 {
138 std::string args;
139 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDSpeaker(args));
140 }
141
142 /**
143 * @tc.name: TaskOpenDSpeaker_002
144 * @tc.desc: Verify the TaskOpenDSpeaker function.
145 * @tc.type: FUNC
146 * @tc.require: AR000H0E5F
147 */
148 HWTEST_F(DAudioSinkDevTest, TaskOpenDSpeaker_002, TestSize.Level1)
149 {
150 std::string args = "args";
151 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDSpeaker(args));
152 }
153
154 /**
155 * @tc.name: TaskCloseDSpeaker_001
156 * @tc.desc: Verify the TaskCloseDSpeaker function.
157 * @tc.type: FUNC
158 * @tc.require: AR000H0E5F
159 */
160 HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_001, TestSize.Level1)
161 {
162 std::string args;
163 sinkDev_->speakerClient_ = nullptr;
164 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args));
165 }
166
167 /**
168 * @tc.name: TaskCloseDSpeaker_002
169 * @tc.desc: Verify the TaskCloseDSpeaker function.
170 * @tc.type: FUNC
171 * @tc.require: AR000H0E5F
172 */
173 HWTEST_F(DAudioSinkDevTest, TaskCloseDSpeaker_002, TestSize.Level1)
174 {
175 std::string args;
176 std::string devId = "devId";
177 sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, sinkDev_);
178 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDSpeaker(args));
179 }
180
181 /**
182 * @tc.name: TaskStartRender_001
183 * @tc.desc: Verify the TaskStartRender function.
184 * @tc.type: FUNC
185 * @tc.require: AR000H0E5F
186 */
187 HWTEST_F(DAudioSinkDevTest, TaskStartRender_001, TestSize.Level1)
188 {
189 std::string devId = "devId";
190 sinkDev_->speakerClient_ = nullptr;
191 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->TaskStartRender());
192 sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, sinkDev_);
193 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskStartRender());
194 }
195
196 /**
197 * @tc.name: TaskOpenDMic_001
198 * @tc.desc: Verify the TaskOpenDMic function.
199 * @tc.type: FUNC
200 * @tc.require: AR000H0E5F
201 */
202 HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_001, TestSize.Level1)
203 {
204 std::string args;
205 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDMic(args));
206 }
207
208 /**
209 * @tc.name: TaskOpenDMic_002
210 * @tc.desc: Verify the TaskOpenDMic function.
211 * @tc.type: FUNC
212 * @tc.require: AR000H0E5F
213 */
214 HWTEST_F(DAudioSinkDevTest, TaskOpenDMic_002, TestSize.Level1)
215 {
216 std::string args = "args";
217 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskOpenDMic(args));
218 }
219
220 /**
221 * @tc.name: TaskCloseDMic_001
222 * @tc.desc: Verify the TaskCloseDMic function.
223 * @tc.type: FUNC
224 * @tc.require: AR000H0E5F
225 */
226 HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_001, TestSize.Level1)
227 {
228 std::string args;
229 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args));
230 }
231
232 /**
233 * @tc.name: TaskCloseDMic_002
234 * @tc.desc: Verify the TaskCloseDMic function.
235 * @tc.type: FUNC
236 * @tc.require: AR000H0E5F
237 */
238 HWTEST_F(DAudioSinkDevTest, TaskCloseDMic_002, TestSize.Level1)
239 {
240 std::string args;
241 std::string devId;
242 sinkDev_->micClient_ = std::make_shared<DMicClient>(devId, sinkDev_);
243 EXPECT_EQ(DH_SUCCESS, sinkDev_->TaskCloseDMic(args));
244 }
245
246 /**
247 * @tc.name: TaskSetParameter_001
248 * @tc.desc: Verify the TaskSetParameter function.
249 * @tc.type: FUNC
250 * @tc.require: AR000H0E5F
251 */
252 HWTEST_F(DAudioSinkDevTest, TaskSetParameter_001, TestSize.Level1)
253 {
254 std::string args;
255 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args));
256 }
257
258 /**
259 * @tc.name: TaskSetParameter_002
260 * @tc.desc: Verify the TaskSetParameter function.
261 * @tc.type: FUNC
262 * @tc.require: AR000H0E5F
263 */
264 HWTEST_F(DAudioSinkDevTest, TaskSetParameter_002, TestSize.Level1)
265 {
266 std::string args;
267 std::string devId;
268 sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, sinkDev_);
269 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetParameter(args));
270 }
271
272 /**
273 * @tc.name: TaskSetVolume_001
274 * @tc.desc: Verify the TaskSetVolume function.
275 * @tc.type: FUNC
276 * @tc.require: AR000H0E5F
277 */
278 HWTEST_F(DAudioSinkDevTest, TaskSetVolume_001, TestSize.Level1)
279 {
280 std::string args;
281 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args));
282 }
283
284 /**
285 * @tc.name: TaskSetVolume_002
286 * @tc.desc: Verify the TaskSetVolume function.
287 * @tc.type: FUNC
288 * @tc.require: AR000H0E5F
289 */
290 HWTEST_F(DAudioSinkDevTest, TaskSetVolume_002, TestSize.Level1)
291 {
292 std::string args;
293 std::string devId;
294 sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, sinkDev_);
295 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetVolume(args));
296 }
297
298 /**
299 * @tc.name: TaskSetMute_001
300 * @tc.desc: Verify the TaskSetMute function.
301 * @tc.type: FUNC
302 * @tc.require: AR000H0E5F
303 */
304 HWTEST_F(DAudioSinkDevTest, TaskSetMute_001, TestSize.Level1)
305 {
306 std::string args;
307 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetMute(args));
308 }
309
310 /**
311 * @tc.name: TaskSetMute_002
312 * @tc.desc: Verify the TaskSetMute function.
313 * @tc.type: FUNC
314 * @tc.require: AR000H0E5F
315 */
316 HWTEST_F(DAudioSinkDevTest, TaskSetMute_002, TestSize.Level1)
317 {
318 std::string args;
319 std::string devId;
320 sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, sinkDev_);
321 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskSetMute(args));
322 }
323
324 /**
325 * @tc.name: TaskVolumeChange_001
326 * @tc.desc: Verify the TaskVolumeChange function.
327 * @tc.type: FUNC
328 * @tc.require: AR000H0E5F
329 */
330 HWTEST_F(DAudioSinkDevTest, TaskVolumeChange_001, TestSize.Level1)
331 {
332 std::string args;
333 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskVolumeChange(args));
334 }
335
336 /**
337 * @tc.name: TaskVolumeChange_002
338 * @tc.desc: Verify the TaskVolumeChange function.
339 * @tc.type: FUNC
340 * @tc.require: AR000H0E5F
341 */
342 HWTEST_F(DAudioSinkDevTest, TaskVolumeChange_002, TestSize.Level1)
343 {
344 std::string args;
345 std::string devId = "devId";
346 sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
347 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskVolumeChange(args));
348 }
349
350 /**
351 * @tc.name: TaskFocusChange_001
352 * @tc.desc: Verify the TaskFocusChange function.
353 * @tc.type: FUNC
354 * @tc.require: AR000H0E5F
355 */
356 HWTEST_F(DAudioSinkDevTest, TaskFocusChange_001, TestSize.Level1)
357 {
358 std::string args;
359 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskFocusChange(args));
360 }
361
362 /**
363 * @tc.name: TaskFocusChange_002
364 * @tc.desc: Verify the TaskFocusChange function.
365 * @tc.type: FUNC
366 * @tc.require: AR000H0E5F
367 */
368 HWTEST_F(DAudioSinkDevTest, TaskFocusChange_002, TestSize.Level1)
369 {
370 std::string args;
371 std::string devId = "devId";
372 sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
373 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskFocusChange(args));
374 }
375
376 /**
377 * @tc.name: TaskRenderStateChange_001
378 * @tc.desc: Verify the TaskRenderStateChange function.
379 * @tc.type: FUNC
380 * @tc.require: AR000H0E5F
381 */
382 HWTEST_F(DAudioSinkDevTest, TaskRenderStateChange_001, TestSize.Level1)
383 {
384 std::string args;
385 std::string dhId = "dhId";
386 int32_t result = 0;
387 sinkDev_->NotifySourceDev(AUDIO_START, dhId, result);
388 sinkDev_->NotifySourceDev(NOTIFY_OPEN_CTRL_RESULT, dhId, result);
389 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskRenderStateChange(args));
390 }
391
392 /**
393 * @tc.name: TaskRenderStateChange_002
394 * @tc.desc: Verify the TaskRenderStateChange function.
395 * @tc.type: FUNC
396 * @tc.require: AR000H0E5F
397 */
398 HWTEST_F(DAudioSinkDevTest, TaskRenderStateChange_002, TestSize.Level1)
399 {
400 std::string args;
401 std::string devId = "devId";
402 json j;
403 AudioParam audioParam;
404 sinkDev_->audioCtrlMgr_ = std::make_shared<DAudioSinkDevCtrlMgr>(devId, sinkDev_);
405 EXPECT_NE(DH_SUCCESS, sinkDev_->TaskRenderStateChange(args));
406 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sinkDev_->from_json(j, audioParam));
407 }
408
409 /**
410 * @tc.name: SendAudioEventToRemote_002
411 * @tc.desc: Verify the SendAudioEventToRemote function.
412 * @tc.type: FUNC
413 * @tc.require: AR000H0E5F
414 */
415 HWTEST_F(DAudioSinkDevTest, SendAudioEventToRemote_002, TestSize.Level1)
416 {
417 std::string devId = "devId";
418 AudioEvent event;
419 sinkDev_->speakerClient_ = nullptr;
420 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->SendAudioEventToRemote(event));
421 sinkDev_->speakerClient_ = std::make_shared<DSpeakerClient>(devId, sinkDev_);
422 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sinkDev_->SendAudioEventToRemote(event));
423 }
424 } // DistributedHardware
425 } // OHOS
426