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