1 /*
2 * Copyright (C) 2021-2022 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 "mediascanner_unit_test.h"
17
18 #include "medialibrary_errno.h"
19 #include "medialibrary_unittest_utils.h"
20 #include "media_log.h"
21 #include "media_scanner_manager.h"
22 #include "scanner_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<MediaScannerManager> mediaScannerManager = nullptr;
32 } // namespace
33
34 constexpr int32_t WAIT_TIME = 3;
35
SetUpTestCase(void)36 void MediaScannerUnitTest::SetUpTestCase(void)
37 {
38 MediaLibraryUnitTestUtils::Init();
39
40 mediaScannerManager = MediaScannerManager::GetInstance();
41 }
42
TearDownTestCase(void)43 void MediaScannerUnitTest::TearDownTestCase(void)
44 {
45 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
46 }
47
48 // SetUp:Execute before each test case
SetUp()49 void MediaScannerUnitTest::SetUp()
50 {
51 MediaLibraryUnitTestUtils::CleanTestFiles();
52 MediaLibraryUnitTestUtils::InitRootDirs();
53 }
54
TearDown(void)55 void MediaScannerUnitTest::TearDown(void) {}
56
57 /**
58 * @tc.number : MediaScanner_ScanDir_test_001
59 * @tc.name : scan root dir
60 * @tc.desc : scan root dir with six dirs
61 */
62 HWTEST_F(MediaScannerUnitTest, MediaScanner_ScanDir_test_001, TestSize.Level0)
63 {
64 if (mediaScannerManager == nullptr) {
65 MEDIA_ERR_LOG("MediaScannerManager invalid");
66 exit(1);
67 }
68
69 auto scannerCallback = make_shared<TestScannerCallback>();
70 int result = mediaScannerManager->ScanDir(ROOT_MEDIA_DIR, scannerCallback);
71 EXPECT_EQ(result, E_OK);
72
73 if (result == 0) {
74 MediaLibraryUnitTestUtils::WaitForCallback(scannerCallback);
75 EXPECT_EQ(scannerCallback->status_, E_OK);
76 }
77 }
78
79 /**
80 * @tc.number : MediaScanner_ScanImage_Test_001
81 * @tc.name : scan jpg file
82 * @tc.desc : 1.create jpg file Scanner_Image1.jpg
83 * 2.scan this file
84 */
85 HWTEST_F(MediaScannerUnitTest, MediaScanner_ScanImage_Test_001, TestSize.Level0)
86 {
87 if (mediaScannerManager == nullptr) {
88 MEDIA_ERR_LOG("MediaScannerManager invalid");
89 exit(1);
90 }
91
92 string path = ROOT_MEDIA_DIR + "Pictures/Scanner_Image1.jpg";
93 EXPECT_EQ(MediaLibraryUnitTestUtils::CreateFileFS(path), true);
94
95 auto scannerCallback = make_shared<TestScannerCallback>();
96 int result = mediaScannerManager->ScanFile(path, scannerCallback);
97 EXPECT_EQ(result, E_OK);
98
99 if (result == 0) {
100 MediaLibraryUnitTestUtils::WaitForCallback(scannerCallback);
101 EXPECT_EQ(scannerCallback->status_, E_OK);
102 }
103 }
104
105 /**
106 * @tc.number : MediaScanner_ScanImage_Test_002
107 * @tc.name : scan png file
108 * @tc.desc : 1.create png file Scanner_Image2.png
109 * 2.scan this file
110 */
111 HWTEST_F(MediaScannerUnitTest, MediaScanner_ScanImage_Test_002, TestSize.Level0)
112 {
113 if (mediaScannerManager == nullptr) {
114 MEDIA_ERR_LOG("MediaScannerManager invalid");
115 exit(1);
116 }
117
118 string path = ROOT_MEDIA_DIR + "Pictures/Scanner_Image2.png";
119 EXPECT_EQ(MediaLibraryUnitTestUtils::CreateFileFS(path), true);
120
121 auto scannerCallback = make_shared<TestScannerCallback>();
122 int result = mediaScannerManager->ScanFile(path, scannerCallback);
123 EXPECT_EQ(result, E_OK);
124
125 if (result == 0) {
126 MediaLibraryUnitTestUtils::WaitForCallback(scannerCallback);
127 EXPECT_EQ(scannerCallback->status_, E_OK);
128 }
129 }
130
131 /**
132 * @tc.number : MediaScanner_ScanImage_Test_003
133 * @tc.name : scan jpeg file
134 * @tc.desc : 1.create jpeg file Scanner_Image3.jpeg
135 * 2.scan this file
136 */
137 HWTEST_F(MediaScannerUnitTest, MediaScanner_ScanImage_Test_003, TestSize.Level0)
138 {
139 if (mediaScannerManager == nullptr) {
140 MEDIA_ERR_LOG("MediaScannerManager invalid");
141 exit(1);
142 }
143
144 string path = ROOT_MEDIA_DIR + "Pictures/Scanner_Image3.jpeg";
145 EXPECT_EQ(MediaLibraryUnitTestUtils::CreateFileFS(path), true);
146
147 auto scannerCallback = make_shared<TestScannerCallback>();
148 int result = mediaScannerManager->ScanFile(path, scannerCallback);
149 EXPECT_EQ(result, E_OK);
150
151 if (result == 0) {
152 MediaLibraryUnitTestUtils::WaitForCallback(scannerCallback);
153 EXPECT_EQ(scannerCallback->status_, E_OK);
154 }
155 }
156
157 /**
158 * @tc.number : MediaScanner_ScanTextFile_Test_001
159 * @tc.name : scan text file
160 * @tc.desc : 1.create text file Scanner_Text1.txt
161 * 2.scan this text file
162 */
163 HWTEST_F(MediaScannerUnitTest, MediaScanner_ScanTextFile_Test_001, TestSize.Level0)
164 {
165 if (mediaScannerManager == nullptr) {
166 MEDIA_ERR_LOG("MediaScannerManager invalid");
167 exit(1);
168 }
169
170 string path = ROOT_MEDIA_DIR + "Docs/Documents/Scanner_Text1.txt";
171 EXPECT_EQ(MediaLibraryUnitTestUtils::CreateFileFS(path), true);
172
173 auto scannerCallback = make_shared<TestScannerCallback>();
174 int result = mediaScannerManager->ScanFile(path, scannerCallback);
175 EXPECT_EQ(result, E_OK);
176
177 if (result == 0) {
178 MediaLibraryUnitTestUtils::WaitForCallback(scannerCallback);
179 EXPECT_EQ(scannerCallback->status_, E_OK);
180 }
181 }
182
183 /**
184 * @tc.number : MediaScanner_ScanHiddenFile_Test_001
185 * @tc.name : scan hidden file
186 * @tc.desc : 1.create hidden file .HiddenFile
187 * 2.scan this hidden file
188 * 3.expect return error
189 */
190 HWTEST_F(MediaScannerUnitTest, MediaScanner_ScanHiddenFile_Test_001, TestSize.Level0)
191 {
192 if (mediaScannerManager == nullptr) {
193 MEDIA_ERR_LOG("MediaScannerManager invalid");
194 exit(1);
195 }
196
197 string path = ROOT_MEDIA_DIR + "Docs/Download/.HiddenFile";
198 EXPECT_EQ(MediaLibraryUnitTestUtils::CreateFileFS(path), true);
199
200 auto scannerCallback = make_shared<TestScannerCallback>();
201 int result = mediaScannerManager->ScanFile(path, scannerCallback);
202 EXPECT_EQ(result, E_OK);
203
204 if (result == 0) {
205 MediaLibraryUnitTestUtils::WaitForCallback(scannerCallback);
206 EXPECT_EQ(scannerCallback->status_, E_FILE_HIDDEN);
207 }
208 }
209
210 /**
211 * @tc.number : MediaScanner_ScanDir_CanonicalPathtest_001
212 * @tc.name : scan dir with uncanonical path
213 * @tc.desc : 1.pass dir's uncanonical path
214 */
215 HWTEST_F(MediaScannerUnitTest, MediaScanner_ScanDir_CanonicalPathtest_001, TestSize.Level0)
216 {
217 if (mediaScannerManager == nullptr) {
218 MEDIA_ERR_LOG("MediaScannerManager invalid");
219 exit(1);
220 }
221
222 string path = ROOT_MEDIA_DIR + "../files";
223
224 auto scannerCallback = make_shared<TestScannerCallback>();
225 int result = mediaScannerManager->ScanDir(path, scannerCallback);
226 EXPECT_EQ(result, E_OK);
227
228 if (result == 0) {
229 MediaLibraryUnitTestUtils::WaitForCallback(scannerCallback);
230 EXPECT_EQ(scannerCallback->status_, E_OK);
231 }
232 }
233
234 /**
235 * @tc.number : MediaScanner_ScanFile_CanonicalPathtest_001
236 * @tc.name : scan file with uncanonical path
237 * @tc.desc : 1.create file
238 * 2.pass file's uncanonical path
239 */
240 HWTEST_F(MediaScannerUnitTest, MediaScanner_ScanFile_CanonicalPathtest_001, TestSize.Level0)
241 {
242 if (mediaScannerManager == nullptr) {
243 MEDIA_ERR_LOG("MediaScannerManager invalid");
244 exit(1);
245 }
246
247 string path = ROOT_MEDIA_DIR + "../files/Pictures/Canonical1.jpg";
248 EXPECT_EQ(MediaLibraryUnitTestUtils::CreateFileFS(path), true);
249
250 auto scannerCallback = make_shared<TestScannerCallback>();
251 int result = mediaScannerManager->ScanFile(path, scannerCallback);
252 EXPECT_EQ(result, E_OK);
253
254 if (result == 0) {
255 MediaLibraryUnitTestUtils::WaitForCallback(scannerCallback);
256 EXPECT_EQ(scannerCallback->status_, E_OK);
257 }
258 }
259
260 /**
261 * @tc.number : MediaScanner_ScanFile_CanonicalPathtest_002
262 * @tc.name : scan file with uncanonical path
263 * @tc.desc : 1.create file
264 * 2.pass file's uncanonical path
265 */
266 HWTEST_F(MediaScannerUnitTest, MediaScanner_ScanFile_CanonicalPathtest_002, TestSize.Level0)
267 {
268 if (mediaScannerManager == nullptr) {
269 MEDIA_ERR_LOG("MediaScannerManager invalid");
270 exit(1);
271 }
272
273 string path = ROOT_MEDIA_DIR + "../files/Docs/Documents/Canonical2.txt";
274 EXPECT_EQ(MediaLibraryUnitTestUtils::CreateFileFS(path), true);
275
276 auto scannerCallback = make_shared<TestScannerCallback>();
277 int result = mediaScannerManager->ScanFile(path, scannerCallback);
278 EXPECT_EQ(result, E_OK);
279
280 if (result == 0) {
281 MediaLibraryUnitTestUtils::WaitForCallback(scannerCallback);
282 EXPECT_EQ(scannerCallback->status_, E_OK);
283 }
284 }
285 } // namespace Media
286 } // namespace OHOS
287
