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