1 /*
2 * Copyright (c) 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 <gtest/gtest.h>
17 #include "distributedaudiotest.h"
18 #include "audio_event.h"
19 #include "daudio_constants.h"
20 #include "daudio_errorcode.h"
21 #include "iservice_registry.h"
22 #include "daudio_sink_ipc_callback_proxy.h"
23 #include "daudio_sink_load_callback.h"
24 #define PRIVATE public
25 #define PROTECTED public
26 #include "daudio_sink_service.h"
27 #undef PROTECTED
28 #undef PRIVATE
29
30 using namespace testing::ext;
31 using namespace OHOS;
32 using namespace OHOS::DistributedHardware;
33
34 int32_t g_audioOk = 0;
35 int32_t g_audioDelay = 5;
36 std::string res = "true";
37 std::string g_testParams = "sink";
38 class DAudioAutomatTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 DAudioAutomatTest();
45 std::shared_ptr<DAudioSinkService> sinkSrv_ = nullptr;
46 sptr<IRemoteObject> remoteObject_ = nullptr;
47 sptr<ISystemAbilityManager> samgr_ = nullptr;
48 };
SetUpTestCase(void)49 void DAudioAutomatTest::SetUpTestCase(void)
50 {
51 int ret = InitTestDemo();
52 if (ret != g_audioOk) {
53 DHLOGI("demo test:InitTestDemo error");
54 return;
55 }
56 }
TearDownTestCase(void)57 void DAudioAutomatTest::TearDownTestCase(void) {}
SetUp(void)58 void DAudioAutomatTest::SetUp(void)
59 {
60 int32_t saId = 6666;
61 bool runOnCreate = true;
62 std::string params = "params";
63 samgr_ = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
64 if (samgr_ == nullptr) {
65 return;
66 }
67 sptr<DAudioSinkLoadCallback> loadCallback(new DAudioSinkLoadCallback(params));
68 samgr_->LoadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, loadCallback);
69 remoteObject_ = samgr_->GetSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
70 if (remoteObject_ == nullptr) {
71 return;
72 }
73
74 sinkSrv_ = std::make_shared<DAudioSinkService>(saId, runOnCreate);
75 }
TearDown(void)76 void DAudioAutomatTest::TearDown(void)
77 {
78 if (samgr_ != nullptr) {
79 samgr_->UnloadSystemAbility(DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID);
80 }
81 sinkSrv_ = nullptr;
82 }
DAudioAutomatTest(void)83 DAudioAutomatTest::DAudioAutomatTest(void) {}
84
85 /**
86 * @tc.name FindAudioDevice()
87 * @tc.number SUB_DH_DAudio_Dcts_0100
88 * @tc.desc Find Audio Device Test
89 * @tc.size MediumTest
90 * @tc.type Function
91 * @tc.level Level 1
92 */
93 HWTEST_F(DAudioAutomatTest, SUB_DH_DAudio_Dcts_0100, TestSize.Level1)
94 {
95 std::string g_networkId;
96 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
97 int32_t ret = sinkSrv_->InitSink(g_testParams, dAudioSinkIpcCallbackProxy);
98 EXPECT_EQ(g_audioOk, ret) << "InitSink fail DCTS_0100";
99
100 int32_t res = GetSyncOnlineDevices(g_networkId);
101 EXPECT_EQ(g_audioOk, res) << "GetSyncOnlineDevices fail DCTS_0100";
102
103 res = sinkSrv_->PauseDistributedHardware(g_networkId);
104 EXPECT_EQ(g_audioOk, res) << "PauseDistributedHardware fail DCTS_0100";
105
106 sinkSrv_->ReleaseSink();
107 }
108
109 /**
110 * @tc.name OpenSpk()
111 * @tc.number SUB_DH_DAudio_Dcts_0200
112 * @tc.desc Open Spk Test
113 * @tc.size MediumTest
114 * @tc.type Function
115 * @tc.level Level 1
116 */
117 HWTEST_F(DAudioAutomatTest, SUB_DH_DAudio_Dcts_0200, TestSize.Level1)
118 {
119 std::string g_networkId;
120 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
121 int32_t ret = sinkSrv_->InitSink(g_testParams, dAudioSinkIpcCallbackProxy);
122 EXPECT_EQ(g_audioOk, ret) << "InitSink fail DCTS_0200";
123
124 int32_t ref = GetSyncOnlineDevices(g_networkId);
125 EXPECT_EQ(g_audioOk, ref) << "GetSyncOnlineDevices fail DCTS_0200";
126
127 ref = sinkSrv_->ResumeDistributedHardware(g_networkId);
128 EXPECT_EQ(g_audioOk, ref) << "ResumeDistributedHardware fail DCTS_0200";
129
130 sinkSrv_->ReleaseSink();
131 }
132
133 /**
134 * @tc.name StartRender()
135 * @tc.number SUB_DH_DAudio_Dcts_0300
136 * @tc.desc Start Render Test
137 * @tc.size MediumTest
138 * @tc.type Function
139 * @tc.level Level 1
140 */
141 HWTEST_F(DAudioAutomatTest, SUB_DH_DAudio_Dcts_0300, TestSize.Level1)
142 {
143 std::string g_networkId;
144 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
145 int32_t ret = sinkSrv_->InitSink(g_testParams, dAudioSinkIpcCallbackProxy);
146 EXPECT_EQ(g_audioOk, ret) << "InitSink fail DCTS_0300";
147
148 int32_t ref = GetSyncOnlineDevices(g_networkId);
149 EXPECT_EQ(g_audioOk, ref) << "GetSyncOnlineDevices fail DCTS_0300";
150
151 ref = sinkSrv_->StopDistributedHardware(g_networkId);
152 EXPECT_EQ(g_audioOk, ref) << "StopDistributedHardware fail DCTS_0300";
153
154 sinkSrv_->ReleaseSink();
155 }
156
157 /**
158 * @tc.name StopRender()
159 * @tc.number SUB_DH_DAudio_Dcts_0400
160 * @tc.desc Stop Render Test
161 * @tc.size MediumTest
162 * @tc.type Function
163 * @tc.level Level 1
164 */
165 HWTEST_F(DAudioAutomatTest, SUB_DH_DAudio_Dcts_0400, TestSize.Level1)
166 {
167 std::string g_networkId;
168 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
169 int32_t ret = sinkSrv_->InitSink(g_testParams, dAudioSinkIpcCallbackProxy);
170 EXPECT_EQ(g_audioOk, ret) << "InitSink fail DCTS_0400";
171
172 int32_t ref = GetSyncOnlineDevices(g_networkId);
173 EXPECT_EQ(g_audioOk, ref) << "GetSyncOnlineDevices fail DCTS_0400";
174
175 ref = sinkSrv_->ResumeDistributedHardware(g_networkId);
176 EXPECT_EQ(g_audioOk, ref) << "ResumeDistributedHardware fail DCTS_0400";
177
178 ref = sinkSrv_->StopDistributedHardware(g_networkId);
179 EXPECT_EQ(g_audioOk, ref) << "StopDistributedHardware fail DCTS_0400";
180
181 sinkSrv_->ReleaseSink();
182 }
183
184 /**
185 * @tc.name SetVolume()
186 * @tc.number SUB_DH_DAudio_Dcts_0500
187 * @tc.desc Set Volume Test
188 * @tc.size MediumTest
189 * @tc.type Function
190 * @tc.level Level 1
191 */
192 HWTEST_F(DAudioAutomatTest, SUB_DH_DAudio_Dcts_0500, TestSize.Level1)
193 {
194 std::string g_networkId;
195 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
196 int32_t ret = sinkSrv_->InitSink(g_testParams, dAudioSinkIpcCallbackProxy);
197 EXPECT_EQ(g_audioOk, ret) << "InitSink fail DCTS_0500";
198
199 int32_t ref = GetSyncOnlineDevices(g_networkId);
200 EXPECT_EQ(g_audioOk, ref) << "GetSyncOnlineDevices fail DCTS_0500";
201
202 ref = sinkSrv_->ResumeDistributedHardware(g_networkId);
203 EXPECT_EQ(g_audioOk, ref) << "ResumeDistributedHardware fail DCTS_0500";
204
205 ref = sinkSrv_->PauseDistributedHardware(g_networkId);
206 EXPECT_EQ(g_audioOk, ref) << "PauseDistributedHardware fail DCTS_0500";
207
208 sinkSrv_->ReleaseSink();
209 }
210
211 /**
212 * @tc.name GetVolume()
213 * @tc.number SUB_DH_DAudio_Dcts_0600
214 * @tc.desc Get Volume Test
215 * @tc.size MediumTest
216 * @tc.type Function
217 * @tc.level Level 1
218 */
219 HWTEST_F(DAudioAutomatTest, SUB_DH_DAudio_Dcts_0600, TestSize.Level1)
220 {
221 std::string g_networkId;
222 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
223 int32_t ret = sinkSrv_->InitSink(g_testParams, dAudioSinkIpcCallbackProxy);
224 EXPECT_EQ(g_audioOk, ret) << "InitSink fail DCTS_0600";
225
226 int32_t ref = GetSyncOnlineDevices(g_networkId);
227 EXPECT_EQ(g_audioOk, ref) << "GetSyncOnlineDevices fail DCTS_0600";
228
229 ref = sinkSrv_->PauseDistributedHardware(g_networkId);
230 EXPECT_EQ(g_audioOk, ref) << "PauseDistributedHardware fail DCTS_0600";
231
232 ref = sinkSrv_->ResumeDistributedHardware(g_networkId);
233 EXPECT_EQ(g_audioOk, ref) << "ResumeDistributedHardware fail DCTS_0600";
234
235 sinkSrv_->ReleaseSink();
236 }
237
238 /**
239 * @tc.name CloseSpk()
240 * @tc.number SUB_DH_DAudio_Dcts_0700
241 * @tc.desc Close Spk Test
242 * @tc.size MediumTest
243 * @tc.type Function
244 * @tc.level Level 1
245 */
246 HWTEST_F(DAudioAutomatTest, SUB_DH_DAudio_Dcts_0700, TestSize.Level1)
247 {
248 std::string g_networkId;
249 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
250 int32_t ret = sinkSrv_->InitSink(g_testParams, dAudioSinkIpcCallbackProxy);
251 EXPECT_EQ(g_audioOk, ret) << "InitSink fail DCTS_0700";
252
253 int32_t ref = GetSyncOnlineDevices(g_networkId);
254 EXPECT_EQ(g_audioOk, ref) << "GetSyncOnlineDevices fail DCTS_0700";
255
256 ref = sinkSrv_->StopDistributedHardware(g_networkId);
257 EXPECT_EQ(g_audioOk, ref) << "StopDistributedHardware fail DCTS_0700";
258
259 ref = sinkSrv_->ResumeDistributedHardware(g_networkId);
260 EXPECT_EQ(g_audioOk, ref) << "ResumeDistributedHardware fail DCTS_0700";
261
262 sinkSrv_->ReleaseSink();
263 }
264
265 /**
266 * @tc.name OpenMic()
267 * @tc.number SUB_DH_DAudio_Dcts_0800
268 * @tc.desc Open Mic Test
269 * @tc.size MediumTest
270 * @tc.type Function
271 * @tc.level Level 1
272 */
273 HWTEST_F(DAudioAutomatTest, SUB_DH_DAudio_Dcts_0800, TestSize.Level1)
274 {
275 std::string g_networkId;
276 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
277 int32_t ret = sinkSrv_->InitSink(g_testParams, dAudioSinkIpcCallbackProxy);
278 EXPECT_EQ(g_audioOk, ret) << "InitSink fail DCTS_0800";
279
280 int32_t ref = GetSyncOnlineDevices(g_networkId);
281 EXPECT_EQ(g_audioOk, ref) << "GetSyncOnlineDevices fail DCTS_0800";
282
283 ref = sinkSrv_->PauseDistributedHardware(g_networkId);
284 EXPECT_EQ(g_audioOk, ref) << "PauseDistributedHardware fail DCTS_0800";
285
286 ref = sinkSrv_->StopDistributedHardware(g_networkId);
287 EXPECT_EQ(g_audioOk, ref) << "StopDistributedHardware fail DCTS_0800";
288 sleep(g_audioDelay);
289
290 sinkSrv_->ReleaseSink();
291 }
292
293 /**
294 * @tc.name StartCapture()
295 * @tc.number SUB_DH_DAudio_Dcts_0900
296 * @tc.desc Start Capture Test
297 * @tc.size MediumTest
298 * @tc.type Function
299 * @tc.level Level 1
300 */
301 HWTEST_F(DAudioAutomatTest, SUB_DH_DAudio_Dcts_0900, TestSize.Level1)
302 {
303 std::string g_networkId;
304 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
305 int32_t ret = sinkSrv_->InitSink(g_testParams, dAudioSinkIpcCallbackProxy);
306 EXPECT_EQ(g_audioOk, ret) << "InitSink fail DCTS_0900";
307
308 int32_t ref = GetSyncOnlineDevices(g_networkId);
309 EXPECT_EQ(g_audioOk, ref) << "GetSyncOnlineDevices fail DCTS_0900";
310
311 std::string finish = HandleAudioEvent(5);
312 EXPECT_EQ(res, finish) << "OpenMic fail DCTS_0900";
313 sleep(g_audioDelay);
314
315 ref = sinkSrv_->PauseDistributedHardware(g_networkId);
316 EXPECT_EQ(g_audioOk, ref) << "PauseDistributedHardware fail DCTS_0900";
317
318 finish = HandleAudioEvent(7);
319 EXPECT_EQ(res, finish) << "StartCapture fail DCTS_0900";
320 sleep(g_audioDelay);
321
322 ref = sinkSrv_->ResumeDistributedHardware(g_networkId);
323 EXPECT_EQ(g_audioOk, ref) << "ResumeDistributedHardware fail DCTS_0900";
324
325 finish = HandleAudioEvent(8);
326 EXPECT_EQ(res, finish) << "StopCapture fail DCTS_0900";
327 sleep(g_audioDelay);
328
329 finish = HandleAudioEvent(6);
330 EXPECT_EQ(res, finish) << "CloseMic fail DCTS_0900";
331 sleep(g_audioDelay);
332
333 sinkSrv_->ReleaseSink();
334 }
335
336 /**
337 * @tc.name StopCapture()
338 * @tc.number SUB_DH_DAudio_Dcts_1000
339 * @tc.desc Stop Capture Test
340 * @tc.size MediumTest
341 * @tc.type Function
342 * @tc.level Level 1
343 */
344 HWTEST_F(DAudioAutomatTest, SUB_DH_DAudio_Dcts_1000, TestSize.Level1)
345 {
346 std::string g_networkId;
347 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
348 int32_t ret = sinkSrv_->InitSink(g_testParams, dAudioSinkIpcCallbackProxy);
349 EXPECT_EQ(g_audioOk, ret) << "InitSink fail DCTS_1000";
350
351 int32_t ref = GetSyncOnlineDevices(g_networkId);
352 EXPECT_EQ(g_audioOk, ref) << "GetSyncOnlineDevices fail DCTS_1000";
353
354 std::string finish = HandleAudioEvent(5);
355 EXPECT_EQ(res, finish) << "OpenMic fail DCTS_1000";
356 sleep(g_audioDelay);
357
358 finish = HandleAudioEvent(7);
359 EXPECT_EQ(res, finish) << "StartCapture fail DCTS_1000";
360 sleep(g_audioDelay);
361
362 ref = sinkSrv_->PauseDistributedHardware(g_networkId);
363 EXPECT_EQ(g_audioOk, ref) << "PauseDistributedHardware fail DCTS_1000";
364
365 ref = sinkSrv_->ResumeDistributedHardware(g_networkId);
366 EXPECT_EQ(g_audioOk, ref) << "ResumeDistributedHardware fail DCTS_1000";
367
368 finish = HandleAudioEvent(8);
369 EXPECT_EQ(res, finish) << "StopCapture fail DCTS_1000";
370 sleep(g_audioDelay);
371
372 finish = HandleAudioEvent(6);
373 EXPECT_EQ(res, finish) << "CloseMic fail DCTS_1000";
374 sleep(g_audioDelay);
375
376 sinkSrv_->ReleaseSink();
377 }
378
379 /**
380 * @tc.name CloseMic()
381 * @tc.number SUB_DH_DAudio_Dcts_1100
382 * @tc.desc Close Mic Test
383 * @tc.size MediumTest
384 * @tc.type Function
385 * @tc.level Level 1
386 */
387 HWTEST_F(DAudioAutomatTest, SUB_DH_DAudio_Dcts_1100, TestSize.Level1)
388 {
389 std::string g_networkId;
390 sptr<DAudioSinkIpcCallbackProxy> dAudioSinkIpcCallbackProxy(new DAudioSinkIpcCallbackProxy(remoteObject_));
391 int32_t ret = sinkSrv_->InitSink(g_testParams, dAudioSinkIpcCallbackProxy);
392 EXPECT_EQ(0, ret) << "InitSink fail DCTS_1100";
393
394 int32_t ref = GetSyncOnlineDevices(g_networkId);
395 EXPECT_EQ(0, ref) << "GetSyncOnlineDevices fail DCTS_1100";
396
397 std::string finish = HandleAudioEvent(5);
398 EXPECT_EQ(res, finish) << "OpenMic fail DCTS_1100";
399 sleep(g_audioDelay);
400
401 finish = HandleAudioEvent(7);
402 EXPECT_EQ(res, finish) << "StartCapture fail DCTS_1100";
403 sleep(g_audioDelay);
404
405
406 ref = sinkSrv_->PauseDistributedHardware(g_networkId);
407 EXPECT_EQ(0, ref) << "PauseDistributedHardware fail DCTS_1100";
408
409 finish = HandleAudioEvent(8);
410 EXPECT_EQ(res, finish) << "StopCapture fail DCTS_1100";
411 sleep(g_audioDelay);
412
413 finish = HandleAudioEvent(6);
414 EXPECT_EQ(res, finish) << "CloseMic fail DCTS_1100";
415 sleep(g_audioDelay);
416
417 ref = sinkSrv_->StopDistributedHardware(g_networkId);
418 EXPECT_EQ(0, ref) << "StopDistributedHardware fail DCTS_1100";
419
420 sinkSrv_->ReleaseSink();
421 }
422
423