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 FileAudioCaptureSourceUnitTest : 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<IAudioCaptureSource> source_;
37 static IAudioSourceAttr attr_;
38 };
39
40 uint32_t FileAudioCaptureSourceUnitTest::id_ = HDI_INVALID_ID;
41 std::shared_ptr<IAudioCaptureSource> FileAudioCaptureSourceUnitTest::source_ = nullptr;
42 IAudioSourceAttr FileAudioCaptureSourceUnitTest::attr_ = {};
43
SetUpTestCase()44 void FileAudioCaptureSourceUnitTest::SetUpTestCase()
45 {
46 id_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_CAPTURE, HDI_ID_TYPE_FILE, "test", true);
47 }
48
TearDownTestCase()49 void FileAudioCaptureSourceUnitTest::TearDownTestCase()
50 {
51 HdiAdapterManager::GetInstance().ReleaseId(id_);
52 }
53
SetUp()54 void FileAudioCaptureSourceUnitTest::SetUp()
55 {
56 source_ = HdiAdapterManager::GetInstance().GetCaptureSource(id_, true);
57 if (source_ == nullptr) {
58 return;
59 }
60 attr_.filePath = "/data/log/hilog/test.txt";
61 source_->Init(attr_);
62 }
63
TearDown()64 void FileAudioCaptureSourceUnitTest::TearDown()
65 {
66 if (source_ && source_->IsInited()) {
67 source_->DeInit();
68 }
69 source_ = nullptr;
70 }
71
72 /**
73 * @tc.name : Test FileSource API
74 * @tc.number : FileSourceUnitTest_001
75 * @tc.desc : Test file source create
76 */
77 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_001, TestSize.Level1)
78 {
79 EXPECT_TRUE(source_ && source_->IsInited());
80 }
81
82 /**
83 * @tc.name : Test FileSource API
84 * @tc.number : FileSourceUnitTest_002
85 * @tc.desc : Test file source init
86 */
87 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_002, TestSize.Level1)
88 {
89 EXPECT_TRUE(source_ && source_->IsInited());
90 source_->DeInit();
91 int32_t ret = source_->Init(attr_);
92 EXPECT_EQ(ret, SUCCESS);
93 ret = source_->Init(attr_);
94 EXPECT_EQ(ret, SUCCESS);
95 EXPECT_TRUE(source_->IsInited());
96 }
97
98 /**
99 * @tc.name : Test FileSource API
100 * @tc.number : FileSourceUnitTest_003
101 * @tc.desc : Test file source start, stop, resume, pause, flush, reset
102 */
103 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_003, TestSize.Level1)
104 {
105 EXPECT_TRUE(source_ && source_->IsInited());
106 int32_t ret = source_->Start();
107 EXPECT_EQ(ret, SUCCESS);
108 ret = source_->Stop();
109 EXPECT_EQ(ret, SUCCESS);
110 ret = source_->Resume();
111 EXPECT_EQ(ret, SUCCESS);
112 ret = source_->Pause();
113 EXPECT_EQ(ret, SUCCESS);
114 ret = source_->Flush();
115 EXPECT_EQ(ret, SUCCESS);
116 ret = source_->Reset();
117 EXPECT_EQ(ret, SUCCESS);
118 ret = source_->Stop();
119 EXPECT_EQ(ret, SUCCESS);
120 }
121
122 /**
123 * @tc.name : Test FileSource API
124 * @tc.number : FileSourceUnitTest_004
125 * @tc.desc : Test file source capture frame
126 */
127 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_004, TestSize.Level1)
128 {
129 EXPECT_TRUE(source_ && source_->IsInited());
130 uint64_t replyBytes = 0;
131 uint64_t replyBytesEc = 0;
132 std::vector<char> buffer{'8', '8', '8', '8', '8', '8', '8', '8'};
133 std::vector<char> bufferEc{'8', '8', '8', '8', '8', '8', '8', '8'};
134 int32_t ret = source_->CaptureFrame(buffer.data(), buffer.size(), replyBytes);
135 EXPECT_EQ(ret, SUCCESS);
136 FrameDesc desc = {
137 .frame = buffer.data(),
138 .frameLen = buffer.size(),
139 };
140 FrameDesc descEc = {
141 .frame = bufferEc.data(),
142 .frameLen = bufferEc.size(),
143 };
144 ret = source_->CaptureFrameWithEc(&desc, replyBytes, &descEc, replyBytesEc);
145 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
146 }
147
148 /**
149 * @tc.name : Test DirectSource API
150 * @tc.number : FileSourceUnitTest_005
151 * @tc.desc : Test file source set/get volume
152 */
153 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_005, TestSize.Level1)
154 {
155 EXPECT_TRUE(source_ && source_->IsInited());
156 int32_t ret = source_->SetVolume(0.0f, 0.0f);
157 EXPECT_EQ(ret, SUCCESS);
158 float left;
159 float right;
160 ret = source_->GetVolume(left, right);
161 EXPECT_EQ(ret, SUCCESS);
162 }
163
164 /**
165 * @tc.name : Test FileSource API
166 * @tc.number : FileSourceUnitTest_006
167 * @tc.desc : Test file source set/get mute
168 */
169 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_006, TestSize.Level1)
170 {
171 EXPECT_TRUE(source_ && source_->IsInited());
172 int32_t ret = source_->SetMute(false);
173 EXPECT_EQ(ret, SUCCESS);
174 bool mute;
175 ret = source_->GetMute(mute);
176 EXPECT_EQ(ret, SUCCESS);
177 }
178
179 /**
180 * @tc.name : Test FileSource API
181 * @tc.number : FileSourceUnitTest_007
182 * @tc.desc : Test file source get transaction id
183 */
184 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_007, TestSize.Level1)
185 {
186 EXPECT_TRUE(source_ && source_->IsInited());
187 uint64_t transId = source_->GetTransactionId();
188 EXPECT_EQ(transId, -1);
189 }
190
191 /**
192 * @tc.name : Test FileSource API
193 * @tc.number : FileSourceUnitTest_008
194 * @tc.desc : Test file source get presentation position
195 */
196 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_008, TestSize.Level1)
197 {
198 EXPECT_TRUE(source_ && source_->IsInited());
199 uint64_t frame = 10;
200 int64_t timeSec = 10;
201 int64_t timeNanoSec = 10;
202 int32_t ret = source_->GetPresentationPosition(frame, timeSec, timeNanoSec);
203 EXPECT_EQ(ret, SUCCESS);
204 }
205
206 /**
207 * @tc.name : Test FileSource API
208 * @tc.number : FileSourceUnitTest_009
209 * @tc.desc : Test file source get max amplitude
210 */
211 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_009, TestSize.Level1)
212 {
213 EXPECT_TRUE(source_ && source_->IsInited());
214 float maxAmplitude = source_->GetMaxAmplitude();
215 EXPECT_EQ(maxAmplitude, 0.0f);
216 }
217
218 /**
219 * @tc.name : Test FileSource API
220 * @tc.number : FileSourceUnitTest_010
221 * @tc.desc : Test file source set audio scene
222 */
223 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_010, TestSize.Level1)
224 {
225 EXPECT_TRUE(source_ && source_->IsInited());
226 int32_t ret = source_->SetAudioScene(AUDIO_SCENE_DEFAULT);
227 EXPECT_EQ(ret, SUCCESS);
228 }
229
230 /**
231 * @tc.name : Test FileSource API
232 * @tc.number : FileSourceUnitTest_011
233 * @tc.desc : Test file source update active device
234 */
235 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_011, TestSize.Level1)
236 {
237 EXPECT_TRUE(source_ && source_->IsInited());
238 int32_t ret = source_->UpdateActiveDevice(DEVICE_TYPE_SPEAKER);
239 EXPECT_EQ(ret, SUCCESS);
240 }
241
242 /**
243 * @tc.name : Test FileSource API
244 * @tc.number : FileSourceUnitTest_012
245 * @tc.desc : Test file source update apps uid
246 */
247 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_012, TestSize.Level1)
248 {
249 EXPECT_TRUE(source_&& source_->IsInited());
250 vector<int32_t> appsUid;
251 int32_t ret = source_->UpdateAppsUid(appsUid);
252 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
253 int32_t appsUidArr[10] = { 0 }; // 10: array size
254 ret = source_->UpdateAppsUid(appsUidArr, 10); // 10: array size
255 EXPECT_EQ(ret, ERR_NOT_SUPPORTED);
256 }
257
258 /**
259 * @tc.name : Test FileSource API
260 * @tc.number : FileSourceUnitTest_013
261 * @tc.desc : Test file source dump info
262 */
263 HWTEST_F(FileAudioCaptureSourceUnitTest, FileSourceUnitTest_013, TestSize.Level1)
264 {
265 EXPECT_TRUE(source_&& source_->IsInited());
266 std::string info;
267 source_->DumpInfo(info);
268 EXPECT_EQ(info.empty(), false);
269 }
270
271 } // namespace AudioStandard
272 } // namespace OHOS
273