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 "ringtone_file_utils_test.h"
17
18 #include <algorithm>
19
20 #include "ringtone_db_const.h"
21 #include "ringtone_errno.h"
22 #include "ringtone_file_utils.h"
23 #include "ringtone_log.h"
24 #include "ringtone_type.h"
25 #include "ringtone_utils.h"
26 #include "ringtone_xcollie.h"
27
28 using std::string;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Media {
33 const string PATH = "ringtone/audio";
34 const string DEFAULT_STR = "";
35 const int32_t MAX_SIZE = 9;
36
SetUpTestCase()37 void RingtoneFileUtilsTest::SetUpTestCase() {}
TearDownTestCase()38 void RingtoneFileUtilsTest::TearDownTestCase() {}
SetUp()39 void RingtoneFileUtilsTest::SetUp()
40 {
41 system("mkdir /data/local/tmp/test");
42 }
TearDown(void)43 void RingtoneFileUtilsTest::TearDown(void)
44 {
45 system("rm -rf /data/local/tmp/test");
46 }
47
48 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_SplitByChar_Test_001, TestSize.Level0)
49 {
50 const char SLASH_CHAR = '/';
51 auto str = RingtoneFileUtils::SplitByChar(PATH, SLASH_CHAR);
52 ASSERT_EQ(str, "audio");
53 }
54
55 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_SplitByChar_Test_002, TestSize.Level0)
56 {
57 const char star = '*';
58 auto str = RingtoneFileUtils::SplitByChar(PATH, star);
59 ASSERT_EQ(str, DEFAULT_STR);
60 }
61
62 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_GetExtensionFromPath_Test_001, TestSize.Level0)
63 {
64 const string path = "ringtone/audio.mp3";
65 const string extension = "mp3";
66 auto str = RingtoneFileUtils::GetExtensionFromPath(path);
67 ASSERT_EQ(str, extension);
68 }
69
70 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_GetExtensionFromPath_Test_002, TestSize.Level0)
71 {
72 auto str = RingtoneFileUtils::GetExtensionFromPath(PATH);
73 ASSERT_EQ(str, DEFAULT_STR);
74 }
75
76 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_OpenFile_Test_001, TestSize.Level0)
77 {
78 const string path = "/storage/media/100";
79 auto ret = RingtoneFileUtils::OpenFile(path, RINGTONE_FILEMODE_WRITEONLY);
80 ASSERT_EQ(ret, E_INVALID_PATH);
81 ret = RingtoneFileUtils::OpenFile(path, "v");
82 ASSERT_EQ(ret, E_INVALID_PATH);
83 const int32_t count = 5200;
84 string filePath = string(count, 'a') + ".ogg";
85 ret = RingtoneFileUtils::OpenFile(filePath, RINGTONE_FILEMODE_WRITEONLY);
86 ASSERT_EQ(ret, E_ERR);
87 filePath = "ringtoneFileUtils_OpenFile_Test_001.ogg";
88 ret = RingtoneFileUtils::OpenFile(filePath, "z");
89 ASSERT_EQ(ret, E_ERR);
90 }
91
92 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_MilliSecond_Test_001, TestSize.Level0)
93 {
94 struct timespec t;
95 clock_gettime(CLOCK_REALTIME, &t);
96 int64_t MilliSecondTime = RingtoneFileUtils::Timespec2Millisecond(t);
97 ASSERT_EQ(MilliSecondTime, RingtoneFileUtils::UTCTimeMilliSeconds());
98 }
99
100 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_StartsWith_Test_001, TestSize.Level0)
101 {
102 const std::string prefix = "audio";
103 auto str = RingtoneFileUtils::StartsWith(PATH, prefix);
104 ASSERT_EQ(str, false);
105 }
106
107 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_StartsWith_Test_002, TestSize.Level0)
108 {
109 const std::string prefix = "ringtone/audio";
110 auto str = RingtoneFileUtils::StartsWith(PATH, prefix);
111 ASSERT_EQ(str, true);
112 }
113
114 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_IsFileExists_Test_001, TestSize.Level0)
115 {
116 const string filePath = "/data/test/isfileexists_001";
117 EXPECT_EQ(RingtoneFileUtils::IsFileExists(filePath), false);
118 }
119
120 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_CreateFile_Test_001, TestSize.Level0)
121 {
122 const string filePath = "/data/local/tmp/test/createfile_001.ogg";
123 EXPECT_EQ(RingtoneFileUtils::CreateFile(filePath), E_SUCCESS);
124 }
125
126 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_CreateFile_Test_002, TestSize.Level0)
127 {
128 string filePath = DEFAULT_STR;
129 EXPECT_EQ(RingtoneFileUtils::CreateFile(filePath), E_VIOLATION_PARAMETERS);
130 filePath = "/data/local/tmp/test/createfile_002.pcm";
131 EXPECT_EQ(RingtoneFileUtils::CreateFile(filePath), E_INVALID_PATH);
132 }
133
134 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_CreateFile_Test_003, TestSize.Level0)
135 {
136 const string filePath = "/data/local/tmp/test/createfile_003.ogg";
137 EXPECT_EQ(RingtoneFileUtils::CreateFile(filePath), E_SUCCESS);
138 EXPECT_EQ(RingtoneFileUtils::CreateFile(filePath), E_FILE_EXIST);
139 }
140
141 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_CreateFile_Test_004, TestSize.Level0)
142 {
143 const string filePath = "/data/local/tmp/test/test/test/test/createfile_004.ogg";
144 EXPECT_EQ(RingtoneFileUtils::CreateFile(filePath), E_ERR);
145 }
146
147 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_GetFileNameFromPath_Test_001, TestSize.Level0)
148 {
149 string filePath = "/ringtoneFileUtils_GetFileNameFromPath_Test_001/createfile_001.ogg";
150 auto ret = RingtoneFileUtils::GetFileNameFromPath(filePath);
151 EXPECT_EQ(ret, "createfile_001.ogg");
152 filePath = "/";
153 ret = RingtoneFileUtils::GetFileNameFromPath(filePath);
154 EXPECT_EQ(ret, "");
155 filePath = "";
156 ret = RingtoneFileUtils::GetFileNameFromPath(filePath);
157 EXPECT_EQ(ret, "");
158 }
159
160 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_GetBaseNameFromPath_Test_001, TestSize.Level0)
161 {
162 string filePath = "data/createfile_001.";
163 auto ret = RingtoneFileUtils::GetBaseNameFromPath(filePath);
164 EXPECT_EQ(ret, "createfile_001");
165 filePath = "createfile_001./";
166 ret = RingtoneFileUtils::GetBaseNameFromPath(filePath);
167 EXPECT_EQ(ret, "");
168 }
169
170 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_IsSameFile_Test_001, TestSize.Level0)
171 {
172 const string srcPath = "/data/local/tmp/test/createfile_Test_001.ogg";
173 const string dstPath = "/data/local/tmp/test/createfile_Test_001.ogg";
174 auto ret = RingtoneFileUtils::IsSameFile(srcPath, dstPath);
175 EXPECT_EQ(ret, false);
176 EXPECT_EQ(RingtoneFileUtils::CreateFile(srcPath), E_SUCCESS);
177 ret = RingtoneFileUtils::IsSameFile(srcPath, dstPath);
178 EXPECT_EQ(ret, true);
179 }
180
181 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_IsSameFile_Test_002, TestSize.Level0)
182 {
183 const string srcPath = "/data/local/tmp/test/createfile_Test_001.ogg";
184 const string dstPath = "/data/local/tmp/test/createfile_001.ogg";
185 auto ret = RingtoneFileUtils::IsSameFile(srcPath, dstPath);
186 EXPECT_EQ(ret, false);
187 }
188
189 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_RemoveDirectory_Test_001, TestSize.Level0)
190 {
191 const string filePath = "/data/local/tmp/test/createfile_003.ogg";
192 EXPECT_EQ(RingtoneFileUtils::CreateFile(filePath), E_SUCCESS);
193 auto ret = RingtoneFileUtils::RemoveDirectory(filePath);
194 EXPECT_EQ(ret, E_SUCCESS);
195 }
196
197 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_Mkdir_Test_001, TestSize.Level0)
198 {
199 const string path = "ringtoneFileUtils_RemoveDirectory_Test_001";
200 std::shared_ptr<int> errCodePtr;
201 auto ret = RingtoneFileUtils::Mkdir(path);
202 EXPECT_EQ(ret, true);
203 }
204 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_Mkdir_Test_002, TestSize.Level0)
205 {
206 const string path = "/data/local/tmp/test";
207 std::shared_ptr<int> errCodePtr;
208 auto ret = RingtoneFileUtils::Mkdir(path);
209 EXPECT_EQ(ret, true);
210 }
211
212 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_IsDirectory_Test_001, TestSize.Level0)
213 {
214 const string path = "ringtoneFileUtils_RemoveDirectory_Test_001";
215 std::shared_ptr<int> errCodePtr;
216 auto ret = RingtoneFileUtils::IsDirectory(path, errCodePtr);
217 EXPECT_EQ(ret, true);
218 const string pathDir = "/data/ringtone/ringtoneFileUtils_RemoveDirectory_Test_001";
219 ret = RingtoneFileUtils::IsDirectory(pathDir, errCodePtr);
220 EXPECT_EQ(ret, false);
221 std::shared_ptr<int> errCode = std::make_shared<int>(1);
222 ret = RingtoneFileUtils::IsDirectory(pathDir, errCode);
223 EXPECT_EQ(ret, false);
224 }
225
226 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_CreateDirectory_Test_001, TestSize.Level0)
227 {
228 string dirPath = "/data/test/isdirempty_002";
229 string subPath = dirPath + "/isdirempty_002";
230 EXPECT_EQ(RingtoneFileUtils::CreateDirectory(subPath), true);
231 }
232
233 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_MoveFile_Test_001, TestSize.Level0)
234 {
235 string oldPath = "/data/local/tmp/test/movefile_001.ogg";
236 string newPath = "/data/local/tmp/test/movefile_001_move.ogg";
237 EXPECT_EQ(RingtoneFileUtils::CreateFile(oldPath), E_SUCCESS);
238 EXPECT_EQ(RingtoneFileUtils::MoveFile(oldPath, newPath), true);
239 }
240
241 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_CopyFileUtil_Test_001, TestSize.Level0)
242 {
243 string oldPath = "/data/local/tmp/test/movefile_001.ogg";
244 string newPath = "/data/local/tmp/test/movefile_001_move.ogg";
245 EXPECT_EQ(RingtoneFileUtils::CreateFile(oldPath), E_SUCCESS);
246 EXPECT_EQ(RingtoneFileUtils::CopyFileUtil(oldPath, newPath), true);
247 const string filePath("a", 5200);
248 RingtoneFileUtils::CopyFileUtil(filePath, newPath);
249 }
250
251 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_GetSandboxPath_Test_001, TestSize.Level0)
252 {
253 string uri1 = "/data/app/el2/100/base/com.ohos.ringtonelibrary.ringtonelibrarydata/files/Ringtone";
254 string uri2 = "/data/local/tmp/test";
255 int32_t result = GetAppSandboxPathFromUri(uri1);
256 EXPECT_EQ(result, E_OK);
257 result = GetAppSandboxPathFromUri(uri2);
258 EXPECT_EQ(result, E_INVALID_URI);
259 }
260
261 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_OpenVibrateFile_Test_001, TestSize.Level0)
262 {
263 string vibratePath1 = "vibrate/audio.json";
264 string mode = "O_WR";
265 EXPECT_EQ(RingtoneFileUtils::OpenVibrateFile(vibratePath1, mode), E_ERR);
266 const string vibratePath2 = "ringtone/audio.mp3";
267 EXPECT_EQ(RingtoneFileUtils::OpenVibrateFile(vibratePath2, mode), E_INVALID_PATH);
268 }
269
270 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_OpenVibrateFile_Test_002, TestSize.Level0)
271 {
272 string vibratePath1 = "";
273 string mode1 = "O_RDONLY";
274 EXPECT_EQ(RingtoneFileUtils::OpenVibrateFile(vibratePath1, mode1), E_ERR);
275 string vibratePath2 = "vibrate/audio.json";
276 string mode2 = "";
277 EXPECT_EQ(RingtoneFileUtils::OpenVibrateFile(vibratePath2, mode2), E_ERR);
278 string vibratePath3 = "vibrate/audio.json";
279 string mode3 = "O_RDWR";
280 EXPECT_EQ(RingtoneFileUtils::OpenVibrateFile(vibratePath3, mode3), E_ERR);
281 }
282
283 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_ParseFromUri_Test_002, TestSize.Level0)
284 {
285 string path1 = "content://test";
286 bool isTitle = false;
287 string fileName1 = RingtoneFileUtils::GetFileNameFromPathOrUri(path1, isTitle);
288 EXPECT_TRUE(fileName1.empty());
289 string path2 = "content://title/test&data";
290 string fileName2 = RingtoneFileUtils::GetFileNameFromPathOrUri(path2, isTitle);
291 EXPECT_FALSE(fileName2.empty());
292 }
293
294 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_GetFileExtension_Test_001, TestSize.Level0)
295 {
296 string path1 = "ringtone/audio.mp3";
297 string extension = "mp3";
298 string str1 = RingtoneFileUtils::GetFileExtension(path1);
299 EXPECT_EQ(str1, extension);
300 string path2 = "ringtone/audio";
301 string str2 = RingtoneFileUtils::GetFileExtension(path2);
302 EXPECT_EQ(str2, "");
303 }
304
305 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_UrlDecode_Test_001, TestSize.Level0)
306 {
307 string uri = "%";
308 string result = RingtoneFileUtils::UrlDecode(uri);
309 EXPECT_NE(result, "");
310 }
311
312 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_MoveDirectory_Test_001, TestSize.Level0)
313 {
314 string srcDir = "/data/test/moveDirectory/src";
315 string dstDir = "/data/test/moveDirectory/dst";
316 int32_t result = RingtoneFileUtils::MoveDirectory(srcDir, dstDir);
317 EXPECT_EQ(result, E_FAIL);
318
319 EXPECT_TRUE(RingtoneFileUtils::CreateDirectory(srcDir));
320 result = RingtoneFileUtils::MoveDirectory(srcDir, dstDir);
321 EXPECT_EQ(result, E_FAIL);
322
323 EXPECT_TRUE(RingtoneFileUtils::CreateDirectory(dstDir));
324 result = RingtoneFileUtils::MoveDirectory(srcDir, dstDir);
325 EXPECT_EQ(result, E_SUCCESS);
326
327 string fileUri = "/data/test/moveDirectory/src/test.ogg";
328 EXPECT_EQ(RingtoneFileUtils::CreateFile(fileUri), E_SUCCESS);
329 result = RingtoneFileUtils::MoveDirectory(srcDir, dstDir);
330 EXPECT_EQ(result, E_SUCCESS);
331
332 RingtoneFileUtils::MoveRingtoneFolder();
333 RingtoneFileUtils::AccessRingtoneDir();
334 }
335
336 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_GetFileExtension_Test_002, TestSize.Level0)
337 {
338 string path = "";
339 string result = RingtoneFileUtils::GetFileExtension(path);
340 EXPECT_EQ(result, "");
341 }
342
343 HWTEST_F(RingtoneFileUtilsTest, ringtoneUtils_ReplaceAll_Test_001, TestSize.Level0)
344 {
345 string str = "";
346 string oldValue = "old";
347 string newValue = "new";
348 string result = RingtoneUtils::ReplaceAll(str, oldValue, newValue);
349 EXPECT_EQ(result, "");
350
351 str = "test";
352 result = RingtoneUtils::ReplaceAll(str, oldValue, newValue);
353 EXPECT_EQ(result, "test");
354
355 oldValue = "est";
356 newValue = "ese";
357 result = RingtoneUtils::ReplaceAll(str, oldValue, newValue);
358 EXPECT_EQ(result, "tese");
359
360 str = "test";
361 oldValue = "t";
362 newValue = "o";
363 result = RingtoneUtils::ReplaceAll(str, oldValue, newValue);
364 EXPECT_EQ(result, "oeso");
365
366 str = "test";
367 oldValue = "est";
368 newValue = "est1";
369 result = RingtoneUtils::ReplaceAll(str, oldValue, newValue);
370 EXPECT_EQ(result, "test1");
371
372 str = "test";
373 oldValue = "est";
374 newValue = "";
375 result = RingtoneUtils::ReplaceAll(str, oldValue, newValue);
376 EXPECT_EQ(result, "t");
377 }
378
379 HWTEST_F(RingtoneFileUtilsTest, ringtoneUtils_IsNumber_Test_001, TestSize.Level0)
380 {
381 string str = "";
382 bool result = RingtoneUtils::IsNumber(str);
383 EXPECT_FALSE(result);
384
385 string longStr(MAX_SIZE + 1, '1');
386 result = RingtoneUtils::IsNumber(longStr);
387 EXPECT_FALSE(result);
388
389 str = "123abc123";
390 result = RingtoneUtils::IsNumber(str);
391 EXPECT_FALSE(result);
392 }
393
394 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_Mkdir_Test_003, TestSize.Level0)
395 {
396 const string path = "/data/local/tmp/test";
397 std::shared_ptr<int> errCodePtr = std::make_shared<int>();;
398 auto ret = RingtoneFileUtils::Mkdir(path);
399 EXPECT_EQ(ret, true);
400 }
401
402 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_OpenVibrateFile_Test_003, TestSize.Level1)
403 {
404 std::string filePath(PATH_MAX + 1, 'a');
405 std::string mode = RINGTONE_FILEMODE_READONLY;
406 int32_t result = RingtoneFileUtils::OpenVibrateFile(filePath, mode);
407 EXPECT_EQ(result, -209);
408 }
409
410 HWTEST_F(RingtoneFileUtilsTest, ringtoneFileUtils_OpenVibrateFile_Test_004, TestSize.Level1)
411 {
412 std::string filePath = "/path/to/vibrate_file.json";
413 std::string mode = RINGTONE_FILEMODE_READONLY;
414
415 int32_t result = RingtoneFileUtils::OpenVibrateFile(filePath, mode);
416 EXPECT_EQ(result, E_ERR);
417 }
418
419 HWTEST_F(RingtoneFileUtilsTest, ringtoneUtils_MoveEL2DBToEL1DB_Test_001, TestSize.Level1)
420 {
421 std::shared_ptr<RingtoneUtils> ringtoneutils = std::make_shared<RingtoneUtils>();
422 EXPECT_NE(ringtoneutils, nullptr);
423 bool ret = ringtoneutils->MoveEL2DBToEL1DB();
424 EXPECT_EQ(ret, true);
425 ret = ringtoneutils->SetMoveEL2DBToEL1();
426 EXPECT_EQ(ret, true);
427 }
428
429 HWTEST_F(RingtoneFileUtilsTest, ringtoneUtils_GetTotalSize_Test_001, TestSize.Level1)
430 {
431 system("mkdir /data/storage/el2/base");
432 int64_t totalSize = RingtoneUtils::GetTotalSize();
433 EXPECT_GT(totalSize, 0);
434 }
435
436 HWTEST_F(RingtoneFileUtilsTest, ringtoneUtils_GetFreeSize_Test_001, TestSize.Level1)
437 {
438 system("mkdir /data/storage/el2/base");
439 int64_t freeSize = RingtoneUtils::GetFreeSize();
440 EXPECT_GT(freeSize, 0);
441 }
442
443 HWTEST_F(RingtoneFileUtilsTest, ringtoneUtils_CheckRemainSpaceMeetCondition_Test_001, TestSize.Level1)
444 {
445 bool result = RingtoneUtils::CheckRemainSpaceMeetCondition();
446 EXPECT_TRUE(result);
447 }
448
449 HWTEST_F(RingtoneFileUtilsTest, ringtonexcollie_CancelXCollieTimer_Test_001, TestSize.Level1)
450 {
451 std::string tag = "";
452 std::shared_ptr<RingtoneXCollie> ringtonexcollie = std::make_shared<RingtoneXCollie>(tag);
453 EXPECT_NE(ringtonexcollie, nullptr);
454 ringtonexcollie->id_ = 0;
455 ringtonexcollie->CancelXCollieTimer();
456 ringtonexcollie->id_ = 1;
457 ringtonexcollie->isCanceled_ = true;
458 ringtonexcollie->CancelXCollieTimer();
459 EXPECT_EQ(ringtonexcollie->isCanceled_, true);
460 }
461 } // namespace Media
462 } // namespace OHOS
463