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 <gmock/gmock.h>
18
19 #include "audio_service_log.h"
20 #include "audio_service.h"
21 #include "audio_errors.h"
22 #include "audio_process_in_client.h"
23 #include "audio_process_in_client.cpp"
24
25 using namespace testing::ext;
26 using namespace testing;
27
28 namespace OHOS {
29 namespace AudioStandard {
30
31 class AudioProcessInClientUnitTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 };
38
39 constexpr int32_t DEFAULT_STREAM_ID = 10;
40 constexpr size_t NUMBER1 = 1;
41 constexpr size_t NUMBER2 = 2;
42 constexpr size_t NUMBER4 = 4;
43 constexpr size_t NUMBER6 = 6;
44 constexpr size_t NUMBER8 = 8;
45
InitProcessConfig()46 static AudioProcessConfig InitProcessConfig()
47 {
48 AudioProcessConfig config;
49 config.appInfo.appUid = DEFAULT_STREAM_ID;
50 config.appInfo.appPid = DEFAULT_STREAM_ID;
51 config.streamInfo.format = SAMPLE_S32LE;
52 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
53 config.streamInfo.channels = STEREO;
54 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
55 config.audioMode = AudioMode::AUDIO_MODE_RECORD;
56 config.streamType = AudioStreamType::STREAM_MUSIC;
57 config.deviceType = DEVICE_TYPE_USB_HEADSET;
58 return config;
59 }
60
61 class ClientUnderrunCallBackTest : public ClientUnderrunCallBack {
62 virtual ~ClientUnderrunCallBackTest() = default;
63
64 /**
65 * Callback function when underrun occurs.
66 *
67 * @param posInFrames Indicates the postion when client handle underrun in frames.
68 */
OnUnderrun(size_t posInFrames)69 virtual void OnUnderrun(size_t posInFrames) {}
70 };
71
72 class AudioDataCallbackTest : public AudioDataCallback {
73 public:
74 virtual ~AudioDataCallbackTest() = default;
75
76 /**
77 * Called when request handle data.
78 *
79 * @param length Indicates requested buffer length.
80 */
OnHandleData(size_t length)81 virtual void OnHandleData(size_t length) {}
82 };
83
84 /**
85 * @tc.name : Test GetPredictNextHandleTime API
86 * @tc.type : FUNC
87 * @tc.number: GetPredictNextHandleTime_001
88 * @tc.desc : Test GetPredictNextHandleTime
89 */
90 HWTEST(AudioProcessInClientUnitTest, GetPredictNextHandleTime_001, TestSize.Level4)
91 {
92 AudioProcessConfig config = InitProcessConfig();
93 AudioService *g_audioServicePtr = AudioService::GetInstance();
94 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
95 bool isVoipMmap = true;
96 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
97 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
98 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
99
100 uint64_t posInFrame = 100;
101 bool isIndependent = false;
102 ptrAudioProcessInClientInner->spanSizeInFrame_ = 10;
103 ptrAudioProcessInClientInner->clientByteSizePerFrame_ = 0;
104 int64_t result = ptrAudioProcessInClientInner->GetPredictNextHandleTime(posInFrame, isIndependent);
105 EXPECT_NE(result, 0);
106 }
107
108 /**
109 * @tc.name : Test GetPredictNextHandleTime API
110 * @tc.type : FUNC
111 * @tc.number: GetPredictNextHandleTime_002
112 * @tc.desc : Test GetPredictNextHandleTime
113 */
114 HWTEST(AudioProcessInClientUnitTest, GetPredictNextHandleTime_002, TestSize.Level4)
115 {
116 AudioProcessConfig config = InitProcessConfig();
117 AudioService *g_audioServicePtr = AudioService::GetInstance();
118 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
119 bool isVoipMmap = true;
120 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
121 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
122 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
123
124 uint64_t posInFrame = 100;
125 bool isIndependent = true;
126 ptrAudioProcessInClientInner->spanSizeInFrame_ = 10;
127 ptrAudioProcessInClientInner->clientByteSizePerFrame_ = 0;
128 int64_t result = ptrAudioProcessInClientInner->GetPredictNextHandleTime(posInFrame, isIndependent);
129 EXPECT_NE(result, 0);
130 }
131
132 /**
133 * @tc.name : Test GetPredictNextHandleTime API
134 * @tc.type : FUNC
135 * @tc.number: GetPredictNextHandleTime_003
136 * @tc.desc : Test GetPredictNextHandleTime
137 */
138 HWTEST(AudioProcessInClientUnitTest, GetPredictNextHandleTime_003, TestSize.Level2)
139 {
140 AudioProcessConfig config = InitProcessConfig();
141 AudioService *g_audioServicePtr = AudioService::GetInstance();
142 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
143 bool isVoipMmap = true;
144 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
145 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
146 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
147
148 uint64_t posInFrame = 0;
149 bool isIndependent = true;
150 ptrAudioProcessInClientInner->spanSizeInFrame_ = 0;
151 ptrAudioProcessInClientInner->clientByteSizePerFrame_ = 0;
152 int64_t result = ptrAudioProcessInClientInner->GetPredictNextHandleTime(posInFrame, isIndependent);
153 EXPECT_EQ(result, 0);
154 }
155
156 /**
157 * @tc.name : Test GetPredictNextHandleTime API
158 * @tc.type : FUNC
159 * @tc.number: GetPredictNextHandleTime_004
160 * @tc.desc : Test GetPredictNextHandleTime
161 */
162 HWTEST(AudioProcessInClientUnitTest, GetPredictNextHandleTime_004, TestSize.Level4)
163 {
164 AudioProcessConfig config = InitProcessConfig();
165 AudioService *g_audioServicePtr = AudioService::GetInstance();
166 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
167 bool isVoipMmap = true;
168 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
169 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
170 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
171
172 uint64_t posInFrame = 100;
173 bool isIndependent = true;
174 ptrAudioProcessInClientInner->spanSizeInFrame_ = 0;
175 ptrAudioProcessInClientInner->clientByteSizePerFrame_ = 0;
176 int64_t result = ptrAudioProcessInClientInner->GetPredictNextHandleTime(posInFrame, isIndependent);
177 EXPECT_EQ(result, 0);
178 }
179
180 /**
181 * @tc.name : Test GetPredictNextHandleTime API
182 * @tc.type : FUNC
183 * @tc.number: GetPredictNextHandleTime_005
184 * @tc.desc : Test GetPredictNextHandleTime
185 */
186 HWTEST(AudioProcessInClientUnitTest, GetPredictNextHandleTime_005, TestSize.Level4)
187 {
188 AudioProcessConfig config = InitProcessConfig();
189 AudioService *g_audioServicePtr = AudioService::GetInstance();
190 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
191 bool isVoipMmap = true;
192 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
193 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
194 EXPECT_NE(ptrAudioProcessInClientInner, nullptr);
195
196 uint64_t posInFrame = 0;
197 bool isIndependent = false;
198 ptrAudioProcessInClientInner->spanSizeInFrame_ = 0;
199 ptrAudioProcessInClientInner->clientByteSizePerFrame_ = 0;
200 int64_t result = ptrAudioProcessInClientInner->GetPredictNextHandleTime(posInFrame, isIndependent);
201 EXPECT_EQ(result, 0);
202 }
203
204 /**
205 * @tc.name : Test ReadFromProcessClient API
206 * @tc.type : FUNC
207 * @tc.number: ReadFromProcessClient
208 * @tc.desc : Test AudioProcessInClientInner::ReadFromProcessClient
209 */
210 HWTEST(AudioProcessInClientUnitTest, ReadFromProcessClient_001, TestSize.Level1)
211 {
212 AudioProcessConfig config = InitProcessConfig();
213 AudioService *g_audioServicePtr = AudioService::GetInstance();
214 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
215 bool isVoipMmap = true;
216 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
217 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
218
219 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
220 ptrAudioProcessInClientInner -> spanSizeInByte_ = 0;
221
222 auto ret = ptrAudioProcessInClientInner->ReadFromProcessClient();
223 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
224 }
225
226 /**
227 * @tc.name : Test CopyWithVolume API
228 * @tc.type : FUNC
229 * @tc.number: CopyWithVolume_001
230 * @tc.desc : Test AudioProcessInClientInner::CopyWithVolume
231 */
232 HWTEST(AudioProcessInClientUnitTest, CopyWithVolume_001, TestSize.Level4)
233 {
234 AudioProcessConfig config = InitProcessConfig();
235 AudioService *g_audioServicePtr = AudioService::GetInstance();
236 sptr<AudioProcessInServer> processStream = AudioProcessInServer::Create(config, g_audioServicePtr);
237 bool isVoipMmap = true;
238 AudioStreamInfo info = {SAMPLE_RATE_48000, ENCODING_PCM, SAMPLE_S16LE, STEREO};
239 auto ptrAudioProcessInClientInner = std::make_shared<AudioProcessInClientInner>(processStream, isVoipMmap, info);
240 ASSERT_TRUE(ptrAudioProcessInClientInner != nullptr);
241
242 BufferDesc srcDesc;
243 BufferDesc dstDesc;
244 srcDesc.bufLength = 1;
245 dstDesc.bufLength = 1;
246 ptrAudioProcessInClientInner->CopyWithVolume(srcDesc, dstDesc);
247 }
248 } // namespace AudioStandard
249 } // namespace OHOSs