1 /*
2 * Copyright (c) 2025 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 <gtest/gtest.h>
17 #include <system_ability_definition.h>
18
19 #include "disk.h"
20 #include "message_parcel.h"
21 #include "storage_manager.h"
22 #include "storage_manager_provider.h"
23 #include "storage_service_errno.h"
24 #include "test/common/help_utils.h"
25 #include "mock/uece_activation_callback_mock.h"
26 #include "user/multi_user_manager_service.h"
27 #include "volume_core.h"
28 #include <cstdlib>
29 #include <cstring>
30 #include <gtest/gtest.h>
31 #include <map>
32 #include <memory>
33 #include <mutex>
34 #include <thread>
35 #include <vector>
36 namespace OHOS {
37 namespace StorageManager {
38 using namespace testing;
39 using namespace testing::ext;
40 class StorageManagerProviderTest : public testing::Test {
41 public:
SetUpTestCase(void)42 static void SetUpTestCase(void) {};
TearDownTestCase(void)43 static void TearDownTestCase(void) {};
44 void SetUp();
45 void TearDown();
46
47 std::unique_ptr<StorageManagerProvider> storageManagerProviderTest_;
48 };
49
StringVecToRawData(const std::vector<std::string> & stringVec,StorageFileRawData & rawData)50 void StringVecToRawData(const std::vector<std::string> &stringVec, StorageFileRawData &rawData)
51 {
52 std::stringstream ss;
53 uint32_t stringCount = stringVec.size();
54 ss.write(reinterpret_cast<const char*>(&stringCount), sizeof(stringCount));
55
56 for (uint32_t i = 0; i < stringCount; ++i) {
57 uint32_t strLen = stringVec[i].length();
58 ss.write(reinterpret_cast<const char*>(&strLen), sizeof(strLen));
59 ss.write(stringVec[i].c_str(), strLen);
60 }
61 std::string result = ss.str();
62 rawData.ownedData = std::move(result);
63 rawData.data = rawData.ownedData.data();
64 rawData.size = rawData.ownedData.size();
65 }
66
SetUp(void)67 void StorageManagerProviderTest::SetUp(void)
68 {
69 storageManagerProviderTest_ = std::make_unique<StorageManagerProvider>(STORAGE_MANAGER_MANAGER_ID);
70 }
71
TearDown(void)72 void StorageManagerProviderTest::TearDown(void) {}
73 /**
74 * @tc.name: StorageManagerProviderTest_PrepareAddUser_001
75 * @tc.desc: Verify the PrepareAddUser function.
76 * @tc.type: FUNC
77 * @tc.require: AR000H09L6
78 */
79 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_PrepareAddUser_001, TestSize.Level1)
80 {
81 GTEST_LOG_(INFO) << "StorageManagerProviderTest_PrepareAddUser_001 start";
82 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
83 int32_t userId = 121;
84 uint32_t flags = 3;
85 auto ret = storageManagerProviderTest_->PrepareAddUser(userId, flags);
86 EXPECT_EQ(ret, E_PERMISSION_DENIED);
87 GTEST_LOG_(INFO) << "StorageManagerProviderTest_PrepareAddUser_001 end";
88 }
89
90 /**
91 * @tc.name: StorageManagerProviderTest_RemoveUser_001
92 * @tc.desc: Verify the RemoveUser function.
93 * @tc.type: FUNC
94 * @tc.require: AR000H09L6
95 */
96 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_RemoveUser_001, TestSize.Level1)
97 {
98 GTEST_LOG_(INFO) << "StorageManagerProviderTest_RemoveUser_001 start";
99 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
100 const int32_t testUserId = 1001;
101 const uint32_t testFlags = 0;
102 auto ret = storageManagerProviderTest_->RemoveUser(testUserId, testFlags);
103 EXPECT_EQ(ret, E_PERMISSION_DENIED);
104 GTEST_LOG_(INFO) << "StorageManagerProviderTest_RemoveUser_001 end";
105 }
106
107 /**
108 * @tc.name: StorageManagerProviderTest_PrepareStartUser_001
109 * @tc.desc: Verify the PrepareStartUser function.
110 * @tc.type: FUNC
111 * @tc.require: AR000H09L6
112 */
113 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_PrepareStartUser_001, TestSize.Level1)
114 {
115 GTEST_LOG_(INFO) << "StorageManagerProviderTest_PrepareStartUser_001 start";
116 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
117 auto ret = storageManagerProviderTest_->PrepareStartUser(OHOS::StorageDaemon::StorageTest::USER_ID1);
118 EXPECT_EQ(ret, E_PERMISSION_DENIED);
119 GTEST_LOG_(INFO) << "StorageManagerProviderTest_PrepareStartUser_001 end";
120 }
121
122 /**
123 * @tc.name: StorageManagerProviderTest_StopUser_001
124 * @tc.desc: Verify the StopUser function.
125 * @tc.type: FUNC
126 * @tc.require: AR000H09L6
127 */
128 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_StopUser_001, TestSize.Level1)
129 {
130 GTEST_LOG_(INFO) << "StorageManagerProviderTest_StopUser_001 start";
131 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
132 auto ret = storageManagerProviderTest_->StopUser(OHOS::StorageDaemon::StorageTest::USER_ID2);
133 EXPECT_EQ(ret, E_PERMISSION_DENIED);
134 GTEST_LOG_(INFO) << "StorageManagerProviderTest_StopUser_001 end";
135 }
136
137 /**
138 * @tc.name: StorageManagerProviderTest_CompleteAddUser_001
139 * @tc.desc: Verify the CompleteAddUser function.
140 * @tc.type: FUNC
141 * @tc.require: AR000H09L6
142 */
143 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_CompleteAddUser_001, TestSize.Level1)
144 {
145 GTEST_LOG_(INFO) << "storageManagerProviderTest_CompleteAddUser_001 start";
146 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
147 auto ret = storageManagerProviderTest_->CompleteAddUser(OHOS::StorageDaemon::StorageTest::USER_ID3);
148 EXPECT_EQ(ret, E_PERMISSION_DENIED);
149 GTEST_LOG_(INFO) << "StorageManagerProviderTest_CompleteAddUser_001 end";
150 }
151
152 /**
153 * @tc.name: StorageManagerProviderTest_GetFreeSizeOfVolume_001
154 * @tc.desc: Verify the GetFreeSizeOfVolume function.
155 * @tc.type: FUNC
156 * @tc.require: AR000H09L6
157 */
158 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetFreeSizeOfVolume_001, TestSize.Level1)
159 {
160 GTEST_LOG_(INFO) << "storageManagerProviderTest_GetFreeSizeOfVolume_001 start";
161 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
162 std::string volumeUuid = "test-volume-uuid";
163 int64_t freeSize = 0;
164 auto ret = storageManagerProviderTest_->GetFreeSizeOfVolume(volumeUuid, freeSize);
165 EXPECT_EQ(ret, E_PERMISSION_DENIED);
166 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetFreeSizeOfVolume_001 end";
167 }
168
169 /**
170 * @tc.name: StorageManagerProviderTest_GetTotalSizeOfVolume_001
171 * @tc.desc: Verify the GetTotalSizeOfVolume function.
172 * @tc.type: FUNC
173 * @tc.require: AR000H09L6
174 */
175 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetTotalSizeOfVolume_001, TestSize.Level1)
176 {
177 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetTotalSizeOfVolume_001 start";
178 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
179 const std::string volumeUuid = "test_volume_uuid";
180 int64_t totalSize = 0;
181 auto ret = storageManagerProviderTest_->GetTotalSizeOfVolume(volumeUuid, totalSize);
182 EXPECT_EQ(ret, E_PERMISSION_DENIED);
183 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetTotalSizeOfVolume_001 end";
184 }
185
186 /**
187 * @tc.name: StorageManagerProviderTest_GetBundleStats_001
188 * @tc.desc: Verify the GetBundleStats function.
189 * @tc.type: FUNC
190 * @tc.require: AR000H09L6
191 */
192 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetBundleStats_001, TestSize.Level1)
193 {
194 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetBundleStats_001 start";
195 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
196 std::string pkgName = "com.example.test";
197 BundleStats bundleStats;
198 int32_t appIndex = 0;
199 uint32_t statFlag = 0x01;
200 auto ret = storageManagerProviderTest_->GetBundleStats(pkgName, bundleStats, appIndex, statFlag);
201 EXPECT_EQ(ret, E_PERMISSION_DENIED);
202 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetBundleStats_001 end";
203 }
204
205 /**
206 * @tc.name: StorageManagerProviderTest_GetSystemSize_001
207 * @tc.desc: Verify the GetSystemSize function.
208 * @tc.type: FUNC
209 * @tc.require: AR000H09L6
210 */
211 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetSystemSize_001, TestSize.Level1)
212 {
213 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetSystemSize_001 start";
214 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
215 int64_t systemSize = 0;
216 auto ret = storageManagerProviderTest_->GetSystemSize(systemSize);
217 EXPECT_EQ(ret, E_PERMISSION_DENIED);
218 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetSystemSize_001 end";
219 }
220
221 /**
222 * @tc.name: StorageManagerProviderTest_GetTotalSize_001
223 * @tc.desc: Verify the GetTotalSize function.
224 * @tc.type: FUNC
225 * @tc.require: AR000H09L6
226 */
227 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetTotalSize_001, TestSize.Level1)
228 {
229 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetTotalSize_001 start";
230 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
231 int64_t totalSize = 0;
232 auto ret = storageManagerProviderTest_->GetTotalSize(totalSize);
233 EXPECT_NE(ret, E_OK);
234 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetTotalSize_001 end";
235 }
236
237 /**
238 * @tc.name: StorageManagerProviderTest_GetFreeSize_001
239 * @tc.desc: Verify the GetFreeSize function.
240 * @tc.type: FUNC
241 * @tc.require: AR000H09L6
242 */
243 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetFreeSize_001, TestSize.Level1)
244 {
245 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetFreeSize_001 start";
246 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
247 int64_t freeSize = 0;
248 auto ret = storageManagerProviderTest_->GetFreeSize(freeSize);
249 EXPECT_NE(ret, E_OK);
250 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetFreeSize_001 end";
251 }
252
253 /**
254 * @tc.name: StorageManagerProviderTest_GetUserStorageStats_001
255 * @tc.desc: Verify the GetUserStorageStats function.
256 * @tc.type: FUNC
257 * @tc.require: AR000H09L6
258 */
259 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetUserStorageStats_001, TestSize.Level1)
260 {
261 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetUserStorageStats_001 start";
262 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
263 StorageStats storageStats;
264 auto ret = storageManagerProviderTest_->GetUserStorageStats(storageStats);
265 EXPECT_EQ(ret, E_PERMISSION_DENIED);
266 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetUserStorageStats_001 end";
267 }
268
269 /**
270 * @tc.name: StorageManagerProviderTest_GetUserStorageStatsIpc_001
271 * @tc.desc: Verify the GetUserStorageStatsIpc function.
272 * @tc.type: FUNC
273 * @tc.require: AR000H09L6
274 */
275 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetUserStorageStatsIpc_001, TestSize.Level1)
276 {
277 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetUserStorageStatsIpc_001 start";
278 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
279 int32_t userId = 1001;
280 StorageStats storageStats;
281 auto ret = storageManagerProviderTest_->GetUserStorageStats(userId, storageStats);
282 EXPECT_EQ(ret, E_PERMISSION_DENIED);
283 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetUserStorageStatsIpc_001 end";
284 }
285
286 /**
287 * @tc.name: StorageManagerProviderTest_GetCurrentBundleStats_001
288 * @tc.desc: Verify the GetCurrentBundleStats function.
289 * @tc.type: FUNC
290 * @tc.require: AR000H09L6
291 */
292 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetCurrentBundleStats_001, TestSize.Level1)
293 {
294 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetCurrentBundleStats_001 start";
295 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
296 BundleStats bundleStats;
297 uint32_t statFlag = 0x01;
298 auto ret = storageManagerProviderTest_->GetCurrentBundleStats(bundleStats, statFlag);
299 EXPECT_NE(ret, E_OK);
300 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetCurrentBundleStats_001 end";
301 }
302
303 /**
304 * @tc.name: StorageManagerProviderTest_NotifyVolumeCreated_001
305 * @tc.desc: Verify the NotifyVolumeCreated function.
306 * @tc.type: FUNC
307 * @tc.require: AR000H09L6
308 */
309 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_NotifyVolumeCreated_001, TestSize.Level1)
310 {
311 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyVolumeCreated_001 start";
312 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
313 VolumeCore volumeCore;
314 auto ret = storageManagerProviderTest_->NotifyVolumeCreated(volumeCore);
315 EXPECT_EQ(ret, E_PERMISSION_DENIED);
316 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyVolumeCreated_001 end";
317 }
318
319 /**
320 * @tc.name: StorageManagerProviderTest_NotifyVolumeMounted_001
321 * @tc.desc: Verify the NotifyVolumeMounted function.
322 * @tc.type: FUNC
323 * @tc.require: AR000H09L6
324 */
325 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_NotifyVolumeMounted_001, TestSize.Level1)
326 {
327 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyVolumeMounted_001 start";
328 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
329 std::string volumeId = "testVolumeId";
330 std::string fsTypeStr = "testfsTypeStr";
331 std::string fsUuid = "testFsUuid";
332 std::string path = "/mnt/testVolume";
333 std::string description = "Test Volume";
334 auto ret = storageManagerProviderTest_->NotifyVolumeMounted(volumeId, fsTypeStr, fsUuid, path, description);
335 EXPECT_EQ(ret, E_PERMISSION_DENIED);
336 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyVolumeMounted_001 end";
337 }
338
339 /**
340 * @tc.name: StorageManagerProviderTest_NotifyVolumeStateChanged_001
341 * @tc.desc: Verify the NotifyVolumeStateChanged function.
342 * @tc.type: FUNC
343 * @tc.require: AR000H09L6
344 */
345 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_NotifyVolumeStateChanged_001, TestSize.Level1)
346 {
347 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyVolumeStateChanged_001 start";
348 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
349 std::string volumeId = "testVolumeId";
350 uint32_t state = MOUNTED;
351 auto ret = storageManagerProviderTest_->NotifyVolumeStateChanged(volumeId, state);
352 EXPECT_EQ(ret, E_PERMISSION_DENIED);
353 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyVolumeStateChanged_001 end";
354 }
355
356 /**
357 * @tc.name: StorageManagerProviderTest_Mount_001
358 * @tc.desc: Verify the Mount function.
359 * @tc.type: FUNC
360 * @tc.require: AR000H09L6
361 */
362 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_Mount_001, TestSize.Level1)
363 {
364 GTEST_LOG_(INFO) << "StorageManagerProviderTest_Mount_001 start";
365 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
366 std::string volumeId = "testVolumeId";
367 auto ret = storageManagerProviderTest_->Mount(volumeId);
368 EXPECT_EQ(ret, E_PERMISSION_DENIED);
369 GTEST_LOG_(INFO) << "StorageManagerProviderTest_Mount_001 end";
370 }
371
372 /**
373 * @tc.name: StorageManagerProviderTest_Unmount_001
374 * @tc.desc: Verify the Unmount function.
375 * @tc.type: FUNC
376 * @tc.require: AR000H09L6
377 */
378 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_Unmount_001, TestSize.Level1)
379 {
380 GTEST_LOG_(INFO) << "StorageManagerProviderTest_Unmount_001 start";
381 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
382 std::string volumeId = "testVolumeId";
383 auto ret = storageManagerProviderTest_->Unmount(volumeId);
384 EXPECT_EQ(ret, E_PERMISSION_DENIED);
385 GTEST_LOG_(INFO) << "StorageManagerProviderTest_Unmount_001 end";
386 }
387
388 /**
389 * @tc.name: StorageManagerProviderTest_GetAllVolumes_001
390 * @tc.desc: Verify the GetAllVolumes function.
391 * @tc.type: FUNC
392 * @tc.require: AR000H09L6
393 */
394 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetAllVolumes_001, TestSize.Level1)
395 {
396 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetAllVolumes_001 start";
397 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
398 std::vector<VolumeExternal> volumes;
399 auto ret = storageManagerProviderTest_->GetAllVolumes(volumes);
400 EXPECT_EQ(ret, E_PERMISSION_DENIED);
401 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetAllVolumes_001 end";
402 }
403
404 /**
405 * @tc.name: StorageManagerProviderTest_NotifyDiskCreated_001
406 * @tc.desc: Verify the NotifyDiskCreated function.
407 * @tc.type: FUNC
408 * @tc.require: AR000H09L6
409 */
410 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_NotifyDiskCreated_001, TestSize.Level1)
411 {
412 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyDiskCreated_001 start";
413 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
414 Disk disk;
415 auto ret = storageManagerProviderTest_->NotifyDiskCreated(disk);
416 EXPECT_EQ(ret, E_PERMISSION_DENIED);
417 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyDiskCreated_001 end";
418 }
419
420 /**
421 * @tc.name: StorageManagerProviderTest_NotifyDiskDestroyed_001
422 * @tc.desc: Verify the NotifyDiskDestroyed function.
423 * @tc.type: FUNC
424 * @tc.require: AR000H09L6
425 */
426 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_NotifyDiskDestroyed_001, TestSize.Level1)
427 {
428 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyDiskDestroyed_001 start";
429 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
430 std::string diskId = "testDiskId";
431 auto ret = storageManagerProviderTest_->NotifyDiskDestroyed(diskId);
432 EXPECT_EQ(ret, E_PERMISSION_DENIED);
433 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyDiskDestroyed_001 end";
434 }
435
436 /**
437 * @tc.name: StorageManagerProviderTest_Partition_001
438 * @tc.desc: Verify the Partition function.
439 * @tc.type: FUNC
440 * @tc.require: AR000H09L6
441 */
442 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_Partition_001, TestSize.Level1)
443 {
444 GTEST_LOG_(INFO) << "StorageManagerProviderTest_Partition_001 start";
445 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
446 std::string diskId = "testDiskId";
447 int32_t type = 1;
448 auto ret = storageManagerProviderTest_->Partition(diskId, type);
449 EXPECT_EQ(ret, E_PERMISSION_DENIED);
450 GTEST_LOG_(INFO) << "StorageManagerProviderTest_Partition_001 end";
451 }
452
453 /**
454 * @tc.name: StorageManagerProviderTest_GetAllDisks_001
455 * @tc.desc: Verify the GetAllDisks function.
456 * @tc.type: FUNC
457 * @tc.require: AR000H09L6
458 */
459 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetAllDisks_001, TestSize.Level1)
460 {
461 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetAllDisks_001 start";
462 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
463 std::vector<Disk> disks;
464 auto ret = storageManagerProviderTest_->GetAllDisks(disks);
465 EXPECT_EQ(ret, E_PERMISSION_DENIED);
466 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetAllDisks_001 end";
467 }
468
469 /**
470 * @tc.name: StorageManagerProviderTest_GetVolumeByUuid_001
471 * @tc.desc: Verify the GetVolumeByUuid function.
472 * @tc.type: FUNC
473 * @tc.require: AR000H09L6
474 */
475 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetVolumeByUuid_001, TestSize.Level1)
476 {
477 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetVolumeByUuid_001 start";
478 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
479 std::string fsUuid = "testUuid";
480 VolumeExternal volume;
481 auto ret = storageManagerProviderTest_->GetVolumeByUuid(fsUuid, volume);
482 EXPECT_EQ(ret, E_PERMISSION_DENIED);
483 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetVolumeByUuid_001 end";
484 }
485
486 /**
487 * @tc.name: StorageManagerProviderTest_GetVolumeById_001
488 * @tc.desc: Verify the GetVolumeById function.
489 * @tc.type: FUNC
490 * @tc.require: AR000H09L6
491 */
492 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetVolumeById_001, TestSize.Level1)
493 {
494 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetVolumeById_001 start";
495 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
496 std::string volumeId = "testVolumeId";
497 VolumeExternal volume;
498 auto ret = storageManagerProviderTest_->GetVolumeById(volumeId, volume);
499 EXPECT_EQ(ret, E_PERMISSION_DENIED);
500 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetVolumeById_001 end";
501 }
502
503 /**
504 * @tc.name: StorageManagerProviderTest_SetVolumeDescription_001
505 * @tc.desc: Verify the SetVolumeDescription function.
506 * @tc.type: FUNC
507 * @tc.require: AR000H09L6
508 */
509 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_SetVolumeDescription_001, TestSize.Level1)
510 {
511 GTEST_LOG_(INFO) << "StorageManagerProviderTest_SetVolumeDescription_001 start";
512 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
513 std::string fsUuid = "testUuid";
514 std::string description = "Test Volume Description";
515 auto ret = storageManagerProviderTest_->SetVolumeDescription(fsUuid, description);
516 EXPECT_EQ(ret, E_PERMISSION_DENIED);
517 GTEST_LOG_(INFO) << "StorageManagerProviderTest_SetVolumeDescription_001 end";
518 }
519
520 /**
521 * @tc.name: StorageManagerProviderTest_Format_001
522 * @tc.desc: Verify the SetVolumeDescription function.
523 * @tc.type: FUNC
524 * @tc.require: AR000H09L6
525 */
526 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_Format_001, TestSize.Level1)
527 {
528 GTEST_LOG_(INFO) << "StorageManagerProviderTest_Format_001 start";
529 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
530 std::string volumeId = "testVolumeId";
531 std::string fsType = "ext4";
532 auto ret = storageManagerProviderTest_->Format(volumeId, fsType);
533 EXPECT_EQ(ret, E_PERMISSION_DENIED);
534 GTEST_LOG_(INFO) << "StorageManagerProviderTest_Format_001 end";
535 }
536
537 /**
538 * @tc.name: StorageManagerProviderTest_GetDiskById_001
539 * @tc.desc: Verify the GetDiskById function.
540 * @tc.type: FUNC
541 * @tc.require: AR000H09L6
542 */
543 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetDiskById_001, TestSize.Level1)
544 {
545 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetDiskById_001 start";
546 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
547 std::string diskId = "testDiskId";
548 Disk disk;
549 auto ret = storageManagerProviderTest_->GetDiskById(diskId, disk);
550 EXPECT_EQ(ret, E_PERMISSION_DENIED);
551 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetDiskById_001 end";
552 }
553
554 /**
555 * @tc.name: StorageManagerProviderTest_GenerateUserKeys_001
556 * @tc.desc: Verify the GenerateUserKeys function.
557 * @tc.type: FUNC
558 * @tc.require: AR000H09L6
559 */
560 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GenerateUserKeys_001, TestSize.Level1)
561 {
562 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GenerateUserKeys_001 start";
563 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
564 uint32_t userId = 1001;
565 uint32_t flags = 0x01;
566 auto ret = storageManagerProviderTest_->GenerateUserKeys(userId, flags);
567 EXPECT_EQ(ret, E_PERMISSION_DENIED);
568 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GenerateUserKeys_001 end";
569 }
570
571 /**
572 * @tc.name: StorageManagerProviderTest_QueryUsbIsInUse_001
573 * @tc.desc: Verify the QueryUsbIsInUse function.
574 * @tc.type: FUNC
575 * @tc.require: AR000H09L6
576 */
577 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_QueryUsbIsInUse_001, TestSize.Level1)
578 {
579 GTEST_LOG_(INFO) << "StorageManagerProviderTest_QueryUsbIsInUse_001 start";
580 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
581 std::string diskPath = "/dev/sda1";
582 bool isInUse = false;
583 auto ret = storageManagerProviderTest_->QueryUsbIsInUse(diskPath, isInUse);
584 EXPECT_EQ(ret, E_PERMISSION_DENIED);
585 GTEST_LOG_(INFO) << "StorageManagerProviderTest_QueryUsbIsInUse_001 end";
586 }
587
588 /**
589 * @tc.name: StorageManagerProviderTest_DeleteUserKeys_001
590 * @tc.desc: Verify the DeleteUserKeys function.
591 * @tc.type: FUNC
592 * @tc.require: AR000H09L6
593 */
594 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_DeleteUserKeys_001, TestSize.Level1)
595 {
596 GTEST_LOG_(INFO) << "StorageManagerProviderTest_DeleteUserKeys_001 start";
597 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
598 uint32_t userId = 1001;
599 auto ret = storageManagerProviderTest_->DeleteUserKeys(userId);
600 EXPECT_EQ(ret, E_PERMISSION_DENIED);
601 GTEST_LOG_(INFO) << "StorageManagerProviderTest_DeleteUserKeys_001 end";
602 }
603
604 /**
605 * @tc.name: StorageManagerProviderTest_UpdateUserAuth_001
606 * @tc.desc: Verify the UpdateUserAuth function.
607 * @tc.type: FUNC
608 * @tc.require: AR000H09L6
609 */
610 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_UpdateUserAuth_001, TestSize.Level1)
611 {
612 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UpdateUserAuth_001 start";
613 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
614 uint32_t userId = 1001;
615 uint64_t secureUid = 123456789;
616 std::vector<uint8_t> token = {1, 2, 3, 4};
617 std::vector<uint8_t> oldSecret = {5, 6, 7, 8};
618 std::vector<uint8_t> newSecret = {9, 10, 11, 12};
619 auto ret = storageManagerProviderTest_->UpdateUserAuth(userId, secureUid, token, oldSecret, newSecret);
620 EXPECT_EQ(ret, E_PERMISSION_DENIED);
621 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UpdateUserAuth_001 end";
622 }
623
624 /**
625 * @tc.name: StorageManagerProviderTest_UpdateUseAuthWithRecoveryKey_001
626 * @tc.desc: Verify the UpdateUseAuthWithRecoveryKey function.
627 * @tc.type: FUNC
628 * @tc.require: AR000H09L6
629 */
630 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_UpdateUseAuthWithRecoveryKey_001, TestSize.Level1)
631 {
632 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UpdateUseAuthWithRecoveryKey_001 start";
633 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
634 std::vector<uint8_t> authToken = {1, 2, 3, 4};
635 std::vector<uint8_t> newSecret = {5, 6, 7, 8};
636 uint64_t secureUid = 123456789;
637 uint32_t userId = 1001;
638 std::vector<std::vector<uint8_t>> plainText = {{9, 10}, {11, 12}};
639 auto ret =
640 storageManagerProviderTest_->UpdateUseAuthWithRecoveryKey(authToken, newSecret, secureUid, userId, plainText);
641 EXPECT_EQ(ret, E_PERMISSION_DENIED);
642 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UpdateUseAuthWithRecoveryKey_001 end";
643 }
644
645 /**
646 * @tc.name: StorageManagerProviderTest_ActiveUserKey_001
647 * @tc.desc: Verify the ActiveUserKey function.
648 * @tc.type: FUNC
649 * @tc.require: AR000H09L6
650 */
651 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_ActiveUserKey_001, TestSize.Level1)
652 {
653 GTEST_LOG_(INFO) << "StorageManagerProviderTest_ActiveUserKey_001 start";
654 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
655 uint32_t userId = 1001;
656 std::vector<uint8_t> token = {1, 2, 3, 4};
657 std::vector<uint8_t> secret = {5, 6, 7, 8};
658 auto ret = storageManagerProviderTest_->ActiveUserKey(userId, token, secret);
659 EXPECT_EQ(ret, E_PERMISSION_DENIED);
660 GTEST_LOG_(INFO) << "StorageManagerProviderTest_ActiveUserKey_001 end";
661 }
662
663 /**
664 * @tc.name: StorageManagerProviderTest_InactiveUserKey_001
665 * @tc.desc: Verify the InactiveUserKey function.
666 * @tc.type: FUNC
667 * @tc.require: AR000H09L6
668 */
669 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_InactiveUserKey_001, TestSize.Level1)
670 {
671 GTEST_LOG_(INFO) << "StorageManagerProviderTest_InactiveUserKey_001 start";
672 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
673 uint32_t userId = 1001;
674 auto ret = storageManagerProviderTest_->InactiveUserKey(userId);
675 EXPECT_EQ(ret, E_PERMISSION_DENIED);
676 GTEST_LOG_(INFO) << "StorageManagerProviderTest_InactiveUserKey_001 end";
677 }
678
679 /**
680 * @tc.name: StorageManagerProviderTest_LockUserScreen_001
681 * @tc.desc: Verify the LockUserScreen function.
682 * @tc.type: FUNC
683 * @tc.require: AR000H09L6
684 */
685 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_LockUserScreen_001, TestSize.Level1)
686 {
687 GTEST_LOG_(INFO) << "StorageManagerProviderTest_LockUserScreen_001 start";
688 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
689 uint32_t userId = 1001;
690 auto ret = storageManagerProviderTest_->LockUserScreen(userId);
691 EXPECT_NE(ret, E_OK);
692 GTEST_LOG_(INFO) << "StorageManagerProviderTest_LockUserScreen_001 end";
693 }
694
695 /**
696 * @tc.name: StorageManagerProviderTest_GetFileEncryptStatus_001
697 * @tc.desc: Verify the GetFileEncryptStatus function.
698 * @tc.type: FUNC
699 * @tc.require: AR000H09L6
700 */
701 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetFileEncryptStatus_001, TestSize.Level1)
702 {
703 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetFileEncryptStatus_001 start";
704 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
705 uint32_t userId = 1001;
706 bool isEncrypted = false;
707 bool needCheckDirMount = true;
708 auto ret = storageManagerProviderTest_->GetFileEncryptStatus(userId, isEncrypted, needCheckDirMount);
709 EXPECT_EQ(ret, E_PERMISSION_DENIED);
710 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetFileEncryptStatus_001 end";
711 }
712
713 /**
714 * @tc.name: StorageManagerProviderTest_GetUserNeedActiveStatus_001
715 * @tc.desc: Verify the GetUserNeedActiveStatus function.
716 * @tc.type: FUNC
717 * @tc.require: AR000H09L6
718 */
719 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetUserNeedActiveStatus_001, TestSize.Level1)
720 {
721 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetUserNeedActiveStatus_001 start";
722 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
723 uint32_t userId = 1001;
724 bool needActive = false;
725 auto ret = storageManagerProviderTest_->GetUserNeedActiveStatus(userId, needActive);
726 EXPECT_EQ(ret, E_PERMISSION_DENIED);
727 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetUserNeedActiveStatus_001 end";
728 }
729
730 /**
731 * @tc.name: StorageManagerProviderTest_UnlockUserScreen_001
732 * @tc.desc: Verify the UnlockUserScreen function.
733 * @tc.type: FUNC
734 * @tc.require: AR000H09L6
735 */
736 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_UnlockUserScreen_001, TestSize.Level1)
737 {
738 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UnlockUserScreen_001 start";
739 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
740 uint32_t userId = 1001;
741 std::vector<uint8_t> token = {0x01, 0x02, 0x03};
742 std::vector<uint8_t> secret = {0x04, 0x05, 0x06};
743 auto ret = storageManagerProviderTest_->UnlockUserScreen(userId, token, secret);
744 EXPECT_EQ(ret, E_PERMISSION_DENIED);
745 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UnlockUserScreen_001 end";
746 }
747
748 /**
749 * @tc.name: StorageManagerProviderTest_GetLockScreenStatus_001
750 * @tc.desc: Verify the GetLockScreenStatus function.
751 * @tc.type: FUNC
752 * @tc.require: AR000H09L6
753 */
754 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetLockScreenStatus_001, TestSize.Level1)
755 {
756 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetLockScreenStatus_001 start";
757 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
758 uint32_t userId = 1001;
759 bool needActive = false;
760 auto ret = storageManagerProviderTest_->GetLockScreenStatus(userId, needActive);
761 EXPECT_EQ(ret, E_PERMISSION_DENIED);
762 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetLockScreenStatus_001 end";
763 }
764
765 /**
766 * @tc.name: StorageManagerProviderTest_GenerateAppkey_001
767 * @tc.desc: Verify the GenerateAppkey function.
768 * @tc.type: FUNC
769 * @tc.require: AR000H09L6
770 */
771 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GenerateAppkey_001, TestSize.Level1)
772 {
773 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GenerateAppkey_001 start";
774 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
775 uint32_t hashId = 12345;
776 uint32_t userId = 1001;
777 std::string keyId;
778 bool needReSet = false;
779 auto ret = storageManagerProviderTest_->GenerateAppkey(hashId, userId, keyId, needReSet);
780 EXPECT_EQ(ret, E_PERMISSION_DENIED);
781 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GenerateAppkey_001 end";
782 }
783
784 /**
785 * @tc.name: StorageManagerProviderTest_DeleteAppkey_001
786 * @tc.desc: Verify the DeleteAppkey function.
787 * @tc.type: FUNC
788 * @tc.require: AR000H09L6
789 */
790 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_DeleteAppkey_001, TestSize.Level1)
791 {
792 GTEST_LOG_(INFO) << "StorageManagerProviderTest_DeleteAppkey_001 start";
793 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
794 std::string keyId = "testKeyId";
795 auto ret = storageManagerProviderTest_->DeleteAppkey(keyId);
796 EXPECT_EQ(ret, E_PERMISSION_DENIED);
797 GTEST_LOG_(INFO) << "StorageManagerProviderTest_DeleteAppkey_001 end";
798 }
799
800 /**
801 * @tc.name: StorageManagerProviderTest_CreateRecoverKey_001
802 * @tc.desc: Verify the CreateRecoverKey function.
803 * @tc.type: FUNC
804 * @tc.require: AR000H09L6
805 */
806 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_CreateRecoverKey_001, TestSize.Level1)
807 {
808 GTEST_LOG_(INFO) << "StorageManagerProviderTest_CreateRecoverKey_001 start";
809 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
810 uint32_t userId = 1001;
811 uint32_t userType = 1;
812 std::vector<uint8_t> token = {0x01, 0x02, 0x03};
813 std::vector<uint8_t> secret = {0xAA, 0xBB, 0xCC};
814 auto ret = storageManagerProviderTest_->CreateRecoverKey(userId, userType, token, secret);
815 EXPECT_EQ(ret, E_PERMISSION_DENIED);
816 GTEST_LOG_(INFO) << "StorageManagerProviderTest_CreateRecoverKey_001 end";
817 }
818
819 /**
820 * @tc.name: StorageManagerProviderTest_SetRecoverKey_001
821 * @tc.desc: Verify the SetRecoverKey function.
822 * @tc.type: FUNC
823 * @tc.require: AR000H09L6
824 */
825 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_SetRecoverKey_001, TestSize.Level1)
826 {
827 GTEST_LOG_(INFO) << "StorageManagerProviderTest_SetRecoverKey_001 start";
828 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
829 std::vector<uint8_t> key = {0x01, 0x02, 0x03};
830 auto ret = storageManagerProviderTest_->SetRecoverKey(key);
831 EXPECT_EQ(ret, E_PERMISSION_DENIED);
832 GTEST_LOG_(INFO) << "StorageManagerProviderTest_SetRecoverKey_001 end";
833 }
834
835 /**
836 * @tc.name: StorageManagerProviderTest_UpdateKeyContext_001
837 * @tc.desc: Verify the UpdateKeyContext function.
838 * @tc.type: FUNC
839 * @tc.require: AR000H09L6
840 */
841 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_UpdateKeyContext_001, TestSize.Level1)
842 {
843 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UpdateKeyContext_001 start";
844 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
845 uint32_t userId = 1001;
846 bool needRemoveTmpKey = true;
847 auto ret = storageManagerProviderTest_->UpdateKeyContext(userId, needRemoveTmpKey);
848 EXPECT_EQ(ret, E_PERMISSION_DENIED);
849 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UpdateKeyContext_001 end";
850 }
851
852 /**
853 * @tc.name: StorageManagerProviderTest_CreateShareFile_001
854 * @tc.desc: Verify the CreateShareFile function.
855 * @tc.type: FUNC
856 * @tc.require: AR000H09L6
857 */
858 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_CreateShareFile_001, TestSize.Level1)
859 {
860 GTEST_LOG_(INFO) << "StorageManagerProviderTest_CreateShareFile_001 start";
861 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
862 std::string uriStr = "file1";
863 std::vector<std::string> uriStrVec = {uriStr};
864 StorageFileRawData rawData;
865 StringVecToRawData(uriStrVec, rawData);
866 StorageFileRawData fileRawData;
867 fileRawData.size = rawData.size;
868 fileRawData.RawDataCpy(rawData.data);
869 uint32_t tokenId = 12345;
870 uint32_t flag = 1;
871 std::vector<int32_t> funcResult;
872 auto ret = storageManagerProviderTest_->CreateShareFile(fileRawData, tokenId, flag, funcResult);
873 EXPECT_EQ(ret, E_PERMISSION_DENIED);
874 GTEST_LOG_(INFO) << "StorageManagerProviderTest_CreateShareFile_001 end";
875 }
876
877 /**
878 * @tc.name: StorageManagerProviderTest_DeleteShareFile_001
879 * @tc.desc: Verify the DeleteShareFile function.
880 * @tc.type: FUNC
881 * @tc.require: AR000H09L6
882 */
883 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_DeleteShareFile_001, TestSize.Level1)
884 {
885 GTEST_LOG_(INFO) << "StorageManagerProviderTest_DeleteShareFile_001 start";
886 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
887 std::string uriStr = "file1";
888 std::vector<std::string> uriStrVec = {uriStr};
889 StorageFileRawData rawData;
890 StringVecToRawData(uriStrVec, rawData);
891 StorageFileRawData fileRawData;
892 fileRawData.size = rawData.size;
893 fileRawData.RawDataCpy(rawData.data);
894 uint32_t tokenId = 12345;
895 auto ret = storageManagerProviderTest_->DeleteShareFile(tokenId, fileRawData);
896 EXPECT_EQ(ret, E_PERMISSION_DENIED);
897 GTEST_LOG_(INFO) << "StorageManagerProviderTest_DeleteShareFile_001 end";
898 }
899
900 /**
901 * @tc.name: StorageManagerProviderTest_SetBundleQuota_001
902 * @tc.desc: Verify the SetBundleQuota function.
903 * @tc.type: FUNC
904 * @tc.require: AR000H09L6
905 */
906 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_SetBundleQuota_001, TestSize.Level1)
907 {
908 GTEST_LOG_(INFO) << "StorageManagerProviderTest_SetBundleQuota_001 start";
909 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
910 std::string bundleName = "com.example.app";
911 int32_t uid = 1001;
912 std::string bundleDataDirPath = "/data/app/example";
913 int32_t limitSizeMb = 1024;
914 auto ret = storageManagerProviderTest_->SetBundleQuota(bundleName, uid, bundleDataDirPath, limitSizeMb);
915 EXPECT_EQ(ret, E_PERMISSION_DENIED);
916 GTEST_LOG_(INFO) << "StorageManagerProviderTest_SetBundleQuota_001 end";
917 }
918
919 /**
920 * @tc.name: StorageManagerProviderTest_GetUserStorageStatsByType_001
921 * @tc.desc: Verify the GetUserStorageStatsByType function.
922 * @tc.type: FUNC
923 * @tc.require: AR000H09L6
924 */
925 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_GetUserStorageStatsByType_001, TestSize.Level1)
926 {
927 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetUserStorageStatsByType_001 start";
928 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
929 int32_t userId = 1001;
930 StorageStats storageStats;
931 std::string type = "exampleType";
932 auto ret = storageManagerProviderTest_->GetUserStorageStatsByType(userId, storageStats, type);
933 EXPECT_EQ(ret, E_PERMISSION_DENIED);
934 GTEST_LOG_(INFO) << "StorageManagerProviderTest_GetUserStorageStatsByType_001 end";
935 }
936
937 /**
938 * @tc.name: StorageManagerProviderTest_UpdateMemoryPara_001
939 * @tc.desc: Verify the UpdateMemoryPara function.
940 * @tc.type: FUNC
941 * @tc.require: AR000H09L6
942 */
943 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_UpdateMemoryPara_001, TestSize.Level1)
944 {
945 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UpdateMemoryPara_001 start";
946 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
947 int32_t size = 1024;
948 int32_t oldSize = 0;
949 auto ret = storageManagerProviderTest_->UpdateMemoryPara(size, oldSize);
950 EXPECT_EQ(ret, E_PERMISSION_DENIED);
951 EXPECT_EQ(oldSize, 0);
952 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UpdateMemoryPara_001 end";
953 }
954
955 /**
956 * @tc.name: StorageManagerProviderTest_MountDfsDocs_001
957 * @tc.desc: Verify the MountDfsDocs function.
958 * @tc.type: FUNC
959 * @tc.require: AR000H09L6
960 */
961 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_MountDfsDocs_001, TestSize.Level1)
962 {
963 GTEST_LOG_(INFO) << "StorageManagerProviderTest_MountDfsDocs_001 start";
964 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
965 int32_t userId = 1001;
966 std::string relativePath = "/mnt/dfs/network123/device123/relative/path";
967 std::string networkId = "network123";
968 std::string deviceId = "device123";
969 auto ret = storageManagerProviderTest_->MountDfsDocs(userId, relativePath, networkId, deviceId);
970 EXPECT_EQ(ret, E_PERMISSION_DENIED);
971 GTEST_LOG_(INFO) << "StorageManagerProviderTest_MountDfsDocs_001 end";
972 }
973
974 /**
975 * @tc.name: StorageManagerProviderTest_UMountDfsDocs_001
976 * @tc.desc: Verify the UMountDfsDocs function.
977 * @tc.type: FUNC
978 * @tc.require: AR000H09L6
979 */
980 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_UMountDfsDocs_001, TestSize.Level1)
981 {
982 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UMountDfsDocs_001 start";
983 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
984 int32_t userId = 1001;
985 std::string relativePath = "/mnt/dfs/network123/device123/relative/path";
986 std::string networkId = "network123";
987 std::string deviceId = "device123";
988 auto ret = storageManagerProviderTest_->UMountDfsDocs(userId, relativePath, networkId, deviceId);
989 EXPECT_EQ(ret, E_PERMISSION_DENIED);
990 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UMountDfsDocs_001 end";
991 }
992
993 /**
994 * @tc.name: StorageManagerProviderTest_NotifyMtpMounted_001
995 * @tc.desc: Verify the NotifyMtpMounted function.
996 * @tc.type: FUNC
997 * @tc.require: AR000H09L6
998 */
999 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_NotifyMtpMounted_001, TestSize.Level1)
1000 {
1001 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyMtpMounted_001 start";
1002 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1003 std::string id = "mtpId";
1004 std::string path = "/mnt/mtp/device/storage/usb";
1005 std::string desc = "MTP Device";
1006 std::string uuid = "1234-5678";
1007 auto ret = storageManagerProviderTest_->NotifyMtpMounted(id, path, desc, uuid);
1008 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1009 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyMtpMounted_001 end";
1010 }
1011
1012 /**
1013 * @tc.name: StorageManagerProviderTest_NotifyMtpUnmounted_001
1014 * @tc.desc: Verify the NotifyMtpUnmounted function.
1015 * @tc.type: FUNC
1016 * @tc.require: AR000H09L6
1017 */
1018 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_NotifyMtpUnmounted_001, TestSize.Level1)
1019 {
1020 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyMtpUnmounted_001 start";
1021 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1022 std::string id = "mtpId";
1023 std::string path = "/mnt/mtp/device/storage/usb";
1024 bool isBadRemove = false;
1025 auto ret = storageManagerProviderTest_->NotifyMtpUnmounted(id, path, isBadRemove);
1026 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1027 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyMtpUnmounted_001 end";
1028 }
1029
1030 /**
1031 * @tc.name: StorageManagerProviderTest_MountMediaFuse_001
1032 * @tc.desc: Verify the MountMediaFuse function.
1033 * @tc.type: FUNC
1034 * @tc.require: AR000H09L6
1035 */
1036 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_MountMediaFuse_001, TestSize.Level1)
1037 {
1038 GTEST_LOG_(INFO) << "StorageManagerProviderTest_MountMediaFuse_001 start";
1039 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1040 int32_t userId = 1001;
1041 int32_t devFd = -1;
1042 auto ret = storageManagerProviderTest_->MountMediaFuse(userId, devFd);
1043 EXPECT_NE(ret, E_OK);
1044 GTEST_LOG_(INFO) << "StorageManagerProviderTest_MountMediaFuse_001 end";
1045 }
1046
1047 /**
1048 * @tc.name: StorageManagerProviderTest_UMountMediaFuse_001
1049 * @tc.desc: Verify the UMountMediaFuse function.
1050 * @tc.type: FUNC
1051 * @tc.require: AR000H09L6
1052 */
1053 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_UMountMediaFuse_001, TestSize.Level1)
1054 {
1055 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UMountMediaFuse_001 start";
1056 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1057 int32_t userId = 1001;
1058 auto ret = storageManagerProviderTest_->UMountMediaFuse(userId);
1059 EXPECT_NE(ret, E_OK);
1060 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UMountMediaFuse_001 end";
1061 }
1062
1063 /**
1064 * @tc.name: StorageManagerProviderTest_MountFileMgrFuse_001
1065 * @tc.desc: Verify the MountFileMgrFuse function.
1066 * @tc.type: FUNC
1067 * @tc.require: AR000H09L6
1068 */
1069 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_MountFileMgrFuse_001, TestSize.Level1)
1070 {
1071 GTEST_LOG_(INFO) << "StorageManagerProviderTest_MountFileMgrFuse_001 start";
1072 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1073 int32_t userId = 1001;
1074 std::string path = "/mnt/mtp/device/storage/usb";
1075 int32_t fuseFd = -1;
1076 auto ret = storageManagerProviderTest_->MountFileMgrFuse(userId, path, fuseFd);
1077 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1078 EXPECT_EQ(fuseFd, -1);
1079 GTEST_LOG_(INFO) << "StorageManagerProviderTest_MountFileMgrFuse_001 end";
1080 }
1081
1082 /**
1083 * @tc.name: StorageManagerProviderTest_UMountFileMgrFuse_001
1084 * @tc.desc: Verify the UMountFileMgrFuse function.
1085 * @tc.type: FUNC
1086 * @tc.require: AR000H09L6
1087 */
1088 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_UMountFileMgrFuse_001, TestSize.Level1)
1089 {
1090 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UMountFileMgrFuse_001 start";
1091 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1092 int32_t userId = 1001;
1093 std::string path = "/mnt/mtp/device/storage/usb";
1094 auto ret = storageManagerProviderTest_->UMountFileMgrFuse(userId, path);
1095 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1096 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UMountFileMgrFuse_001 end";
1097 }
1098
1099 /**
1100 * @tc.name: StorageManagerProviderTest_IsFileOccupied_001
1101 * @tc.desc: Verify the IsFileOccupied function.
1102 * @tc.type: FUNC
1103 * @tc.require: AR000H09L6
1104 */
1105 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_IsFileOccupied_001, TestSize.Level1)
1106 {
1107 GTEST_LOG_(INFO) << "StorageManagerProviderTest_IsFileOccupied_001 start";
1108 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1109 std::string path = "/test/file";
1110 std::vector<std::string> inputList = {"file1", "file2"};
1111 std::vector<std::string> outputList;
1112 bool isOccupy = false;
1113 auto ret = storageManagerProviderTest_->IsFileOccupied(path, inputList, outputList, isOccupy);
1114 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1115 GTEST_LOG_(INFO) << "StorageManagerProviderTest_IsFileOccupied_001 end";
1116 }
1117
1118 /**
1119 * @tc.name: StorageManagerProviderTest_ResetSecretWithRecoveryKey_001
1120 * @tc.desc: Verify the ResetSecretWithRecoveryKey function.
1121 * @tc.type: FUNC
1122 * @tc.require: AR000H09L6
1123 */
1124 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_ResetSecretWithRecoveryKey_001, TestSize.Level1)
1125 {
1126 GTEST_LOG_(INFO) << "StorageManagerProviderTest_ResetSecretWithRecoveryKey_001 start";
1127 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1128 uint32_t userId = 1001;
1129 uint32_t rkType = 1;
1130 std::vector<uint8_t> key = {0x01, 0x02, 0x03};
1131 auto ret = storageManagerProviderTest_->ResetSecretWithRecoveryKey(userId, rkType, key);
1132 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1133 GTEST_LOG_(INFO) << "StorageManagerProviderTest_ResetSecretWithRecoveryKey_001 end";
1134 }
1135
1136 /**
1137 * @tc.name: StorageManagerProviderTest_TryToFix_001
1138 * @tc.desc: Verify the ResetSecretWithRecoveryKey function.
1139 * @tc.type: FUNC
1140 * @tc.require: AR000H09L6
1141 */
1142 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_TryToFix_001, TestSize.Level1)
1143 {
1144 GTEST_LOG_(INFO) << "StorageManagerProviderTest_TryToFix_001 start";
1145 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1146 std::string volId = "vol-8-1";
1147 auto ret = storageManagerProviderTest_->TryToFix(volId);
1148 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1149 GTEST_LOG_(INFO) << "StorageManagerProviderTest_TryToFix_001 end";
1150 }
1151
1152 /**
1153 * @tc.name: StorageManagerProviderTest_NotifyVolumeDamaged_001
1154 * @tc.desc: Verify the NotifyVolumeDamaged function.
1155 * @tc.type: FUNC
1156 * @tc.require: AR000H09L6
1157 */
1158 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_NotifyVolumeDamaged_001, TestSize.Level1)
1159 {
1160 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyVolumeDamaged_001 start";
1161 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1162 std::string volId = "vol-8-1";
1163 std::string fsTypeStr = "ntfs";
1164 std::string uuid = "uuid-1";
1165 std::string path = "/";
1166 std::string description = "My Disk";
1167 auto ret = storageManagerProviderTest_->NotifyVolumeDamaged(volId, fsTypeStr, uuid, path, description);
1168 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1169 GTEST_LOG_(INFO) << "StorageManagerProviderTest_NotifyVolumeDamaged_001 end";
1170 }
1171
1172 /**
1173 * @tc.name: StorageManagerProviderTest_MountDisShareFile_001
1174 * @tc.desc: Verify the MountDisShareFile function.
1175 * @tc.type: FUNC
1176 * @tc.require: AR000H09L6
1177 */
1178 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_MountDisShareFile_001, TestSize.Level1)
1179 {
1180 GTEST_LOG_(INFO) << "StorageManagerProviderTest_MountDisShareFile_001 start";
1181 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1182 int32_t userId = 100;
1183 std::map<std::string, std::string> shareFiles = {{{"/data/sharefile1", "/data/sharefile2"}}};
1184 auto ret = storageManagerProviderTest_->MountDisShareFile(userId, shareFiles);
1185 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1186 GTEST_LOG_(INFO) << "StorageManagerProviderTest_MountDisShareFile_001 end";
1187 }
1188
1189 /**
1190 * @tc.name: StorageManagerProviderTest_UMountDisShareFile_001
1191 * @tc.desc: Verify the UMountDisShareFile function.
1192 * @tc.type: FUNC
1193 * @tc.require: AR000H09L6
1194 */
1195 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_UMountDisShareFile_001, TestSize.Level1)
1196 {
1197 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UMountDisShareFile_001 start";
1198 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1199 int32_t userId = 100;
1200 std::string networkId = "sharefile1";
1201 auto ret = storageManagerProviderTest_->UMountDisShareFile(userId, networkId);
1202 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1203 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UMountDisShareFile_001 end";
1204 }
1205
1206 /**
1207 * @tc.name: StorageManagerProviderTest_InactiveUserPublicDirKey_001
1208 * @tc.desc: Verify the InactiveUserPublicDirKey function.
1209 * @tc.type: FUNC
1210 * @tc.require: AR20250418146433
1211 */
1212 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_InactiveUserPublicDirKey_001, TestSize.Level1)
1213 {
1214 GTEST_LOG_(INFO) << "StorageManagerProviderTest_InactiveUserPublicDirKey_001 start";
1215 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1216 uint32_t userId = 100;
1217 auto ret = storageManagerProviderTest_->InactiveUserPublicDirKey(userId);
1218 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1219 GTEST_LOG_(INFO) << "StorageManagerProviderTest_InactiveUserPublicDirKey_001 end";
1220 }
1221
1222 /**
1223 * @tc.name: StorageManagerProviderTest_RegisterUeceActivationCallback_001
1224 * @tc.desc: Verify the RegisterUeceActivationCallback function.
1225 * @tc.type: FUNC
1226 * @tc.require: AR20250418146433
1227 */
1228 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_RegisterUeceActivationCallback_001, TestSize.Level1)
1229 {
1230 GTEST_LOG_(INFO) << "StorageManagerProviderTest_RegisterUeceActivationCallback_001 start";
1231 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1232 sptr<IUeceActivationCallback> ueceCallback(new (std::nothrow) UeceActivationCallbackMock());
1233 EXPECT_NE(ueceCallback, nullptr);
1234 auto ret = storageManagerProviderTest_->RegisterUeceActivationCallback(ueceCallback);
1235 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1236 GTEST_LOG_(INFO) << "StorageManagerProviderTest_RegisterUeceActivationCallback_001 end";
1237 }
1238
1239 /**
1240 * @tc.name: StorageManagerProviderTest_UnregisterUeceActivationCallbackk_001
1241 * @tc.desc: Verify the UnregisterUeceActivationCallback function.
1242 * @tc.type: FUNC
1243 * @tc.require: AR20250418146433
1244 */
1245 HWTEST_F(StorageManagerProviderTest, StorageManagerProviderTest_UnregisterUeceActivationCallbackk_001, TestSize.Level1)
1246 {
1247 GTEST_LOG_(INFO) << "StorageManagerProviderTest_RegisterUeceActivationCallback_001 start";
1248 ASSERT_TRUE(storageManagerProviderTest_ != nullptr);
1249 auto ret = storageManagerProviderTest_->UnregisterUeceActivationCallback();
1250 EXPECT_EQ(ret, E_PERMISSION_DENIED);
1251 GTEST_LOG_(INFO) << "StorageManagerProviderTest_UnregisterUeceActivationCallbackk_001 end";
1252 }
1253 } // namespace StorageManager
1254 } // namespace OHOS