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 auto instance = RingtoneScannerManager::GetInstance();
169 EXPECT_NE(instance, nullptr);
170 instance->Start(true);
171 instance->Start(false);
172 instance->Stop();
173 }
174
175 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanFile_test_001, TestSize.Level0)
176 {
177 if (g_ringtoneScannerManager == nullptr) {
178 RINGTONE_ERR_LOG("g_ringtoneScannerManager invalid");
179 exit(1);
180 }
181
182 const string path = "files/Ringtone/Canonical1.ogg";
183
184 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
185 int result = g_ringtoneScannerManager->ScanFile(path, scannerCallback);
186 EXPECT_EQ(result, E_INVALID_PATH);
187 }
188
189 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanFileSync_CanonicalPathtest_001, TestSize.Level0)
190 {
191 if (g_ringtoneScannerManager == nullptr) {
192 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
193 exit(1);
194 }
195
196 string path = STORAGE_FILES_DIR + "../files/Ringtone/Canonical1.ogg";
197 EXPECT_EQ(RingtoneUnitTestUtils::CreateFileFS(path), true);
198
199 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
200 int result = g_ringtoneScannerManager->ScanFileSync(path, scannerCallback, true);
201 EXPECT_EQ(result, E_OK);
202
203 if (result == 0) {
204 RingtoneUnitTestUtils::WaitForCallback(scannerCallback);
205 EXPECT_EQ(scannerCallback->status_, E_OK);
206 }
207
208 path = "/storage/cloud/files";
209 result = g_ringtoneScannerManager->ScanFileSync(path, scannerCallback, true);
210 EXPECT_EQ(result, E_INVALID_PATH);
211 }
212
213 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanFileSync_CanonicalPathtest_002, TestSize.Level0)
214 {
215 if (g_ringtoneScannerManager == nullptr) {
216 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
217 exit(1);
218 }
219
220 string path = STORAGE_FILES_DIR + "../files/Ringtone/Canonical1.ogg";
221 EXPECT_EQ(RingtoneUnitTestUtils::CreateFileFS(path), true);
222
223 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
224 int result = g_ringtoneScannerManager->ScanFileSync(path, scannerCallback, false);
225 EXPECT_EQ(result, E_OK);
226
227 if (result == 0) {
228 RingtoneUnitTestUtils::WaitForCallback(scannerCallback);
229 EXPECT_EQ(scannerCallback->status_, E_OK);
230 }
231 }
232
233 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanDirSync_CanonicalPathtest_001, TestSize.Level0)
234 {
235 if (g_ringtoneScannerManager == nullptr) {
236 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
237 exit(1);
238 }
239
240 const string path = STORAGE_FILES_DIR + "../files";
241
242 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
243 int result = g_ringtoneScannerManager->ScanDirSync(path, scannerCallback);
244 EXPECT_EQ(result, E_OK);
245
246 if (result == 0) {
247 RingtoneUnitTestUtils::WaitForCallback(scannerCallback);
248 EXPECT_EQ(scannerCallback->status_, E_OK);
249 }
250 }
251
252 HWTEST_F(RingtoneScannerUnitTest, scannerManager_ScanDirSync_CanonicalPathtest_002, TestSize.Level0)
253 {
254 if (g_ringtoneScannerManager == nullptr) {
255 RINGTONE_ERR_LOG("RingtoneScannerManager invalid");
256 exit(1);
257 }
258
259 const string path = "files/Ringtone/Canonical.ogg";
260
261 auto scannerCallback = make_shared<TestRingtoneScannerCallback>();
262 int result = g_ringtoneScannerManager->ScanDirSync(path, scannerCallback);
263 EXPECT_EQ(result, E_INVALID_PATH);
264 }
265 } // namespace Media
266 } // namespace OHOS
267