1 /*
2 * Copyright (c) 2022-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 <gtest/gtest.h>
17 #include "audio_dump_pcm.h"
18 #include "audio_dump_pcm_private.h"
19 #include "audio_errors.h"
20
21 using namespace testing::ext;
22 namespace OHOS {
23 namespace AudioStandard {
24 class AudioDumpPcmUnitTest : public testing::Test {
25 public:
26 static void SetUpTestCase(void);
27 static void TearDownTestCase(void);
28 void SetUp();
29 void TearDown();
30 };
31
SetUpTestCase(void)32 void AudioDumpPcmUnitTest::SetUpTestCase(void)
33 {
34 // input testsuit setup step，setup invoked before all testcases
35 }
36
TearDownTestCase(void)37 void AudioDumpPcmUnitTest::TearDownTestCase(void)
38 {
39 // input testsuit teardown step，teardown invoked after all testcases
40 }
41
SetUp(void)42 void AudioDumpPcmUnitTest::SetUp(void)
43 {
44 // input testcase setup step，setup invoked before each testcases
45 }
46
TearDown(void)47 void AudioDumpPcmUnitTest::TearDown(void)
48 {
49 // input testcase teardown step，teardown invoked after each testcases
50 }
51
52 /**
53 * @tc.name : Test Init API
54 * @tc.type : FUNC
55 * @tc.number: Init_001
56 * @tc.desc : Test Init interface.
57 */
58 HWTEST(AudioDumpPcmUnitTest, Init_001, TestSize.Level1)
59 {
60 AudioCacheMgrInner audioCacheMgrInner;
61 audioCacheMgrInner.isInited_ = true;
62 bool ret = audioCacheMgrInner.Init();
63 EXPECT_EQ(ret, true);
64 }
65
66 /**
67 * @tc.name : Test Init API
68 * @tc.type : FUNC
69 * @tc.number: Init_002
70 * @tc.desc : Test Init interface.
71 */
72 HWTEST(AudioDumpPcmUnitTest, Init_002, TestSize.Level1)
73 {
74 AudioCacheMgrInner audioCacheMgrInner;
75 audioCacheMgrInner.isInited_ = false;
76 bool ret = audioCacheMgrInner.Init();
77 EXPECT_EQ(ret, true);
78 }
79
80 /**
81 * @tc.name : Test DeInit API
82 * @tc.type : FUNC
83 * @tc.number: DeInit_001
84 * @tc.desc : Test DeInit interface.
85 */
86 HWTEST(AudioDumpPcmUnitTest, DeInit_001, TestSize.Level1)
87 {
88 AudioCacheMgrInner audioCacheMgrInner;
89 bool ret = audioCacheMgrInner.DeInit();
90 EXPECT_EQ(ret, true);
91 }
92
93 /**
94 * @tc.name : Test DeInit API
95 * @tc.type : FUNC
96 * @tc.number: DeInit_002
97 * @tc.desc : Test DeInit interface.
98 */
99 HWTEST(AudioDumpPcmUnitTest, DeInit_002, TestSize.Level1)
100 {
101 AudioCacheMgrInner audioCacheMgrInner;
102 audioCacheMgrInner.InitCallbackHandler();
103 bool ret = audioCacheMgrInner.DeInit();
104 EXPECT_EQ(ret, true);
105 }
106
107 /**
108 * @tc.name : Test DumpAllMemBlock API
109 * @tc.type : FUNC
110 * @tc.number: DumpAllMemBlock_001
111 * @tc.desc : Test DumpAllMemBlock interface.
112 */
113 HWTEST(AudioDumpPcmUnitTest, DumpAllMemBlock_001, TestSize.Level1)
114 {
115 AudioCacheMgrInner audioCacheMgrInner;
116 audioCacheMgrInner.isInited_ = false;
117 int32_t ret = audioCacheMgrInner.DumpAllMemBlock();
118 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
119 }
120
121 /**
122 * @tc.name : Test DumpAllMemBlock API
123 * @tc.type : FUNC
124 * @tc.number: DumpAllMemBlock_002
125 * @tc.desc : Test DumpAllMemBlock interface.
126 */
127 HWTEST(AudioDumpPcmUnitTest, DumpAllMemBlock_002, TestSize.Level1)
128 {
129 AudioCacheMgrInner audioCacheMgrInner;
130 audioCacheMgrInner.isInited_ = true;
131 int32_t ret = audioCacheMgrInner.DumpAllMemBlock();
132 EXPECT_EQ(ret, SUCCESS);
133 }
134
135 /**
136 * @tc.name : Test DumpAllMemBlock API
137 * @tc.type : FUNC
138 * @tc.number: DumpAllMemBlock_003
139 * @tc.desc : Test DumpAllMemBlock interface.
140 */
141 HWTEST(AudioDumpPcmUnitTest, DumpAllMemBlock_003, TestSize.Level1)
142 {
143 AudioCacheMgrInner audioCacheMgrInner;
144 std::shared_ptr<MemChunk> memChunk = std::make_shared<MemChunk>();
145 audioCacheMgrInner.isInited_ = true;
146
147 audioCacheMgrInner.memChunkDeque_.push_back(memChunk);
148 int32_t ret = audioCacheMgrInner.DumpAllMemBlock();
149 EXPECT_EQ(ret, SUCCESS);
150 }
151
152 /**
153 * @tc.name : Test CacheData API
154 * @tc.type : FUNC
155 * @tc.number: CacheData_001
156 * @tc.desc : Test CacheData interface.
157 */
158 HWTEST(AudioDumpPcmUnitTest, CacheData_001, TestSize.Level1)
159 {
160 std::string dumpFileName;
161 void* srcDataPointer;
162 size_t dataLength;
163 uint8_t srcBuffer[16] = {0};
164 AudioCacheMgrInner audioCacheMgrInner;
165
166 dumpFileName = "test.txt";
167 srcDataPointer = static_cast<void *>(srcBuffer);
168 dataLength = 8;
169 audioCacheMgrInner.isInited_ = false;
170 audioCacheMgrInner.CacheData(dumpFileName, srcDataPointer, dataLength);
171 EXPECT_EQ(audioCacheMgrInner.isInited_, false);
172
173 audioCacheMgrInner.isInited_ = true;
174 audioCacheMgrInner.isDumpingData_ = true;
175 audioCacheMgrInner.CacheData(dumpFileName, srcDataPointer, dataLength);
176 EXPECT_EQ(audioCacheMgrInner.isDumpingData_, true);
177
178 audioCacheMgrInner.isDumpingData_ = false;
179 audioCacheMgrInner.totalMemChunkNums_ = -1;
180 audioCacheMgrInner.CacheData(dumpFileName, srcDataPointer, dataLength);
181 EXPECT_EQ(audioCacheMgrInner.isDumpingData_, false);
182
183 audioCacheMgrInner.isDumpingData_ = false;
184 audioCacheMgrInner.totalMemChunkNums_ = 1;
185 audioCacheMgrInner.CacheData(dumpFileName, srcDataPointer, dataLength);
186 EXPECT_EQ(audioCacheMgrInner.isDumpingData_, false);
187 }
188
189 /**
190 * @tc.name : Test GetCachedDuration API
191 * @tc.type : FUNC
192 * @tc.number: GetCachedDuration_001
193 * @tc.desc : Test GetCachedDuration interface.
194 */
195 HWTEST(AudioDumpPcmUnitTest, GetCachedDuration_001, TestSize.Level1)
196 {
197 int64_t startTime = 0;
198 int64_t endTime = 0;
199 std::shared_ptr<MemChunk> memChunk = std::make_shared<MemChunk>();
200 AudioCacheMgrInner audioCacheMgrInner;
201
202 audioCacheMgrInner.isInited_ = false;
203 audioCacheMgrInner.GetCachedDuration(startTime, endTime);
204 EXPECT_EQ(audioCacheMgrInner.isInited_, false);
205
206 audioCacheMgrInner.isInited_ = true;
207 audioCacheMgrInner.GetCachedDuration(startTime, endTime);
208 EXPECT_EQ(audioCacheMgrInner.memChunkDeque_.size(), 0);
209
210 audioCacheMgrInner.memChunkDeque_.push_back(memChunk);
211 audioCacheMgrInner.memChunkDeque_.push_back(memChunk);
212 audioCacheMgrInner.GetCachedDuration(startTime, endTime);
213 EXPECT_NE(audioCacheMgrInner.memChunkDeque_.size(), 0);
214 }
215
216 /**
217 * @tc.name : Test GetDumpParameter API
218 * @tc.type : FUNC
219 * @tc.number: GetDumpParameter_001
220 * @tc.desc : Test GetDumpParameter interface.
221 */
222 HWTEST(AudioDumpPcmUnitTest, GetDumpParameter_001, TestSize.Level1)
223 {
224 std::vector<std::string> subKeys;
225 std::vector<std::pair<std::string, std::string>> result;
226 bool ret;
227 AudioCacheMgrInner audioCacheMgrInner;
228
229 subKeys.push_back(GET_STATUS_KEY);
230 ret = audioCacheMgrInner.GetDumpParameter(subKeys, result);
231 EXPECT_EQ(ret, true);
232
233 subKeys.clear();
234 subKeys.push_back(GET_TIME_KEY);
235 ret = audioCacheMgrInner.GetDumpParameter(subKeys, result);
236 EXPECT_EQ(ret, true);
237
238 subKeys.clear();
239 subKeys.push_back(GET_MEMORY_KEY);
240 ret = audioCacheMgrInner.GetDumpParameter(subKeys, result);
241 EXPECT_EQ(ret, true);
242
243 subKeys.clear();
244 subKeys.push_back("test");
245 ret = audioCacheMgrInner.GetDumpParameter(subKeys, result);
246 EXPECT_EQ(ret, false);
247 }
248
249 /**
250 * @tc.name : Test SetDumpParameter API
251 * @tc.type : FUNC
252 * @tc.number: SetDumpParameter_001
253 * @tc.desc : Test SetDumpParameter interface.
254 */
255 HWTEST(AudioDumpPcmUnitTest, SetDumpParameter_001, TestSize.Level1)
256 {
257 std::vector<std::pair<std::string, std::string>> params;
258 bool ret;
259 AudioCacheMgrInner audioCacheMgrInner;
260
261 params.push_back(std::make_pair(SET_OPEN_KEY, "test"));
262 ret = audioCacheMgrInner.SetDumpParameter(params);
263 EXPECT_EQ(ret, true);
264
265 params.clear();
266 params.push_back(std::make_pair(SET_CLOSE_KEY, "test"));
267 ret = audioCacheMgrInner.SetDumpParameter(params);
268 EXPECT_EQ(ret, true);
269
270 params.clear();
271 params.push_back(std::make_pair(SET_UPLOAD_KEY, "test"));
272 ret = audioCacheMgrInner.SetDumpParameter(params);
273 EXPECT_NE(ret, true);
274
275 params.clear();
276 params.push_back(std::make_pair("test1", "test"));
277 ret = audioCacheMgrInner.SetDumpParameter(params);
278 EXPECT_EQ(ret, false);
279 }
280
281 /**
282 * @tc.name : Test OnHandle API
283 * @tc.type : FUNC
284 * @tc.number: OnHandle_001
285 * @tc.desc : Test OnHandle interface.
286 */
287 HWTEST(AudioDumpPcmUnitTest, OnHandle_001, TestSize.Level1)
288 {
289 uint32_t code;
290 int64_t data = 0;
291 AudioCacheMgrInner audioCacheMgrInner;
292
293 code = AudioCacheMgrInner::RELEASE_OVERTIME_MEMBLOCK;
294 audioCacheMgrInner.OnHandle(code, data);
295 EXPECT_EQ(code, AudioCacheMgrInner::RELEASE_OVERTIME_MEMBLOCK);
296
297 code = AudioCacheMgrInner::PRINT_MEMORY_CONDITION;
298 audioCacheMgrInner.OnHandle(code, data);
299 EXPECT_EQ(code, AudioCacheMgrInner::PRINT_MEMORY_CONDITION);
300
301 code = AudioCacheMgrInner::RAISE_PRIORITY;
302 audioCacheMgrInner.OnHandle(code, data);
303 EXPECT_EQ(code, AudioCacheMgrInner::RAISE_PRIORITY);
304
305 code = 5;
306 audioCacheMgrInner.OnHandle(code, data);
307 EXPECT_EQ(code, 5);
308 }
309 } // namespace AudioStandard
310 } // namespace OHOS
311