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