1 /*
2 * Copyright (c) 2025 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 <iostream>
17 #include <gtest/gtest.h>
18 #include <gmock/gmock.h>
19 #include "audio_utils.h"
20 #include "common/hdi_adapter_info.h"
21 #include "manager/hdi_adapter_manager.h"
22
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace AudioStandard {
27 class BluetoothAudioRenderSinkUnitTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31 virtual void SetUp();
32 virtual void TearDown();
33
34 protected:
35 static uint32_t id_;
36 static std::shared_ptr<IAudioRenderSink> sink_;
37 static IAudioSinkAttr attr_;
38 static uint32_t hearingAidId_;
39 static std::shared_ptr<IAudioRenderSink> hearingAidSink_;
40 };
41
42 uint32_t BluetoothAudioRenderSinkUnitTest::id_ = HDI_INVALID_ID;
43 std::shared_ptr<IAudioRenderSink> BluetoothAudioRenderSinkUnitTest::sink_ = nullptr;
44 IAudioSinkAttr BluetoothAudioRenderSinkUnitTest::attr_ = {};
45 uint32_t BluetoothAudioRenderSinkUnitTest::hearingAidId_ = HDI_INVALID_ID;
46 std::shared_ptr<IAudioRenderSink> BluetoothAudioRenderSinkUnitTest::hearingAidSink_ = nullptr;
47
SetUpTestCase()48 void BluetoothAudioRenderSinkUnitTest::SetUpTestCase()
49 {
50 id_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_BLUETOOTH, HDI_ID_INFO_DEFAULT, true);
51 hearingAidId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER,
52 HDI_ID_TYPE_BLUETOOTH, HDI_ID_INFO_HEARING_AID, true);
53 }
54
TearDownTestCase()55 void BluetoothAudioRenderSinkUnitTest::TearDownTestCase()
56 {
57 HdiAdapterManager::GetInstance().ReleaseId(id_);
58 HdiAdapterManager::GetInstance().ReleaseId(hearingAidId_);
59 }
60
SetUp()61 void BluetoothAudioRenderSinkUnitTest::SetUp()
62 {
63 sink_ = HdiAdapterManager::GetInstance().GetRenderSink(id_, true);
64 if (sink_ == nullptr) {
65 return;
66 }
67 attr_.adapterName = "bt_a2dp";
68 attr_.channel = 2; // 2: channel
69 sink_->Init(attr_);
70 }
71
TearDown()72 void BluetoothAudioRenderSinkUnitTest::TearDown()
73 {
74 if (sink_ && sink_->IsInited()) {
75 sink_->DeInit();
76 }
77 sink_ = nullptr;
78 }
79
80 /**
81 * @tc.name : Test BluetoothSink API
82 * @tc.number : BluetoothSinkUnitTest_001
83 * @tc.desc : Test bluetooth sink create
84 */
85 HWTEST_F(BluetoothAudioRenderSinkUnitTest, BluetoothSinkUnitTest_001, TestSize.Level1)
86 {
87 EXPECT_TRUE(sink_);
88 }
89
90 /**
91 * @tc.name : Test BluetoothSink API
92 * @tc.number : BluetoothSinkUnitTest_002
93 * @tc.desc : Test bluetooth sink init/deinit
94 */
95 HWTEST_F(BluetoothAudioRenderSinkUnitTest, BluetoothSinkUnitTest_002, TestSize.Level1)
96 {
97 EXPECT_TRUE(sink_);
98 sink_->DeInit();
99 (void)sink_->Init(attr_);
100 (void)sink_->Init(attr_);
101 sink_->DeInit();
102 EXPECT_FALSE(sink_->IsInited());
103 }
104
105 /**
106 * @tc.name : Test BluetoothSink API
107 * @tc.number : BluetoothSinkUnitTest_003
108 * @tc.desc : Test bluetooth sink start, stop, resume, pause, flush, reset
109 */
110 HWTEST_F(BluetoothAudioRenderSinkUnitTest, BluetoothSinkUnitTest_003, TestSize.Level1)
111 {
112 EXPECT_TRUE(sink_);
113 int32_t ret = sink_->Start();
114 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
115 ret = sink_->Stop();
116 EXPECT_EQ(ret, SUCCESS);
117 ret = sink_->Resume();
118 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
119 ret = sink_->Pause();
120 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
121 ret = sink_->Flush();
122 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
123 ret = sink_->Reset();
124 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
125 ret = sink_->Stop();
126 EXPECT_EQ(ret, SUCCESS);
127 }
128
129 /**
130 * @tc.name : Test DirectSink API
131 * @tc.number : BluetoothSinkUnitTest_004
132 * @tc.desc : Test bluetooth sink set/get volume
133 */
134 HWTEST_F(BluetoothAudioRenderSinkUnitTest, BluetoothSinkUnitTest_004, TestSize.Level1)
135 {
136 EXPECT_TRUE(sink_);
137 int32_t ret = sink_->SetVolume(0.0f, 0.0f);
138 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
139 ret = sink_->SetVolume(0.0f, 1.0f);
140 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
141 ret = sink_->SetVolume(1.0f, 0.0f);
142 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
143 ret = sink_->SetVolume(1.0f, 1.0f);
144 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
145 float left;
146 float right;
147 ret = sink_->GetVolume(left, right);
148 EXPECT_EQ(ret, SUCCESS);
149 }
150
151 /**
152 * @tc.name : Test BluetoothSink API
153 * @tc.number : BluetoothSinkUnitTest_005
154 * @tc.desc : Test bluetooth sink set audio scene
155 */
156 HWTEST_F(BluetoothAudioRenderSinkUnitTest, BluetoothSinkUnitTest_005, TestSize.Level1)
157 {
158 EXPECT_TRUE(sink_);
159 int32_t ret = sink_->SetAudioScene(AUDIO_SCENE_DEFAULT);
160 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
161 }
162
163 /**
164 * @tc.name : Test BluetoothSink API
165 * @tc.number : BluetoothSinkUnitTest_006
166 * @tc.desc : Test bluetooth sink update active device
167 */
168 HWTEST_F(BluetoothAudioRenderSinkUnitTest, BluetoothSinkUnitTest_006, TestSize.Level1)
169 {
170 EXPECT_TRUE(sink_);
171 std::vector<DeviceType> deviceTypes = { DEVICE_TYPE_SPEAKER };
172 int32_t ret = sink_->UpdateActiveDevice(deviceTypes);
173 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
174 }
175
176 /**
177 * @tc.name : Test BluetoothSink API
178 * @tc.number : BluetoothSinkUnitTest_007
179 * @tc.desc : Test bluetooth sink set invalid state
180 */
181 HWTEST_F(BluetoothAudioRenderSinkUnitTest, BluetoothSinkUnitTest_007, TestSize.Level1)
182 {
183 EXPECT_TRUE(sink_);
184 sink_->SetInvalidState();
185 (void)sink_->Init(attr_);
186 sink_->DeInit();
187 EXPECT_FALSE(sink_->IsInited());
188 }
189
190 /**
191 * @tc.name : Test BluetoothSink API
192 * @tc.number : BluetoothSinkUnitTest_008
193 * @tc.desc : Test bluetooth sink set invalid state
194 */
195 HWTEST_F(BluetoothAudioRenderSinkUnitTest, BluetoothSinkUnitTest_008, TestSize.Level1)
196 {
197 hearingAidSink_ = HdiAdapterManager::GetInstance().GetRenderSink(hearingAidId_, true);
198 EXPECT_TRUE(hearingAidSink_);
199
200 attr_.adapterName = "hearing_aid";
201 attr_.channel = 2;
202 attr_.sampleRate = 16000;
203 attr_.format = SAMPLE_S16LE;
204 attr_.deviceType = DEVICE_TYPE_HEARING_AID;
205 hearingAidSink_->Init(attr_);
206
207 hearingAidSink_->SetInvalidState();
208 (void)hearingAidSink_->Init(attr_);
209 hearingAidSink_->DeInit();
210 EXPECT_FALSE(hearingAidSink_->IsInited());
211 hearingAidSink_ = nullptr;
212 }
213
214 /**
215 * @tc.name : Test BluetoothSink API
216 * @tc.number : BluetoothSinkUnitTest_009
217 * @tc.desc : Test bluetooth sink IsSinkInited
218 */
219 HWTEST_F(BluetoothAudioRenderSinkUnitTest, BluetoothSinkUnitTest_009, TestSize.Level1)
220 {
221 EXPECT_TRUE(sink_);
222 EXPECT_TRUE(sink_->IsSinkInited());
223 sink_->DeInit();
224 EXPECT_FALSE(sink_->IsInited());
225 EXPECT_FALSE(sink_->IsSinkInited());
226 }
227
228 } // namespace AudioStandard
229 } // namespace OHOS
230