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 GetCurrentTime function and DHLOG definition and DHLog function.
133 * @tc.type: FUNC
134 * @tc.require: AR000H0E5U
135 */
136 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_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 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 int64_t tvSec;
159 int64_t tvNSec;
160 GetCurrentTime(tvSec, tvNSec);
161
162 int64_t curNano = GetCurNano();
163 EXPECT_NE(0, curNano);
164
165 int32_t ret = AbsoluteSleep(curNano);
166 EXPECT_EQ(0, ret);
167 }
168
169 /**
170 * @tc.name: DAudioLogTest_003
171 * @tc.desc: Verify the CalculateSampleNum and UpdateTimeOffset function.
172 * @tc.type: FUNC
173 * @tc.require: AR000H0E5U
174 */
175 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_003, TestSize.Level1)
176 {
177 uint32_t sampleRate = 48000;
178 uint32_t timeInterval = 5;
179 int32_t desiredSpanSizeInFrame = 240;
180 int32_t spanSizeInFrame = CalculateSampleNum(sampleRate, timeInterval);
181 EXPECT_EQ(desiredSpanSizeInFrame, spanSizeInFrame);
182
183 int64_t frameIndex = 0;
184 int64_t framePeriodNs = 5000000;
185 int64_t startTime = 0;
186 int64_t timeOffset = UpdateTimeOffset(frameIndex, framePeriodNs, startTime);
187 EXPECT_NE(0, startTime);
188 EXPECT_EQ(0, timeOffset);
189
190 frameIndex = AUDIO_OFFSET_FRAME_NUM / 2;
191 timeOffset = UpdateTimeOffset(frameIndex, framePeriodNs, startTime);
192 EXPECT_EQ(0, timeOffset);
193
194 frameIndex = AUDIO_OFFSET_FRAME_NUM;
195 timeOffset = UpdateTimeOffset(frameIndex, framePeriodNs, startTime);
196 EXPECT_NE(0, timeOffset);
197 }
198
199 /**
200 * @tc.name: DAudioLogTest_004
201 * @tc.desc: Verify the GetAudioParamBool function.
202 * @tc.type: FUNC
203 * @tc.require: AR000H0E5U
204 */
205 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_004, TestSize.Level1)
206 {
207 std::string params = "";
208 std::string key = "";
209 bool value = false;
210 EXPECT_EQ(ERR_DH_AUDIO_FAILED, GetAudioParamBool(params, key, value));
211
212 params = "params";
213 key = "key";
214 EXPECT_EQ(ERR_DH_AUDIO_NOT_FOUND_KEY, GetAudioParamBool(params, key, value));
215
216 params = "key=0";
217 EXPECT_EQ(DH_SUCCESS, GetAudioParamBool(params, key, value));
218 EXPECT_EQ(false, value);
219
220 params = "param1=true;key=1;param2=false;";
221 EXPECT_EQ(DH_SUCCESS, GetAudioParamBool(params, key, value));
222 EXPECT_EQ(true, value);
223 }
224
225 /**
226 * @tc.name: DAudioLogTest_005
227 * @tc.desc: Verify the GetAudioParamInt function.
228 * @tc.type: FUNC
229 * @tc.require: AR000H0E5U
230 */
231 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_005, TestSize.Level1)
232 {
233 std::string params = "";
234 std::string key = "";
235 int32_t value = 5;
236 EXPECT_EQ(ERR_DH_AUDIO_FAILED, GetAudioParamInt(params, key, value));
237
238 params = "params";
239 key = "key";
240 EXPECT_EQ(ERR_DH_AUDIO_NOT_FOUND_KEY, GetAudioParamInt(params, key, value));
241
242 params = "key=0";
243 EXPECT_EQ(DH_SUCCESS, GetAudioParamInt(params, key, value));
244 EXPECT_EQ(0, value);
245
246 params = "param1=true;key=1;param2=false;";
247 EXPECT_EQ(DH_SUCCESS, GetAudioParamInt(params, key, value));
248 EXPECT_EQ(1, value);
249 }
250
251 /**
252 * @tc.name: DAudioLogTest_006
253 * @tc.desc: Verify the JsonParamCheck function.
254 * @tc.type: FUNC
255 * @tc.require: AR000H0E5U
256 */
257 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_006, TestSize.Level1)
258 {
259 std::string tempKey = "TestParam";
260 json jParam = { { KEY_DEV_ID, "TEST_DEV_ID" }, {KEY_AUDIO_PARAM, "TEST_PARAM" }, {KEY_FORMAT, "TEST_8000" },
261 { tempKey, "TEST_TEMP_KEY" } };
262 EXPECT_EQ(false, JsonParamCheck(jParam, { KEY_ATTRS }));
263 EXPECT_EQ(false, JsonParamCheck(jParam, { KEY_AUDIO_PARAM }));
264 EXPECT_EQ(false, JsonParamCheck(jParam, { KEY_FORMAT }));
265 EXPECT_EQ(false, JsonParamCheck(jParam, { tempKey }));
266 EXPECT_EQ(true, JsonParamCheck(jParam, { KEY_DEV_ID }));
267 }
268
269 /**
270 * @tc.name: DAudioLogTest_007
271 * @tc.desc: Verify the CheckIsNum and CheckDevIdIsLegal function.
272 * @tc.type: FUNC
273 * @tc.require: AR000H0E5U
274 */
275 HWTEST_F(DAudioUtilsTest, DAudioUtilTest_007, TestSize.Level1)
276 {
277 uint8_t maxDhIdLen = 20;
278 std::string tempDhIdStr(maxDhIdLen + 1, 'a');
279 EXPECT_EQ(false, CheckIsNum(tempDhIdStr));
280
281 tempDhIdStr = "";
282 EXPECT_EQ(false, CheckIsNum(tempDhIdStr));
283
284 tempDhIdStr = "TestParams";
285 EXPECT_EQ(false, CheckIsNum(tempDhIdStr));
286
287 tempDhIdStr = "1";
288 EXPECT_EQ(true, CheckIsNum(tempDhIdStr));
289
290 std::string tempDevIdStr(DAUDIO_MAX_DEVICE_ID_LEN + 1, 'a');
291 EXPECT_EQ(false, CheckDevIdIsLegal(tempDevIdStr));
292
293 tempDevIdStr = "";
294 EXPECT_EQ(false, CheckDevIdIsLegal(tempDevIdStr));
295
296 tempDevIdStr = "Test*Params#";
297 EXPECT_EQ(false, CheckDevIdIsLegal(tempDevIdStr));
298
299 tempDevIdStr = "Test1";
300 EXPECT_EQ(true, CheckDevIdIsLegal(tempDevIdStr));
301 }
302 } // namespace DistributedHardware
303 } // namespace OHOS
304