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