1 /*
2 * Copyright (c) 2023 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 "daudio_utils_test.h"
17
18 #include <thread>
19
20 #include "securec.h"
21
22 #include "daudio_constants.h"
23 #include "daudio_errorcode.h"
24 #include "daudio_latency_test.h"
25 #include "daudio_log.h"
26 #include "daudio_util.h"
27
28 #undef DH_LOG_TAG
29 #define DH_LOG_TAG "DAudioUtilsTest"
30
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace DistributedHardware {
35 constexpr static int64_t TEMP_BEEP_TIME_INTERVAL_US = 10000; // 10ms
36 constexpr static int64_t MIN_BEEP_TIME_INTERVAL_US = 900000; // 900ms
37
SetUpTestCase(void)38 void DAudioUtilsTest::SetUpTestCase(void) {}
39
TearDownTestCase(void)40 void DAudioUtilsTest::TearDownTestCase(void) {}
41
SetUp(void)42 void DAudioUtilsTest::SetUp(void) {}
43
TearDown(void)44 void DAudioUtilsTest::TearDown(void) {}
45
46 /**
47 * @tc.name: DAudioLatencyTest_001
48 * @tc.desc: Verify the DAudioLatencyTest AddPlayTime, AddRecordTime and ComputeLatency function.
49 * @tc.type: FUNC
50 * @tc.require: AR000H0E5U
51 */
52 HWTEST_F(DAudioUtilsTest, DAudioLatencyTest_001, TestSize.Level1)
53 {
54 int32_t latency = DAudioLatencyTest::GetInstance().ComputeLatency();
55 EXPECT_EQ(-1, latency);
56
57 int64_t t = GetNowTimeUs();
58 EXPECT_EQ(ERR_DH_AUDIO_BAD_VALUE, DAudioLatencyTest::GetInstance().AddRecordTime(t));
59
60 t = GetNowTimeUs();
61 EXPECT_EQ(DH_SUCCESS, DAudioLatencyTest::GetInstance().AddPlayTime(t));
62 EXPECT_EQ(ERR_DH_AUDIO_FAILED, DAudioLatencyTest::GetInstance().AddPlayTime(t + TEMP_BEEP_TIME_INTERVAL_US));
63
64 std::this_thread::sleep_for(std::chrono::microseconds(MIN_BEEP_TIME_INTERVAL_US));
65 t = GetNowTimeUs();
66 EXPECT_EQ(DH_SUCCESS, DAudioLatencyTest::GetInstance().AddPlayTime(t));
67
68 t = GetNowTimeUs();
69 EXPECT_EQ(DH_SUCCESS, DAudioLatencyTest::GetInstance().AddRecordTime(t));
70 EXPECT_EQ(ERR_DH_AUDIO_FAILED, DAudioLatencyTest::GetInstance().AddRecordTime(t + TEMP_BEEP_TIME_INTERVAL_US));
71
72 latency = DAudioLatencyTest::GetInstance().ComputeLatency();
73 EXPECT_EQ(-1, latency);
74
75 std::this_thread::sleep_for(std::chrono::microseconds(MIN_BEEP_TIME_INTERVAL_US));
76 t = GetNowTimeUs();
77 EXPECT_EQ(DH_SUCCESS, DAudioLatencyTest::GetInstance().AddRecordTime(t));
78
79 latency = DAudioLatencyTest::GetInstance().ComputeLatency();
80 EXPECT_LE(0, latency);
81 }
82
83 /**
84 * @tc.name: DAudioLatencyTest_002
85 * @tc.desc: Verify the DAudioLatencyTest IsFrameHigh function.
86 * @tc.type: FUNC
87 * @tc.require: AR000H0E5U
88 */
89 HWTEST_F(DAudioUtilsTest, DAudioLatencyTest_002, TestSize.Level1)
90 {
91 int32_t threshhold = 5000;
92 int32_t spanSizeInByte = 960;
93 std::unique_ptr<uint8_t[]> buf = std::make_unique<uint8_t[]>(spanSizeInByte);
94 memset_s(buf.get(), spanSizeInByte, 0, spanSizeInByte);
95 bool isHigh = DAudioLatencyTest::GetInstance().IsFrameHigh(reinterpret_cast<int16_t *>(buf.get()),
96 spanSizeInByte / sizeof(int16_t), threshhold);
97 EXPECT_EQ(false, isHigh);
98
99 memset_s(buf.get(), spanSizeInByte, threshhold, spanSizeInByte);
100 isHigh = DAudioLatencyTest::GetInstance().IsFrameHigh(reinterpret_cast<int16_t *>(buf.get()),
101 spanSizeInByte / sizeof(int16_t), threshhold);
102 EXPECT_EQ(true, isHigh);
103 }
104
105 /**
106 * @tc.name: DAudioLatencyTest_003
107 * @tc.desc: Verify the DAudioLatencyTest IsFrameHigh function.
108 * @tc.type: FUNC
109 * @tc.require: AR000H0E5U
110 */
111 HWTEST_F(DAudioUtilsTest, DAudioLatencyTest_003, TestSize.Level1)
112 {
113 bool status = true;
114 int32_t threshhold = 8000;
115 int32_t spanSizeInByte = 960;
116 std::unique_ptr<uint8_t[]> buf = std::make_unique<uint8_t[]>(spanSizeInByte);
117 memset_s(buf.get(), spanSizeInByte, threshhold, spanSizeInByte);
118 int64_t beepTime = DAudioLatencyTest::GetInstance().RecordBeepTime(static_cast<uint8_t *>(buf.get()),
119 spanSizeInByte, status);
120 EXPECT_NE(0, beepTime);
121 EXPECT_EQ(false, status);
122
123 memset_s(buf.get(), spanSizeInByte, 0, spanSizeInByte);
124 beepTime = DAudioLatencyTest::GetInstance().RecordBeepTime(static_cast<uint8_t *>(buf.get()),
125 spanSizeInByte, status);
126 EXPECT_EQ(0, beepTime);
127 EXPECT_EQ(true, status);
128 }
129
130 /**
131 * @tc.name: DAudioLogTest_001
132 * @tc.desc: Verify the DHLOG definition and DHLog function.
133 * @tc.type: FUNC
134 * @tc.require: AR000H0E5U
135 */
136 HWTEST_F(DAudioUtilsTest, DAudioLogTest_001, TestSize.Level1)
137 {
138 DHLOGD("DAudio TDD test DHLOGD print.");
139 DHLOGI("DAudio TDD test DHLOGI print.");
140 DHLOGW("DAudio TDD test DHLOGW print.");
141 DHLOGE("DAudio TDD test DHLOGE print.");
142 DHLog(DHLogLevel::DH_LOG_ERROR, "");
143 }
144
145 /**
146 * @tc.name: DAudioLogTest_001
147 * @tc.desc: Verify the GetCurrentTime function.
148 * @tc.type: FUNC
149 * @tc.require: AR000H0E5U
150 */
151 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_001, TestSize.Level1)
152 {
153 int64_t tvSec;
154 int64_t tvNSec;
155 GetCurrentTime(tvSec, tvNSec);
156 }
157
158 /**
159 * @tc.name: DAudioLogTest_002
160 * @tc.desc: Verify the GetCurrentTime, GetCurNano and AbsoluteSleep function.
161 * @tc.type: FUNC
162 * @tc.require: AR000H0E5U
163 */
164 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_002, TestSize.Level1)
165 {
166 int64_t tvSec;
167 int64_t tvNSec;
168 GetCurrentTime(tvSec, tvNSec);
169
170 int64_t curNano = GetCurNano();
171 EXPECT_NE(0, curNano);
172
173 int32_t ret = AbsoluteSleep(curNano);
174 EXPECT_EQ(0, ret);
175 }
176
177 /**
178 * @tc.name: DAudioLogTest_003
179 * @tc.desc: Verify the CalculateSampleNum and UpdateTimeOffset function.
180 * @tc.type: FUNC
181 * @tc.require: AR000H0E5U
182 */
183 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_003, TestSize.Level1)
184 {
185 uint32_t sampleRate = 48000;
186 uint32_t timeInterval = 5;
187 int32_t desiredSpanSizeInFrame = 240;
188 int32_t spanSizeInFrame = CalculateSampleNum(sampleRate, timeInterval);
189 EXPECT_EQ(desiredSpanSizeInFrame, spanSizeInFrame);
190
191 int64_t frameIndex = 0;
192 int64_t framePeriodNs = 5000000;
193 int64_t startTime = 0;
194 int64_t timeOffset = UpdateTimeOffset(frameIndex, framePeriodNs, startTime);
195 EXPECT_NE(0, startTime);
196 EXPECT_EQ(0, timeOffset);
197
198 frameIndex = AUDIO_OFFSET_FRAME_NUM / 2;
199 timeOffset = UpdateTimeOffset(frameIndex, framePeriodNs, startTime);
200 EXPECT_EQ(0, timeOffset);
201
202 frameIndex = AUDIO_OFFSET_FRAME_NUM;
203 timeOffset = UpdateTimeOffset(frameIndex, framePeriodNs, startTime);
204 EXPECT_NE(0, timeOffset);
205 }
206
207 /**
208 * @tc.name: DAudioLogTest_004
209 * @tc.desc: Verify the GetAudioParamBool function.
210 * @tc.type: FUNC
211 * @tc.require: AR000H0E5U
212 */
213 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_004, TestSize.Level1)
214 {
215 std::string params = "";
216 std::string key = "";
217 bool value = false;
218 EXPECT_EQ(ERR_DH_AUDIO_FAILED, GetAudioParamBool(params, key, value));
219
220 params = "params";
221 key = "key";
222 EXPECT_EQ(ERR_DH_AUDIO_NOT_FOUND_KEY, GetAudioParamBool(params, key, value));
223
224 params = "key=0";
225 EXPECT_EQ(DH_SUCCESS, GetAudioParamBool(params, key, value));
226 EXPECT_EQ(false, value);
227
228 params = "param1=true;key=1;param2=false;";
229 EXPECT_EQ(DH_SUCCESS, GetAudioParamBool(params, key, value));
230 EXPECT_EQ(true, value);
231 }
232
233 /**
234 * @tc.name: DAudioLogTest_005
235 * @tc.desc: Verify the GetAudioParamInt function.
236 * @tc.type: FUNC
237 * @tc.require: AR000H0E5U
238 */
239 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_005, TestSize.Level1)
240 {
241 std::string params = "";
242 std::string key = "";
243 int32_t value = 5;
244 EXPECT_EQ(ERR_DH_AUDIO_FAILED, GetAudioParamInt(params, key, value));
245
246 params = "params";
247 key = "key";
248 EXPECT_EQ(ERR_DH_AUDIO_NOT_FOUND_KEY, GetAudioParamInt(params, key, value));
249
250 params = "key=0";
251 EXPECT_EQ(DH_SUCCESS, GetAudioParamInt(params, key, value));
252 EXPECT_EQ(0, value);
253
254 params = "param1=true;key=1;param2=false;";
255 EXPECT_EQ(DH_SUCCESS, GetAudioParamInt(params, key, value));
256 EXPECT_EQ(1, value);
257 }
258
259 /**
260 * @tc.name: DAudioLogTest_006
261 * @tc.desc: Verify the JsonParamCheck function.
262 * @tc.type: FUNC
263 * @tc.require: AR000H0E5U
264 */
265 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_006, TestSize.Level1)
266 {
267 std::string tempKey = "TestParam";
268 json jParam = { { KEY_DEV_ID, "TEST_DEV_ID" }, {KEY_AUDIO_PARAM, "TEST_PARAM" }, {KEY_FORMAT, "TEST_8000" },
269 { tempKey, "TEST_TEMP_KEY" } };
270 EXPECT_EQ(false, JsonParamCheck(jParam, { KEY_ATTRS }));
271 EXPECT_EQ(false, JsonParamCheck(jParam, { KEY_AUDIO_PARAM }));
272 EXPECT_EQ(false, JsonParamCheck(jParam, { KEY_FORMAT }));
273 EXPECT_EQ(false, JsonParamCheck(jParam, { tempKey }));
274 EXPECT_EQ(true, JsonParamCheck(jParam, { KEY_DEV_ID }));
275 }
276
277 /**
278 * @tc.name: DAudioLogTest_007
279 * @tc.desc: Verify the CheckIsNum and CheckDevIdIsLegal function.
280 * @tc.type: FUNC
281 * @tc.require: AR000H0E5U
282 */
283 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_007, TestSize.Level1)
284 {
285 uint8_t maxDhIdLen = 20;
286 std::string tempDhIdStr(maxDhIdLen + 1, 'a');
287 EXPECT_EQ(false, CheckIsNum(tempDhIdStr));
288
289 tempDhIdStr = "";
290 EXPECT_EQ(false, CheckIsNum(tempDhIdStr));
291
292 tempDhIdStr = "TestParams";
293 EXPECT_EQ(false, CheckIsNum(tempDhIdStr));
294
295 tempDhIdStr = "1";
296 EXPECT_EQ(true, CheckIsNum(tempDhIdStr));
297
298 std::string tempDevIdStr(DAUDIO_MAX_DEVICE_ID_LEN + 1, 'a');
299 EXPECT_EQ(false, CheckDevIdIsLegal(tempDevIdStr));
300
301 tempDevIdStr = "";
302 EXPECT_EQ(false, CheckDevIdIsLegal(tempDevIdStr));
303
304 tempDevIdStr = "Test*Params#";
305 EXPECT_EQ(false, CheckDevIdIsLegal(tempDevIdStr));
306
307 tempDevIdStr = "Test1";
308 EXPECT_EQ(true, CheckDevIdIsLegal(tempDevIdStr));
309 }
310 } // namespace DistributedHardware
311 } // namespace OHOS
312