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_scanner_unit_test.h"
17
18 #include "ringtone_errno.h"
19 #include "ringtone_log.h"
20 #include "ringtone_scanner_manager.h"
21 #include "ringtone_scanner_utils.h"
22 #include "ringtone_unittest_utils.h"
23
24 using namespace std;
25 using namespace OHOS;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Media {
30 namespace {
31 shared_ptr<RingtoneScannerManager> g_ringtoneScannerManager = nullptr;
32 } // namespace
33
34
SetUpTestCase()35 void RingtoneScannerUnitTest::SetUpTestCase()
36 {
37 RingtoneUnitTestUtils::Init();
38
39 g_ringtoneScannerManager = RingtoneScannerManager::GetInstance();
40 }
41
TearDownTestCase()42 void RingtoneScannerUnitTest::TearDownTestCase() {}
43
44 // SetUp:Execute before each test case
SetUp()45 void RingtoneScannerUnitTest::SetUp()
46 {
47 RingtoneUnitTestUtils::CleanTestFiles();
48 RingtoneUnitTestUtils::InitRootDirs();
49 }
50
TearDown(void)51 void RingtoneScannerUnitTest::TearDown(void)
52 {
53 RingtoneUnitTestUtils::CleanTestFiles();
54 }
55
56 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanDir_test_001, TestSize.Level0)
57 {
58 if (g_ringtoneScannerManager == nullptr) {
59 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
60 exit(1);
61 }
62
63 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
64 int result = g_ringtoneScannerManager->ScanDir(STORAGE_FILES_DIR, scannerCallback);
65 EXPECT_EQ(result, E_OK);
66
67 if (result == 0) {
68 RingtoneUnitTestUtils::WaitForCallback(scannerCallback);
69 EXPECT_EQ(scannerCallback->status_, E_OK);
70 }
71 }
72
73
74 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanDir_test_002, TestSize.Level0)
75 {
76 if (g_ringtoneScannerManager == nullptr) {
77 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
78 exit(1);
79 }
80
81 const string path = "Ringtone/Scanner_ringtone.ogg";
82 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
83 int result = g_ringtoneScannerManager->ScanDir(path, scannerCallback);
84 EXPECT_EQ(result, E_INVALID_PATH);
85 }
86
87 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanOgg_test_001, TestSize.Level0)
88 {
89 if (g_ringtoneScannerManager == nullptr) {
90 RINGTONE_ERR_LOG("g_ringtoneScannerManager invalid");
91 exit(1);
92 }
93
94 const string path = STORAGE_FILES_DIR + "Ringtone/Scanner_ringtone.ogg";
95 EXPECT_EQ(RingtoneUnitTestUtils::CreateFileFS(path), true);
96
97 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
98 int result = g_ringtoneScannerManager->ScanFile(path, scannerCallback);
99 EXPECT_EQ(result, E_OK);
100
101 if (result == 0) {
102 RingtoneUnitTestUtils::WaitForCallback(scannerCallback);
103 EXPECT_EQ(scannerCallback->status_, E_OK);
104 }
105 }
106
107 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanHiddenFile_Test_001, TestSize.Level0)
108 {
109 if (g_ringtoneScannerManager == nullptr) {
110 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
111 exit(1);
112 }
113
114 const string path = STORAGE_FILES_DIR + "Ringtone/.HiddenFile";
115 EXPECT_EQ(RingtoneUnitTestUtils::CreateFileFS(path), true);
116
117 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
118 int result = g_ringtoneScannerManager->ScanFile(path, scannerCallback);
119 EXPECT_EQ(result, E_OK);
120
121 if (result == 0) {
122 RingtoneUnitTestUtils::WaitForCallback(scannerCallback);
123 EXPECT_EQ(scannerCallback->status_, E_FILE_HIDDEN);
124 }
125 }
126
127 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanDir_CanonicalPathtest_001, TestSize.Level0)
128 {
129 if (g_ringtoneScannerManager == nullptr) {
130 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
131 exit(1);
132 }
133
134 const string path = STORAGE_FILES_DIR + "../files";
135
136 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
137 int result = g_ringtoneScannerManager->ScanDir(path, scannerCallback);
138 EXPECT_EQ(result, E_OK);
139
140 if (result == 0) {
141 RingtoneUnitTestUtils::WaitForCallback(scannerCallback);
142 EXPECT_EQ(scannerCallback->status_, E_OK);
143 }
144 }
145
146 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanFile_CanonicalPathtest_001, TestSize.Level0)
147 {
148 if (g_ringtoneScannerManager == nullptr) {
149 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
150 exit(1);
151 }
152
153 const string path = STORAGE_FILES_DIR + "../files/Ringtone/Canonical1.ogg";
154 EXPECT_EQ(RingtoneUnitTestUtils::CreateFileFS(path), true);
155
156 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
157 int result = g_ringtoneScannerManager->ScanFile(path, scannerCallback);
158 EXPECT_EQ(result, E_OK);
159
160 if (result == 0) {
161 RingtoneUnitTestUtils::WaitForCallback(scannerCallback);
162 EXPECT_EQ(scannerCallback->status_, E_OK);
163 }
164 }
165
166 HWTEST_F(RingtoneScannerUnitTest, scannerManager_Strat_test_001, TestSize.Level0)
167 {
168 if (g_ringtoneScannerManager == nullptr) {
169 RINGTONE_ERR_LOG("g_ringtoneScannerManager invalid");
170 exit(1);
171 }
172
173 RingtoneScannerManager::GetInstance();
174 g_ringtoneScannerManager->Start(true);
175 g_ringtoneScannerManager->Start(false);
176 g_ringtoneScannerManager->Stop();
177 }
178
179 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanFile_test_001, TestSize.Level0)
180 {
181 if (g_ringtoneScannerManager == nullptr) {
182 RINGTONE_ERR_LOG("g_ringtoneScannerManager invalid");
183 exit(1);
184 }
185
186 const string path = "files/Ringtone/Canonical1.ogg";
187
188 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
189 int result = g_ringtoneScannerManager->ScanFile(path, scannerCallback);
190 EXPECT_EQ(result, E_INVALID_PATH);
191 }
192
193 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanFileSync_CanonicalPathtest_001, TestSize.Level0)
194 {
195 if (g_ringtoneScannerManager == nullptr) {
196 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
197 exit(1);
198 }
199
200 string path = STORAGE_FILES_DIR + "../files/Ringtone/Canonical1.ogg";
201 EXPECT_EQ(RingtoneUnitTestUtils::CreateFileFS(path), true);
202
203 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
204 int result = g_ringtoneScannerManager->ScanFileSync(path, scannerCallback, true);
205 EXPECT_EQ(result, E_OK);
206
207 if (result == 0) {
208 RingtoneUnitTestUtils::WaitForCallback(scannerCallback);
209 EXPECT_EQ(scannerCallback->status_, E_OK);
210 }
211
212 path = "/storage/cloud/files";
213 result = g_ringtoneScannerManager->ScanFileSync(path, scannerCallback, true);
214 EXPECT_EQ(result, E_INVALID_PATH);
215 }
216
217 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanFileSync_CanonicalPathtest_002, TestSize.Level0)
218 {
219 if (g_ringtoneScannerManager == nullptr) {
220 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
221 exit(1);
222 }
223
224 string path = STORAGE_FILES_DIR + "../files/Ringtone/Canonical1.ogg";
225 EXPECT_EQ(RingtoneUnitTestUtils::CreateFileFS(path), true);
226
227 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
228 int result = g_ringtoneScannerManager->ScanFileSync(path, scannerCallback, false);
229 EXPECT_EQ(result, E_OK);
230
231 if (result == 0) {
232 RingtoneUnitTestUtils::WaitForCallback(scannerCallback);
233 EXPECT_EQ(scannerCallback->status_, E_OK);
234 }
235 }
236
237 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanDirSync_CanonicalPathtest_001, TestSize.Level0)
238 {
239 if (g_ringtoneScannerManager == nullptr) {
240 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
241 exit(1);
242 }
243
244 const string path = STORAGE_FILES_DIR + "../files";
245
246 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
247 int result = g_ringtoneScannerManager->ScanDirSync(path, scannerCallback);
248 EXPECT_EQ(result, E_OK);
249
250 if (result == 0) {
251 RingtoneUnitTestUtils::WaitForCallback(scannerCallback);
252 EXPECT_EQ(scannerCallback->status_, E_OK);
253 }
254 }
255
256 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanDirSync_CanonicalPathtest_002, TestSize.Level0)
257 {
258 if (g_ringtoneScannerManager == nullptr) {
259 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
260 exit(1);
261 }
262
263 const string path = "files/Ringtone/Canonical.ogg";
264
265 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
266 int result = g_ringtoneScannerManager->ScanDirSync(path, scannerCallback);
267 EXPECT_EQ(result, E_INVALID_PATH);
268 }
269 } // namespace Media
270 } // namespace OHOS
271