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 "cJSON.h"
21 #include "securec.h"
22
23 #include "daudio_constants.h"
24 #include "daudio_errorcode.h"
25 #include "daudio_latency_test.h"
26 #include "daudio_log.h"
27 #include "daudio_util.h"
28
29 #undef DH_LOG_TAG
30 #define DH_LOG_TAG "DAudioUtilsTest"
31
32 using namespace testing::ext;
33
34 namespace OHOS {
35 namespace DistributedHardware {
36 constexpr static int64_t TEMP_BEEP_TIME_INTERVAL_US = 10000; // 10ms
37 constexpr static int64_t MIN_BEEP_TIME_INTERVAL_US = 900000; // 900ms
38
SetUpTestCase(void)39 void DAudioUtilsTest::SetUpTestCase(void) {}
40
TearDownTestCase(void)41 void DAudioUtilsTest::TearDownTestCase(void) {}
42
SetUp(void)43 void DAudioUtilsTest::SetUp(void) {}
44
TearDown(void)45 void DAudioUtilsTest::TearDown(void) {}
46
47 /**
48 * @tc.name: DAudioLatencyTest_001
49 * @tc.desc: Verify the DAudioLatencyTest AddPlayTime, AddRecordTime and ComputeLatency function.
50 * @tc.type: FUNC
51 * @tc.require: AR000H0E5U
52 */
53 HWTEST_F(DAudioUtilsTest, DAudioLatencyTest_001, TestSize.Level1)
54 {
55 int32_t latency = DAudioLatencyTest::GetInstance().ComputeLatency();
56 EXPECT_EQ(-1, latency);
57
58 int64_t t = GetNowTimeUs();
59 EXPECT_EQ(ERR_DH_AUDIO_BAD_VALUE, DAudioLatencyTest::GetInstance().AddRecordTime(t));
60
61 t = GetNowTimeUs();
62 EXPECT_EQ(DH_SUCCESS, DAudioLatencyTest::GetInstance().AddPlayTime(t));
63 EXPECT_EQ(ERR_DH_AUDIO_FAILED, DAudioLatencyTest::GetInstance().AddPlayTime(t + TEMP_BEEP_TIME_INTERVAL_US));
64
65 std::this_thread::sleep_for(std::chrono::microseconds(MIN_BEEP_TIME_INTERVAL_US));
66 t = GetNowTimeUs();
67 EXPECT_EQ(DH_SUCCESS, DAudioLatencyTest::GetInstance().AddPlayTime(t));
68
69 t = GetNowTimeUs();
70 EXPECT_EQ(DH_SUCCESS, DAudioLatencyTest::GetInstance().AddRecordTime(t));
71 EXPECT_EQ(ERR_DH_AUDIO_FAILED, DAudioLatencyTest::GetInstance().AddRecordTime(t + TEMP_BEEP_TIME_INTERVAL_US));
72
73 latency = DAudioLatencyTest::GetInstance().ComputeLatency();
74 EXPECT_EQ(-1, latency);
75
76 std::this_thread::sleep_for(std::chrono::microseconds(MIN_BEEP_TIME_INTERVAL_US));
77 t = GetNowTimeUs();
78 EXPECT_EQ(DH_SUCCESS, DAudioLatencyTest::GetInstance().AddRecordTime(t));
79
80 latency = DAudioLatencyTest::GetInstance().ComputeLatency();
81 EXPECT_LE(0, latency);
82 }
83
84 /**
85 * @tc.name: DAudioLatencyTest_002
86 * @tc.desc: Verify the DAudioLatencyTest IsFrameHigh function.
87 * @tc.type: FUNC
88 * @tc.require: AR000H0E5U
89 */
90 HWTEST_F(DAudioUtilsTest, DAudioLatencyTest_002, TestSize.Level1)
91 {
92 int32_t threshhold = 5000;
93 int32_t spanSizeInByte = 960;
94 std::unique_ptr<uint8_t[]> buf = std::make_unique<uint8_t[]>(spanSizeInByte);
95 memset_s(buf.get(), spanSizeInByte, 0, spanSizeInByte);
96 bool isHigh = DAudioLatencyTest::GetInstance().IsFrameHigh(reinterpret_cast<int16_t *>(buf.get()),
97 spanSizeInByte / sizeof(int16_t), threshhold);
98 EXPECT_EQ(false, isHigh);
99
100 memset_s(buf.get(), spanSizeInByte, threshhold, spanSizeInByte);
101 isHigh = DAudioLatencyTest::GetInstance().IsFrameHigh(reinterpret_cast<int16_t *>(buf.get()),
102 spanSizeInByte / sizeof(int16_t), threshhold);
103 EXPECT_EQ(true, isHigh);
104 }
105
106 /**
107 * @tc.name: DAudioLatencyTest_003
108 * @tc.desc: Verify the DAudioLatencyTest IsFrameHigh function.
109 * @tc.type: FUNC
110 * @tc.require: AR000H0E5U
111 */
112 HWTEST_F(DAudioUtilsTest, DAudioLatencyTest_003, TestSize.Level1)
113 {
114 bool status = true;
115 int32_t threshhold = 8000;
116 int32_t spanSizeInByte = 960;
117 std::unique_ptr<uint8_t[]> buf = std::make_unique<uint8_t[]>(spanSizeInByte);
118 memset_s(buf.get(), spanSizeInByte, threshhold, spanSizeInByte);
119 int64_t beepTime = DAudioLatencyTest::GetInstance().RecordBeepTime(static_cast<uint8_t *>(buf.get()),
120 spanSizeInByte, status);
121 EXPECT_NE(0, beepTime);
122 EXPECT_EQ(false, status);
123
124 memset_s(buf.get(), spanSizeInByte, 0, spanSizeInByte);
125 beepTime = DAudioLatencyTest::GetInstance().RecordBeepTime(static_cast<uint8_t *>(buf.get()),
126 spanSizeInByte, status);
127 EXPECT_EQ(0, beepTime);
128 EXPECT_EQ(true, status);
129 }
130
131 /**
132 * @tc.name: DAudioLogTest_001
133 * @tc.desc: Verify the GetCurrentTime function and DHLOG definition and DHLog function.
134 * @tc.type: FUNC
135 * @tc.require: AR000H0E5U
136 */
137 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_001, TestSize.Level1)
138 {
139 DHLOGD("DAudio TDD test DHLOGD print.");
140 DHLOGI("DAudio TDD test DHLOGI print.");
141 DHLOGW("DAudio TDD test DHLOGW print.");
142 DHLOGE("DAudio TDD test DHLOGE print.");
143 int64_t tvSec;
144 int64_t tvNSec;
145 GetCurrentTime(tvSec, tvNSec);
146 EXPECT_GE(tvSec, 0);
147 EXPECT_GE(tvNSec, 0);
148 }
149
150 /**
151 * @tc.name: DAudioLogTest_002
152 * @tc.desc: Verify the GetCurrentTime, GetCurNano and AbsoluteSleep function.
153 * @tc.type: FUNC
154 * @tc.require: AR000H0E5U
155 */
156 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_002, TestSize.Level1)
157 {
158 int32_t eventType = 200;
159 GetEventNameByType(eventType);
160 cJSON * jsonObj = nullptr;
161 std::initializer_list<std::string> keys = { "one", "two" };
162 CJsonParamCheck(jsonObj, keys);
163 jsonObj = cJSON_CreateObject();
164 cJSON_AddStringToObject(jsonObj, "one", "one");
165 cJSON_AddNumberToObject(jsonObj, "two", 2);
166 CJsonParamCheck(jsonObj, keys);
167 cJSON_Delete(jsonObj);
168
169 int64_t tvSec;
170 int64_t tvNSec;
171 GetCurrentTime(tvSec, tvNSec);
172 int64_t curNano = GetCurNano();
173 EXPECT_NE(0, curNano);
174 int32_t ret = AbsoluteSleep(curNano);
175 EXPECT_EQ(0, ret);
176 }
177
178 /**
179 * @tc.name: DAudioLogTest_003
180 * @tc.desc: Verify the CalculateSampleNum and UpdateTimeOffset function.
181 * @tc.type: FUNC
182 * @tc.require: AR000H0E5U
183 */
184 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_003, TestSize.Level1)
185 {
186 uint32_t sampleRate = 48000;
187 uint32_t timeInterval = 5;
188 int32_t desiredSpanSizeInFrame = 240;
189 int32_t spanSizeInFrame = CalculateSampleNum(sampleRate, timeInterval);
190 EXPECT_EQ(desiredSpanSizeInFrame, spanSizeInFrame);
191
192 int64_t frameIndex = 0;
193 int64_t framePeriodNs = 5000000;
194 int64_t startTime = 0;
195 int64_t timeOffset = UpdateTimeOffset(frameIndex, framePeriodNs, startTime);
196 EXPECT_NE(0, startTime);
197 EXPECT_EQ(0, timeOffset);
198
199 frameIndex = AUDIO_OFFSET_FRAME_NUM / 2;
200 timeOffset = UpdateTimeOffset(frameIndex, framePeriodNs, startTime);
201 EXPECT_EQ(0, timeOffset);
202
203 frameIndex = AUDIO_OFFSET_FRAME_NUM;
204 timeOffset = UpdateTimeOffset(frameIndex, framePeriodNs, startTime);
205 EXPECT_NE(0, timeOffset);
206 }
207
208 /**
209 * @tc.name: DAudioLogTest_004
210 * @tc.desc: Verify the GetAudioParamBool function.
211 * @tc.type: FUNC
212 * @tc.require: AR000H0E5U
213 */
214 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_004, TestSize.Level1)
215 {
216 std::string params = "";
217 std::string key = "";
218 bool value = false;
219 EXPECT_EQ(ERR_DH_AUDIO_FAILED, GetAudioParamBool(params, key, value));
220
221 params = "params";
222 key = "key";
223 EXPECT_EQ(ERR_DH_AUDIO_NOT_FOUND_KEY, GetAudioParamBool(params, key, value));
224
225 params = "key=0";
226 EXPECT_EQ(DH_SUCCESS, GetAudioParamBool(params, key, value));
227 EXPECT_EQ(false, value);
228
229 params = "param1=true;key=1;param2=false;";
230 EXPECT_EQ(DH_SUCCESS, GetAudioParamBool(params, key, value));
231 EXPECT_EQ(true, value);
232 }
233
234 /**
235 * @tc.name: DAudioLogTest_005
236 * @tc.desc: Verify the GetAudioParamInt function.
237 * @tc.type: FUNC
238 * @tc.require: AR000H0E5U
239 */
240 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_005, TestSize.Level1)
241 {
242 std::string params = "";
243 std::string key = "";
244 int32_t value = 5;
245 EXPECT_EQ(ERR_DH_AUDIO_FAILED, GetAudioParamInt(params, key, value));
246
247 params = "params";
248 key = "key";
249 EXPECT_EQ(ERR_DH_AUDIO_NOT_FOUND_KEY, GetAudioParamInt(params, key, value));
250
251 params = "key=0";
252 EXPECT_EQ(DH_SUCCESS, GetAudioParamInt(params, key, value));
253 EXPECT_EQ(0, value);
254
255 params = "param1=true;key=1;param2=false;";
256 EXPECT_EQ(DH_SUCCESS, GetAudioParamInt(params, key, value));
257 EXPECT_EQ(1, value);
258 }
259
260 /**
261 * @tc.name: DAudioLogTest_006
262 * @tc.desc: Verify the JsonParamCheck function.
263 * @tc.type: FUNC
264 * @tc.require: AR000H0E5U
265 */
266 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_006, TestSize.Level1)
267 {
268 cJSON *jParam = cJSON_CreateObject();
269 CHECK_NULL_VOID(jParam);
270 cJSON_AddStringToObject(jParam, KEY_DEV_ID, "123");
271 cJSON_AddStringToObject(jParam, KEY_DH_ID, "1");
272 cJSON_AddStringToObject(jParam, KEY_ATTRS, "");
273 cJSON_AddStringToObject(jParam, KEY_FORMAT, "TEST_8000");
274 EXPECT_EQ(true, CJsonParamCheck(jParam, { KEY_ATTRS }));
275 EXPECT_EQ(true, CJsonParamCheck(jParam, { KEY_DH_ID }));
276 EXPECT_EQ(false, CJsonParamCheck(jParam, { KEY_FORMAT }));
277 EXPECT_EQ(true, CJsonParamCheck(jParam, { KEY_DEV_ID }));
278 cJSON_Delete(jParam);
279 }
280
281 /**
282 * @tc.name: DAudioLogTest_007
283 * @tc.desc: Verify the CheckIsNum and CheckDevIdIsLegal function.
284 * @tc.type: FUNC
285 * @tc.require: AR000H0E5U
286 */
287 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_007, TestSize.Level1)
288 {
289 uint8_t maxDhIdLen = 20;
290 std::string tempDhIdStr(maxDhIdLen + 1, 'a');
291 EXPECT_EQ(false, CheckIsNum(tempDhIdStr));
292
293 tempDhIdStr = "";
294 EXPECT_EQ(false, CheckIsNum(tempDhIdStr));
295
296 tempDhIdStr = "TestParams";
297 EXPECT_EQ(false, CheckIsNum(tempDhIdStr));
298
299 tempDhIdStr = "1";
300 EXPECT_EQ(true, CheckIsNum(tempDhIdStr));
301
302 std::string tempDevIdStr(DAUDIO_MAX_DEVICE_ID_LEN + 1, 'a');
303 EXPECT_EQ(false, CheckDevIdIsLegal(tempDevIdStr));
304
305 tempDevIdStr = "";
306 EXPECT_EQ(false, CheckDevIdIsLegal(tempDevIdStr));
307
308 tempDevIdStr = "Test*Params#";
309 EXPECT_EQ(false, CheckDevIdIsLegal(tempDevIdStr));
310
311 tempDevIdStr = "Test1";
312 EXPECT_EQ(true, CheckDevIdIsLegal(tempDevIdStr));
313 }
314
315 /**
316 * @tc.name: DAudioLogTest_010
317 * @tc.desc: Verify the cjson function.
318 * @tc.type: FUNC
319 * @tc.require: AR000H0E5U
320 */
321 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_010, TestSize.Level1)
322 {
323 std::string key = "123";
324 cJSON *jsonObject = nullptr;
325 EXPECT_EQ(false, IsString(jsonObject, key));
326 jsonObject = cJSON_CreateObject();
327 CHECK_NULL_VOID(jsonObject);
328 EXPECT_EQ(false, IsString(jsonObject, key));
329 cJSON_AddStringToObject(jsonObject, "key", key.c_str());
330 EXPECT_EQ(false, IsString(jsonObject, key));
331 cJSON_Delete(jsonObject);
332 cJSON *jsonObject1 = cJSON_CreateObject();
333 CHECK_NULL_VOID(jsonObject1);
334 cJSON_AddStringToObject(jsonObject1, "key", key.c_str());
335 EXPECT_EQ(false, IsString(jsonObject1, key));
336 cJSON_Delete(jsonObject1);
337 }
338
339 /**
340 * @tc.name: DAudioLogTest_011
341 * @tc.desc: Verify the cjson function.
342 * @tc.type: FUNC
343 * @tc.require: AR000H0E5U
344 */
345 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_011, TestSize.Level1)
346 {
347 std::string key = "123";
348 cJSON *jsonObject = nullptr;
349 EXPECT_EQ(false, IsInt32(jsonObject, key));
350 jsonObject = cJSON_CreateObject();
351 CHECK_NULL_VOID(jsonObject);
352 EXPECT_EQ(false, IsInt32(jsonObject, key));
353 cJSON_AddStringToObject(jsonObject, "key", key.c_str());
354 EXPECT_EQ(false, IsInt32(jsonObject, key));
355 cJSON_Delete(jsonObject);
356 cJSON *jsonObject1 = cJSON_CreateObject();
357 CHECK_NULL_VOID(jsonObject1);
358 cJSON_AddNumberToObject(jsonObject1, "key", INT32_MAX);
359 EXPECT_EQ(false, IsInt32(jsonObject1, key));
360 cJSON_Delete(jsonObject1);
361 }
362
363 /**
364 * @tc.name: DAudioLogTest_012
365 * @tc.desc: Verify the IsAudioParam function.
366 * @tc.type: FUNC
367 * @tc.require: AR000H0E5U
368 */
369 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_012, TestSize.Level1)
370 {
371 std::string key = "123";
372 cJSON *jsonObject = nullptr;
373 EXPECT_EQ(false, IsAudioParam(jsonObject, key));
374 jsonObject = cJSON_CreateObject();
375 CHECK_NULL_VOID(jsonObject);
376 EXPECT_EQ(false, IsAudioParam(jsonObject, key));
377 cJSON *jsonObj = cJSON_CreateArray();
378 CHECK_NULL_VOID(jsonObj);
379 cJSON_AddItemToObject(jsonObject, key.c_str(), jsonObj);
380 EXPECT_EQ(false, IsAudioParam(jsonObject, key));
381 cJSON_Delete(jsonObject);
382 }
383
384 /**
385 * @tc.name: DAudioLogTest_013
386 * @tc.desc: Verify the IsParamEnabled function.
387 * @tc.type: FUNC
388 * @tc.require: AR000H0E5U
389 */
390 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_013, TestSize.Level1)
391 {
392 std::string key = "123";
393 bool isEnabled = false;
394 EXPECT_EQ(false, IsParamEnabled(key, isEnabled));
395 }
396
397 /**
398 * @tc.name: DAudioLogTest_014
399 * @tc.desc: Verify the GetSysPara function.
400 * @tc.type: FUNC
401 * @tc.require: AR000H0E5U
402 */
403 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_014, TestSize.Level1)
404 {
405 char *key = nullptr;
406 int32_t value = 0;
407 EXPECT_EQ(false, GetSysPara(key, value));
408 std::string str = "123";
409 EXPECT_EQ(true, GetSysPara(str.c_str(), value));
410 }
411
412 /**
413 * @tc.name: DAudioLogTest_015
414 * @tc.desc: Verify the AbsoluteSleep function.
415 * @tc.type: FUNC
416 * @tc.require: AR000H0E5U
417 */
418 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_015, TestSize.Level1)
419 {
420 int64_t nanoTime = 0;
421 EXPECT_NE(DH_SUCCESS, AbsoluteSleep(nanoTime));
422 nanoTime = 123456;
423 EXPECT_EQ(DH_SUCCESS, AbsoluteSleep(nanoTime));
424 }
425 } // namespace DistributedHardware
426 } // namespace OHOS
427