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 "daudio_source_mgr_test.h"
17
18 using namespace testing::ext;
19
20 namespace OHOS {
21 namespace DistributedHardware {
22 const std::string DEV_ID = "Test_Dev_Id";
23 const std::string DH_ID_MIC = "134217728";
24 const std::string DH_ID_SPK = "1";
25 const std::string ATTRS = "attrs";
26
SetUpTestCase(void)27 void DAudioSourceMgrTest::SetUpTestCase(void) {}
28
TearDownTestCase(void)29 void DAudioSourceMgrTest::TearDownTestCase(void) {}
30
SetUp(void)31 void DAudioSourceMgrTest::SetUp(void)
32 {
33 dAudioIpcCallback_ = sptr<DAudioIpcCallback>(new DAudioIpcCallback());
34 remoteObject_ = dAudioIpcCallback_;
35 ipcCallbackProxy_ = sptr<DAudioIpcCallbackProxy>(new DAudioIpcCallbackProxy(remoteObject_));
36 auto runner = AppExecFwk::EventRunner::Create(true);
37 if (runner == nullptr) {
38 return;
39 }
40 sourceMgr.handler_ = std::make_shared<DAudioSourceManager::SourceManagerHandler>(runner);
41 }
42
TearDown(void)43 void DAudioSourceMgrTest::TearDown(void)
44 {
45 dAudioIpcCallback_ = nullptr;
46 remoteObject_ = nullptr;
47 ipcCallbackProxy_ = nullptr;
48 }
49
50 /**
51 * @tc.name: Init_001
52 * @tc.desc: Verify the Init and UnInit function.
53 * @tc.type: FUNC
54 * @tc.require: AR000H0E5F
55 */
56 HWTEST_F(DAudioSourceMgrTest, Init_001, TestSize.Level1)
57 {
58 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceMgr.UnInit());
59
60 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceMgr.Init(nullptr));
61 EXPECT_NE(DH_SUCCESS, sourceMgr.Init(ipcCallbackProxy_));
62
63 std::string localDevId;
64 EXPECT_NE(DH_SUCCESS, GetLocalDeviceNetworkId(localDevId));
65 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
66 }
67
68 /**
69 * @tc.name: CreateAudioDevice_001
70 * @tc.desc: Verify the CreateAudioDevice and UnInitfunction.
71 * @tc.type: FUNC
72 * @tc.require: AR000H0E5F
73 */
74 HWTEST_F(DAudioSourceMgrTest, CreateAudioDevice_001, TestSize.Level1)
75 {
76 EXPECT_EQ(DH_SUCCESS, sourceMgr.CreateAudioDevice(DEV_ID));
77
78 sourceMgr.daudioMgrCallback_ = std::make_shared<DAudioSourceMgrCallback>();
79 EXPECT_EQ(DH_SUCCESS, sourceMgr.CreateAudioDevice(DEV_ID + "1"));
80
81 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
82 }
83
84 /**
85 * @tc.name: EnableDAudio_001
86 * @tc.desc: Verify the EnableDAudio and DisableDAudio function.
87 * @tc.type: FUNC
88 * @tc.require: AR000H0E5F
89 */
90 HWTEST_F(DAudioSourceMgrTest, EnableDAudio_001, TestSize.Level1)
91 {
92 std::string reqId1 = GetRandomID();
93 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(DEV_ID, DH_ID_SPK, "", ATTRS, reqId1));
94 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
95 }
96
97 /**
98 * @tc.name: EnableDAudio_002
99 * @tc.desc: Verify the EnableDAudio and DisableDAudio function.
100 * @tc.type: FUNC
101 * @tc.require: AR000H0E5F
102 */
103 HWTEST_F(DAudioSourceMgrTest, EnableDAudio_002, TestSize.Level1)
104 {
105 std::string reqId1 = GetRandomID();
106 std::string reqId2 = GetRandomID();
107 sourceMgr.daudioMgrCallback_ = std::make_shared<DAudioSourceMgrCallback>();
108 sourceMgr.ipcCallback_ = ipcCallbackProxy_;
109 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(DEV_ID, DH_ID_SPK, "", ATTRS, reqId1));
110 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(DEV_ID, DH_ID_MIC, "", ATTRS, reqId2));
111
112 EXPECT_EQ(DH_SUCCESS, sourceMgr.DisableDAudio(DEV_ID, DH_ID_SPK, reqId1));
113 EXPECT_EQ(DH_SUCCESS, sourceMgr.DisableDAudio(DEV_ID, DH_ID_MIC, reqId1));
114 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
115 }
116
117 /**
118 * @tc.name: EnableDAudio_003
119 * @tc.desc: Verify the EnableDAudio and DisableDAudio function.
120 * @tc.type: FUNC
121 * @tc.require: AR000H0E5F
122 */
123 HWTEST_F(DAudioSourceMgrTest, EnableDAudio_003, TestSize.Level1)
124 {
125 std::string reqId1 = GetRandomID();
126 DAudioSourceManager::AudioDevice device = { DEV_ID, nullptr };
127 sourceMgr.audioDevMap_[DEV_ID] = device;
128 EXPECT_EQ(DH_SUCCESS, sourceMgr.DisableDAudio(DEV_ID, DH_ID_SPK, reqId1));
129
130 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
131 }
132
133 /**
134 * @tc.name: EnableDAudio_004
135 * @tc.desc: Verify the EnableDAudio and DisableDAudio function.
136 * @tc.type: FUNC
137 * @tc.require: AR000H0E5F
138 */
139 HWTEST_F(DAudioSourceMgrTest, EnableDAudio_004, TestSize.Level1)
140 {
141 std::string reqId1 = GetRandomID();
142 std::string dhId = "";
143 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(DEV_ID, dhId, "", ATTRS, reqId1));
144 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
145 dhId = std::string(105, '1');
146 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(DEV_ID, dhId, "", ATTRS, reqId1));
147 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
148 std::string devId = "";
149 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(devId, DH_ID_SPK, "", ATTRS, reqId1));
150 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
151 devId = std::string(205, 'a');
152 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(devId, DH_ID_SPK, "", ATTRS, reqId1));
153 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
154 std::string attrs = "";
155 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(DEV_ID, DH_ID_SPK, "", attrs, reqId1));
156 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
157 }
158
159 /**
160 * @tc.name: DisableDAudio_001
161 * @tc.desc: Verify the DisableDAudio function.
162 * @tc.type: FUNC
163 * @tc.require: AR000H0E5F
164 */
165 HWTEST_F(DAudioSourceMgrTest, DisableDAudio_001, TestSize.Level1)
166 {
167 std::string reqId1 = GetRandomID();
168 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(DEV_ID, DH_ID_SPK, "", ATTRS, reqId1));
169
170 std::string dhId = "";
171 EXPECT_EQ(DH_SUCCESS, sourceMgr.DisableDAudio(DEV_ID, dhId, reqId1));
172 dhId = std::string(105, '1');
173 EXPECT_EQ(DH_SUCCESS, sourceMgr.DisableDAudio(DEV_ID, dhId, reqId1));
174 std::string devId = "";
175 EXPECT_EQ(DH_SUCCESS, sourceMgr.DisableDAudio(devId, DH_ID_SPK, reqId1));
176 devId = std::string(205, 'a');
177 EXPECT_EQ(DH_SUCCESS, sourceMgr.DisableDAudio(devId, DH_ID_SPK, reqId1));
178 EXPECT_EQ(DH_SUCCESS, sourceMgr.DisableDAudio("Unknown", DH_ID_SPK, reqId1));
179 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
180 }
181
182 /**
183 * @tc.name: HandleDAudioNotify_001
184 * @tc.desc: Verify the HandleDAudioNotify function.
185 * @tc.type: FUNC
186 * @tc.require: AR000H0E5F
187 */
188 HWTEST_F(DAudioSourceMgrTest, HandleDAudioNotify_001, TestSize.Level1)
189 {
190 EXPECT_EQ(ERR_DH_AUDIO_SA_DEVICE_NOT_EXIST,
191 sourceMgr.HandleDAudioNotify(DEV_ID, DH_ID_SPK, OPEN_SPEAKER, "openspk"));
192
193 std::string reqId = GetRandomID();
194 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(DEV_ID, DH_ID_SPK, "", ATTRS, reqId));
195 EXPECT_EQ(ERR_DH_AUDIO_SA_DEVICE_NOT_EXIST,
196 sourceMgr.HandleDAudioNotify(DEV_ID, DH_ID_SPK, OPEN_SPEAKER, "openspk"));
197
198 EXPECT_EQ(DH_SUCCESS, sourceMgr.DisableDAudio(DEV_ID, DH_ID_SPK, reqId));
199 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceMgr.HandleDAudioNotify(DEV_ID + "1", DH_ID_SPK, CLOSE_CTRL, ""));
200 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
201 }
202
203 /**
204 * @tc.name: DAudioNotify_001
205 * @tc.desc: Verify the DAudioNotify function.
206 * @tc.type: FUNC
207 * @tc.require: AR000H0E5F
208 */
209 HWTEST_F(DAudioSourceMgrTest, DAudioNotify_001, TestSize.Level1)
210 {
211 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR,
212 sourceMgr.DAudioNotify(DEV_ID, DH_ID_SPK, OPEN_SPEAKER, "openspk"));
213 }
214
215 /**
216 * @tc.name: OnEnableDAudio_001
217 * @tc.desc: Verify the OnEnableDAudio function.
218 * @tc.type: FUNC
219 * @tc.require: AR000H0E5F
220 */
221 HWTEST_F(DAudioSourceMgrTest, OnEnableDAudio_001, TestSize.Level1)
222 {
223 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceMgr.OnEnableDAudio(DEV_ID, DH_ID_SPK, DH_SUCCESS));
224
225 std::string reqId = GetRandomID();
226 EXPECT_EQ(DH_SUCCESS, sourceMgr.CreateAudioDevice(DEV_ID));
227 sourceMgr.audioDevMap_[DEV_ID].ports[DH_ID_SPK] = reqId;
228 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceMgr.OnEnableDAudio(DEV_ID, DH_ID_SPK, DH_SUCCESS));
229 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
230 }
231
232 /**
233 * @tc.name: OnEnableDAudio_002
234 * @tc.desc: Verify the OnEnableDAudio function.
235 * @tc.type: FUNC
236 * @tc.require: AR000H0E5F
237 */
238 HWTEST_F(DAudioSourceMgrTest, OnEnableDAudio_002, TestSize.Level1)
239 {
240 std::string reqId = GetRandomID();
241 EXPECT_NE(DH_SUCCESS, sourceMgr.Init(ipcCallbackProxy_));
242 sourceMgr.ipcCallback_ = ipcCallbackProxy_;
243
244 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(DEV_ID, DH_ID_SPK, "", ATTRS, reqId));
245 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceMgr.OnEnableDAudio(DEV_ID, DH_ID_SPK, DH_SUCCESS));
246 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
247 }
248
249 /**
250 * @tc.name: OnEnableDAudio_003
251 * @tc.desc: Verify the OnEnableDAudio function.
252 * @tc.type: FUNC
253 * @tc.require: AR000H0E5F
254 */
255 HWTEST_F(DAudioSourceMgrTest, OnEnableDAudio_003, TestSize.Level1)
256 {
257 EXPECT_NE(DH_SUCCESS, sourceMgr.Init(ipcCallbackProxy_));
258 sourceMgr.ipcCallback_ = ipcCallbackProxy_;
259 std::string reqId = GetRandomID();
260 sourceMgr.audioDevMap_[DEV_ID].ports[DH_ID_SPK] = reqId;
261 EXPECT_EQ(DH_SUCCESS, sourceMgr.OnEnableDAudio(DEV_ID, DH_ID_SPK, DH_SUCCESS));
262 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
263 }
264
265 /**
266 * @tc.name: OnDisableDAudio_001
267 * @tc.desc: Verify the OnDisableDAudio function.
268 * @tc.type: FUNC
269 * @tc.require: AR000H0E5F
270 */
271 HWTEST_F(DAudioSourceMgrTest, OnDisableDAudio_001, TestSize.Level1)
272 {
273 EXPECT_EQ(ERR_DH_AUDIO_FAILED, sourceMgr.OnDisableDAudio(DEV_ID, DH_ID_SPK, DH_SUCCESS));
274
275 std::string reqId = GetRandomID();
276 EXPECT_EQ(DH_SUCCESS, sourceMgr.CreateAudioDevice(DEV_ID));
277 sourceMgr.audioDevMap_[DEV_ID].ports[DH_ID_SPK] = reqId;
278 int32_t ret = -40003;
279 EXPECT_EQ(ERR_DH_AUDIO_NULLPTR, sourceMgr.OnDisableDAudio(DEV_ID, DH_ID_SPK, ret));
280 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
281 }
282
283 /**
284 * @tc.name: OnDisableDAudio_003
285 * @tc.desc: Verify the OnDisableDAudio function.
286 * @tc.type: FUNC
287 * @tc.require: AR000H0E5F
288 */
289 HWTEST_F(DAudioSourceMgrTest, OnDisableDAudio_003, TestSize.Level1)
290 {
291 std::string reqId = GetRandomID();
292 EXPECT_EQ(DH_SUCCESS, sourceMgr.CreateAudioDevice(DEV_ID));
293 sourceMgr.audioDevMap_[DEV_ID].ports[DH_ID_SPK] = reqId;
294 sourceMgr.ipcCallback_ = ipcCallbackProxy_;
295 int32_t ret = -40003;
296 EXPECT_EQ(DH_SUCCESS, sourceMgr.OnDisableDAudio(DEV_ID, DH_ID_SPK, ret));
297 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
298 }
299
300 /**
301 * @tc.name: GetRequestId_001
302 * @tc.desc: Verify the GetRequestId function.
303 * @tc.type: FUNC
304 * @tc.require: AR000H0E5F
305 */
306 HWTEST_F(DAudioSourceMgrTest, GetRequestId_001, TestSize.Level1)
307 {
308 EXPECT_EQ("", sourceMgr.GetRequestId(DEV_ID, DH_ID_SPK));
309
310 std::string reqId0 = GetRandomID();
311 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(DEV_ID, DH_ID_SPK, "", ATTRS, reqId0));
312 std::string reqId1 = GetRandomID();
313 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(DEV_ID, DH_ID_MIC, "", ATTRS, reqId1));
314
315 EXPECT_EQ("", sourceMgr.GetRequestId(DEV_ID, DH_ID_SPK));
316 EXPECT_EQ("", sourceMgr.GetRequestId(DEV_ID, DH_ID_MIC));
317 EXPECT_EQ("", sourceMgr.GetRequestId(DEV_ID, DH_ID_SPK + "2"));
318
319 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
320 }
321
322 /**
323 * @tc.name: GetRequestId_002
324 * @tc.desc: Verify the GetRequestId function.
325 * @tc.type: FUNC
326 * @tc.require: AR000H0E5F
327 */
328 HWTEST_F(DAudioSourceMgrTest, GetRequestId_002, TestSize.Level1)
329 {
330 EXPECT_EQ("", sourceMgr.GetRequestId(DEV_ID, DH_ID_SPK));
331
332 std::string reqId0 = GetRandomID();
333 EXPECT_EQ(DH_SUCCESS, sourceMgr.EnableDAudio(DEV_ID, DH_ID_SPK, "", ATTRS, reqId0));
334
335 EXPECT_EQ("", sourceMgr.GetRequestId(DEV_ID, DH_ID_MIC));
336 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
337 }
338
339 /**
340 * @tc.name: DeleteAudioDevice_001
341 * @tc.desc: Verify the DeleteAudioDevice function.
342 * @tc.type: FUNC
343 * @tc.require: AR000H0E5F
344 */
345 HWTEST_F(DAudioSourceMgrTest, DeleteAudioDevice_001, TestSize.Level1)
346 {
347 sourceMgr.daudioMgrCallback_ = std::make_shared<DAudioSourceMgrCallback>();
348 sourceMgr.ipcCallback_ = ipcCallbackProxy_;
349 std::string reqId0 = GetRandomID();
350 std::string reqId1 = GetRandomID();
351 EXPECT_EQ(DH_SUCCESS, sourceMgr.CreateAudioDevice(DEV_ID));
352 sourceMgr.audioDevMap_[DEV_ID].ports[DH_ID_SPK] = reqId0;
353 sourceMgr.audioDevMap_[DEV_ID].ports[DH_ID_MIC] = reqId1;
354
355 EXPECT_EQ(DH_SUCCESS, sourceMgr.DisableDAudio(DEV_ID, DH_ID_SPK, reqId0));
356 EXPECT_EQ(DH_SUCCESS, sourceMgr.DisableDAudio(DEV_ID, DH_ID_MIC, reqId1));
357
358 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnInit());
359 }
360
361 /**
362 * @tc.name: LoadAVReceiverEngineProvider_001
363 * @tc.desc: Verify the LoadAVReceiverEngineProvider function.
364 * @tc.type: FUNC
365 * @tc.require: AR000H0E5F
366 */
367 HWTEST_F(DAudioSourceMgrTest, LoadAVReceiverEngineProvider_001, TestSize.Level1)
368 {
369 EXPECT_EQ(DH_SUCCESS, sourceMgr.LoadAVReceiverEngineProvider());
370 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnloadAVReceiverEngineProvider());
371 EXPECT_EQ(DH_SUCCESS, sourceMgr.LoadAVSenderEngineProvider());
372 EXPECT_EQ(DH_SUCCESS, sourceMgr.UnloadAVSenderEngineProvider());
373 }
374 } // namespace DistributedHardware
375 } // namespace OHOS
376