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 #include "sink/file_audio_render_sink.h"
23
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace AudioStandard {
28 class FileAudioRenderSinkUnitTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 virtual void SetUp();
33 virtual void TearDown();
34
35 protected:
36 static uint32_t id_;
37 static std::shared_ptr<IAudioRenderSink> sink_;
38 static IAudioSinkAttr attr_;
39 };
40
41 uint32_t FileAudioRenderSinkUnitTest::id_ = HDI_INVALID_ID;
42 std::shared_ptr<IAudioRenderSink> FileAudioRenderSinkUnitTest::sink_ = nullptr;
43 IAudioSinkAttr FileAudioRenderSinkUnitTest::attr_ = {};
44
SetUpTestCase()45 void FileAudioRenderSinkUnitTest::SetUpTestCase()
46 {
47 id_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_FILE, "test", true);
48 }
49
TearDownTestCase()50 void FileAudioRenderSinkUnitTest::TearDownTestCase()
51 {
52 HdiAdapterManager::GetInstance().ReleaseId(id_);
53 }
54
SetUp()55 void FileAudioRenderSinkUnitTest::SetUp()
56 {
57 sink_ = HdiAdapterManager::GetInstance().GetRenderSink(id_, true);
58 if (sink_ == nullptr) {
59 return;
60 }
61 attr_.filePath = "/data/log/hilog/test.txt";
62 sink_->Init(attr_);
63 }
64
TearDown()65 void FileAudioRenderSinkUnitTest::TearDown()
66 {
67 if (sink_ && sink_->IsInited()) {
68 sink_->DeInit();
69 }
70 sink_ = nullptr;
71 }
72
73 /**
74 * @tc.name : Test FileSink API
75 * @tc.number : FileSinkUnitTest_001
76 * @tc.desc : Test file sink create
77 */
78 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_001, TestSize.Level1)
79 {
80 EXPECT_TRUE(sink_ && sink_->IsInited());
81 }
82
83 /**
84 * @tc.name : Test FileSink API
85 * @tc.number : FileSinkUnitTest_002
86 * @tc.desc : Test file sink init
87 */
88 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_002, TestSize.Level1)
89 {
90 EXPECT_TRUE(sink_ && sink_->IsInited());
91 sink_->DeInit();
92 int32_t ret = sink_->Init(attr_);
93 EXPECT_EQ(ret, SUCCESS);
94 ret = sink_->Init(attr_);
95 EXPECT_EQ(ret, SUCCESS);
96 EXPECT_TRUE(sink_->IsInited());
97 }
98
99 /**
100 * @tc.name : Test FileSink API
101 * @tc.number : FileSinkUnitTest_003
102 * @tc.desc : Test file sink start, stop, resume, pause, flush, reset
103 */
104 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_003, TestSize.Level1)
105 {
106 EXPECT_TRUE(sink_ && sink_->IsInited());
107 int32_t ret = sink_->Start();
108 EXPECT_EQ(ret, SUCCESS);
109 ret = sink_->Stop();
110 EXPECT_EQ(ret, SUCCESS);
111 ret = sink_->Resume();
112 EXPECT_EQ(ret, SUCCESS);
113 ret = sink_->Pause();
114 EXPECT_EQ(ret, SUCCESS);
115 ret = sink_->Flush();
116 EXPECT_EQ(ret, SUCCESS);
117 ret = sink_->Reset();
118 EXPECT_EQ(ret, SUCCESS);
119 ret = sink_->Stop();
120 EXPECT_EQ(ret, SUCCESS);
121 sink_->DeInit();
122 attr_.filePath = "/invalid_path/test.txt";
123 sink_->Init(attr_);
124 ret = sink_->Start();
125 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
126 ret = sink_->Stop();
127 EXPECT_EQ(ret, SUCCESS);
128 }
129
130 /**
131 * @tc.name : Test FileSink API
132 * @tc.number : FileSinkUnitTest_004
133 * @tc.desc : Test file sink render frame
134 */
135 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_004, TestSize.Level1)
136 {
137 EXPECT_TRUE(sink_ && sink_->IsInited());
138 uint64_t writeLen = 0;
139 std::vector<char> buffer{'8', '8', '8', '8', '8', '8', '8', '8'};
140 int32_t ret = sink_->Start();
141 EXPECT_EQ(ret, SUCCESS);
142 ret = sink_->RenderFrame(*buffer.data(), buffer.size(), writeLen);
143 EXPECT_EQ(ret, SUCCESS);
144 sink_->SetAudioMonoState(false);
145 sink_->SetAudioBalanceValue(false);
146 ret = sink_->RenderFrame(*buffer.data(), buffer.size(), writeLen);
147 EXPECT_EQ(ret, SUCCESS);
148 ret = sink_->Stop();
149 EXPECT_EQ(ret, SUCCESS);
150 }
151
152 /**
153 * @tc.name : Test FileSink API
154 * @tc.number : FileSinkUnitTest_005
155 * @tc.desc : Test file sink suspend, restore
156 */
157 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_005, TestSize.Level1)
158 {
159 EXPECT_TRUE(sink_ && sink_->IsInited());
160 int32_t ret = sink_->SuspendRenderSink();
161 EXPECT_EQ(ret, SUCCESS);
162 ret = sink_->RestoreRenderSink();
163 EXPECT_EQ(ret, SUCCESS);
164 }
165
166 /**
167 * @tc.name : Test FileSink API
168 * @tc.number : FileSinkUnitTest_006
169 * @tc.desc : Test file sink set/get param
170 */
171 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_006, TestSize.Level1)
172 {
173 EXPECT_TRUE(sink_ && sink_->IsInited());
174 sink_->SetAudioParameter(NONE, "", "");
175 std::string param = sink_->GetAudioParameter(NONE, "");
176 EXPECT_EQ(param, "");
177 }
178
179 /**
180 * @tc.name : Test DirectSink API
181 * @tc.number : FileSinkUnitTest_007
182 * @tc.desc : Test file sink set/get volume
183 */
184 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_007, TestSize.Level1)
185 {
186 EXPECT_TRUE(sink_ && sink_->IsInited());
187 int32_t ret = sink_->SetVolume(0.0f, 0.0f);
188 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
189 float left;
190 float right;
191 ret = sink_->GetVolume(left, right);
192 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
193 }
194
195 /**
196 * @tc.name : Test FileSink API
197 * @tc.number : FileSinkUnitTest_008
198 * @tc.desc : Test file sink set/get audio scene
199 */
200 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_008, TestSize.Level1)
201 {
202 EXPECT_TRUE(sink_ && sink_->IsInited());
203 int32_t ret = sink_->SetAudioScene(AUDIO_SCENE_DEFAULT);
204 EXPECT_EQ(ret, SUCCESS);
205 ret = sink_->GetAudioScene();
206 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
207 }
208
209 /**
210 * @tc.name : Test FileSink API
211 * @tc.number : FileSinkUnitTest_009
212 * @tc.desc : Test file sink update active device
213 */
214 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_009, TestSize.Level1)
215 {
216 EXPECT_TRUE(sink_ && sink_->IsInited());
217 std::vector<DeviceType> deviceTypes = { DEVICE_TYPE_SPEAKER };
218 int32_t ret = sink_->UpdateActiveDevice(deviceTypes);
219 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
220 }
221
222 /**
223 * @tc.name : Test FileSink API
224 * @tc.number : FileSinkUnitTest_010
225 * @tc.desc : Test file sink update apps uid
226 */
227 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_010, TestSize.Level1)
228 {
229 EXPECT_TRUE(sink_&& sink_->IsInited());
230 vector<int32_t> appsUid;
231 int32_t ret = sink_->UpdateAppsUid(appsUid);
232 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
233 int32_t appsUidArr[10] = { 0 }; // 10: array size
234 ret = sink_->UpdateAppsUid(appsUidArr, 10); // 10: array size
235 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
236 }
237
238 /**
239 * @tc.name : Test FileSink API
240 * @tc.number : FileSinkUnitTest_011
241 * @tc.desc : Test file sink dump info
242 */
243 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_011, TestSize.Level1)
244 {
245 EXPECT_TRUE(sink_&& sink_->IsInited());
246 std::string info;
247 sink_->DumpInfo(info);
248 EXPECT_EQ(info.empty(), false);
249 }
250
251 /**
252 * @tc.name : Test FileSink API
253 * @tc.number : FileSinkUnitTest_012
254 * @tc.desc : Test file sink start with file
255 */
256 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_012, TestSize.Level1)
257 {
258 FileAudioRenderSink fileSink;
259 fileSink.filePath_ = "/data/data/utTestFilel.pcm";
260 int32_t res = fileSink.Start();
261 EXPECT_EQ(res, SUCCESS);
262
263 res = fileSink.Stop();
264 EXPECT_EQ(res, SUCCESS);
265
266 fileSink.DeInit();
267 }
268
269 /**
270 * @tc.name : Test FileSink API
271 * @tc.number : FileSinkUnitTest_013
272 * @tc.desc : Test file sink start without file
273 */
274 HWTEST_F(FileAudioRenderSinkUnitTest, FileSinkUnitTest_013, TestSize.Level1)
275 {
276 FileAudioRenderSink fileSink;
277 fileSink.filePath_ = "/data/data/utTestFilel.pcm";
278 int32_t res = fileSink.Start();
279 EXPECT_NE(res, SUCCESS);
280
281 res = fileSink.Stop();
282 EXPECT_EQ(res, SUCCESS);
283
284 fileSink.DeInit();
285 }
286
287 } // namespace AudioStandard
288 } // namespace OHOS
289