diff --git a/test/unittests/clouddisk_database/clouddisk_rdbstore_test.cpp b/test/unittests/clouddisk_database/clouddisk_rdbstore_test.cpp
index 5e3729f356df297e4facbf58e4b3c4d6ec7b2226..06936351d1470d7c762ed120353afaf76cdc13ad 100644
--- a/test/unittests/clouddisk_database/clouddisk_rdbstore_test.cpp
+++ b/test/unittests/clouddisk_database/clouddisk_rdbstore_test.cpp
@@ -4026,9 +4026,11 @@ HWTEST_F(CloudDiskRdbStoreTest, OnCreateTest2, TestSize.Level1)
 HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest1, TestSize.Level1)
 {
     RdbStoreMock store;
-    int32_t oldVersion = 13;
-    int32_t newVersion = 14;
+    RdbStoreMock* rdb = &store;
     CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 16;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
     int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
     EXPECT_EQ(ret, E_OK);
 }
@@ -4041,13 +4043,897 @@ HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest1, TestSize.Level1)
 HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest2, TestSize.Level1)
 {
     RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 16;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest3, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 15;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest4, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 15;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest5, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 14;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest6, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 14;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest7, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 13;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest8, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 13;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest9, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 12;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest10, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 12;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest11, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 11;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest12, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 11;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest13, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 10;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest14, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 10;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest15, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 9;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest16, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 9;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest17, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 8;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest18, TestSize.Level1)
+{
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
     int32_t oldVersion = 8;
-    int32_t newVersion = 14;
+    int32_t newVersion = 0;
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_OK));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest19, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
     CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 7;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
     int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
     EXPECT_EQ(ret, E_OK);
 }
 
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest20, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 7;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest21, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 6;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest22, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 6;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest23, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 5;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest24, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 5;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest25, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 4;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest26, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 4;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest27, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 3;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest28, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 3;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest29, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 2;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest30, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 2;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest31, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 1;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+/**
+ * @tc.name: OnUpgrade
+ * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
+ * @tc.type: FUNC
+ */
+HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest32, TestSize.Level1)
+{
+    std::string databasePath = "/cloudfile/100/com.huawei.hmos.filemanager/rdb";
+    RdbStoreMock store;
+    RdbStoreMock* rdb = &store;
+    CloudDiskDataCallBack CloudDiskDataCallBack;
+    int32_t oldVersion = 1;
+    int32_t newVersion = 0;
+    int32_t rowCount = 0;
+    std::shared_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>();
+    EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
+    EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
+    EXPECT_CALL(*rdb, GetPath()).WillRepeatedly(Return(databasePath));
+    EXPECT_CALL(*rdb, Query(_, _)).WillRepeatedly(Return((rset)));
+    EXPECT_CALL(*rset, GetRowCount(_)).WillRepeatedly(DoAll(SetArgReferee<0>(rowCount), Return(E_OK)));
+    EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+    int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
+    EXPECT_EQ(ret, E_OK);
+}
+
+
+
+
+
+
+
+
+
+/**
+ * @tc.name: UpdateTHMStatus
+ * @tc.desc: Verify the CloudDiskRdbStore::UpdateTHMStatus function
+ * @tc.type: FUNC
+ * @tc.require: ICGORT
+ */
+HWTEST_F(CloudDiskRdbStoreTest, UpdateTHMStatusTest001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UpdateTHMStatusTest001 start";
+    try {
+        shared_ptr<CloudDiskMetaFile> metaFile = make_shared<CloudDiskMetaFile>(100, "", "");
+        MetaBase metaBase;
+        metaBase.fileType == FILE_TYPE_THUMBNAIL;
+        int32_t status = 0;
+        bool preCount = true;
+        auto rdb = make_shared<RdbStoreMock>();
+        clouddiskrdbStore_->rdbStore_ = rdb;
+        auto transaction = make_shared<TransactionMock>();
+        EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
+        .WillOnce(Return(ByMove(nullptr)));
+        int32_t ret = clouddiskrdbStore_->UpdateTHMStatus(metaFile, metaBase, status);
+        EXPECT_EQ(ret, E_RDB);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UpdateTHMStatusTest001 failed";
+    }
+    GTEST_LOG_(INFO) << "UpdateTHMStatusTest001 end";
+}
+
+/**
+ * @tc.name: UpdateTHMStatus
+ * @tc.desc: Verify the CloudDiskRdbStore::UpdateTHMStatus function
+ * @tc.type: FUNC
+ * @tc.require: ICGORT
+ */
+HWTEST_F(CloudDiskRdbStoreTest, UpdateTHMStatusTest002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UpdateTHMStatusTest002 start";
+    try {
+        shared_ptr<CloudDiskMetaFile> metaFile = make_shared<CloudDiskMetaFile>(100, "", "");
+        MetaBase metaBase;
+        metaBase.fileType == FILE_TYPE_CONTENT;
+        int32_t status = 0;
+        bool preCount = true;
+        auto rdb = make_shared<RdbStoreMock>();
+        clouddiskrdbStore_->rdbStore_ = rdb;
+        auto transaction = make_shared<TransactionMock>();
+        std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
+        EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
+        .WillOnce(Return(ByMove(rset)));
+        EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
+        EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
+        EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
+        EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(50, transaction)));
+        int32_t ret = clouddiskrdbStore_->UpdateTHMStatus(metaFile, metaBase, status);
+        EXPECT_EQ(ret, 50);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UpdateTHMStatusTest002 failed";
+    }
+    GTEST_LOG_(INFO) << "UpdateTHMStatusTest002 end";
+}
+
+/**
+ * @tc.name: UpdateTHMStatus
+ * @tc.desc: Verify the CloudDiskRdbStore::UpdateTHMStatus function
+ * @tc.type: FUNC
+ * @tc.require: ICGORT
+ */
+HWTEST_F(CloudDiskRdbStoreTest, UpdateTHMStatusTest003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UpdateTHMStatusTest003 start";
+    try {
+        shared_ptr<CloudDiskMetaFile> metaFile = make_shared<CloudDiskMetaFile>(100, "", "");
+        MetaBase metaBase;
+        metaBase.fileType == FILE_TYPE_CONTENT;
+        int32_t status = 0;
+        bool preCount = true;
+        auto rdb = make_shared<RdbStoreMock>();
+        clouddiskrdbStore_->rdbStore_ = rdb;
+        auto transaction = make_shared<TransactionMock>();
+        std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
+        EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
+        .WillOnce(Return(ByMove(rset)));
+        EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
+        EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
+        EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
+        EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
+        EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
+        int32_t ret = clouddiskrdbStore_->UpdateTHMStatus(metaFile, metaBase, status);
+        EXPECT_EQ(ret, E_RDB);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UpdateTHMStatusTest003 failed";
+    }
+    GTEST_LOG_(INFO) << "UpdateTHMStatusTest003 end";
+}
+
+/**
+ * @tc.name: UpdateTHMStatus
+ * @tc.desc: Verify the CloudDiskRdbStore::UpdateTHMStatus function
+ * @tc.type: FUNC
+ * @tc.require: ICGORT
+ */
+HWTEST_F(CloudDiskRdbStoreTest, UpdateTHMStatusTest004, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UpdateTHMStatusTest004 start";
+    try {
+        shared_ptr<CloudDiskMetaFile> metaFile = make_shared<CloudDiskMetaFile>(100, "", "");
+        MetaBase metaBase;
+        metaBase.fileType == FILE_TYPE_CONTENT;
+        int32_t status = 0;
+        bool preCount = true;
+        auto rdb = make_shared<RdbStoreMock>();
+        clouddiskrdbStore_->rdbStore_ = rdb;
+        auto transaction = make_shared<TransactionMock>();
+        std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
+        EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
+        .WillOnce(Return(ByMove(rset)));
+        EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
+        EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
+        EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
+        EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
+        EXPECT_CALL(*transaction, Update(_, _, _)).WillRepeatedly(Return(std::make_pair(E_OK, 0)));
+        int32_t ret = clouddiskrdbStore_->UpdateTHMStatus(metaFile, metaBase, status);
+        EXPECT_EQ(ret, E_OK);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UpdateTHMStatusTest004 failed";
+    }
+    GTEST_LOG_(INFO) << "UpdateTHMStatusTest004 end";
+}
+
+/**
+ * @tc.name: GetSrcCloudId
+ * @tc.desc: Verify the CloudDiskRdbStore::GetSrcCloudId function
+ * @tc.type: FUNC
+ * @tc.require: ICGORT
+ */
+HWTEST_F(CloudDiskRdbStoreTest, GetSrcCloudIdTest001, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "GetSrcCloudIdTest001 start";
+    try {
+        std::string cloudId = "";
+        std::string srcCloudId = "";
+        bool preCount = true;
+        auto rdb = make_shared<RdbStoreMock>();
+        clouddiskrdbStore_->rdbStore_ = rdb;
+        EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
+        .WillOnce(Return(ByMove(nullptr)));
+        int32_t ret = clouddiskrdbStore_->GetSrcCloudId(cloudId, srcCloudId);
+        EXPECT_EQ(ret, E_RDB);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "GetSrcCloudIdTest001 failed";
+    }
+    GTEST_LOG_(INFO) << "GetSrcCloudIdTest001 end";
+}
+
+/**
+ * @tc.name: GetSrcCloudId
+ * @tc.desc: Verify the CloudDiskRdbStore::GetSrcCloudId function
+ * @tc.type: FUNC
+ * @tc.require: ICGORT
+ */
+HWTEST_F(CloudDiskRdbStoreTest, GetSrcCloudIdTest002, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "GetSrcCloudIdTest002 start";
+    try {
+        std::string cloudId = "";
+        std::string srcCloudId = "";
+        bool preCount = true;
+        auto rdb = make_shared<RdbStoreMock>();
+        clouddiskrdbStore_->rdbStore_ = rdb;
+        auto transaction = make_shared<TransactionMock>();
+        std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
+        EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
+        .WillOnce(Return(ByMove(rset)));
+        EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
+        int32_t ret = clouddiskrdbStore_->GetSrcCloudId(cloudId, srcCloudId);
+        EXPECT_EQ(ret, E_RDB);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "GetSrcCloudIdTest002 failed";
+    }
+    GTEST_LOG_(INFO) << "GetSrcCloudIdTest002 end";
+}
+
+/**
+ * @tc.name: GetSrcCloudId
+ * @tc.desc: Verify the CloudDiskRdbStore::GetSrcCloudId function
+ * @tc.type: FUNC
+ * @tc.require: ICGORT
+ */
+HWTEST_F(CloudDiskRdbStoreTest, GetSrcCloudIdTest003, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "GetSrcCloudIdTest003 start";
+    try {
+        std::string cloudId = "";
+        std::string srcCloudId = "";
+        bool preCount = true;
+        auto rdb = make_shared<RdbStoreMock>();
+        clouddiskrdbStore_->rdbStore_ = rdb;
+        auto transaction = make_shared<TransactionMock>();
+        std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
+        EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
+        .WillOnce(Return(ByMove(rset)));
+        EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
+        EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_RDB));
+        EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
+        int32_t ret = clouddiskrdbStore_->GetSrcCloudId(cloudId, srcCloudId);
+        EXPECT_EQ(ret, E_RDB);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "GetSrcCloudIdTest003 failed";
+    }
+    GTEST_LOG_(INFO) << "GetSrcCloudIdTest003 end";
+}
+
+/**
+ * @tc.name: GetSrcCloudId
+ * @tc.desc: Verify the CloudDiskRdbStore::GetSrcCloudId function
+ * @tc.type: FUNC
+ * @tc.require: ICGORT
+ */
+HWTEST_F(CloudDiskRdbStoreTest, GetSrcCloudIdTest004, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "GetSrcCloudIdTest004 start";
+    try {
+        std::string cloudId = "";
+        std::string srcCloudId = "";
+        bool preCount = true;
+        auto rdb = make_shared<RdbStoreMock>();
+        clouddiskrdbStore_->rdbStore_ = rdb;
+        auto transaction = make_shared<TransactionMock>();
+        std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
+        EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
+        .WillOnce(Return(ByMove(rset)));
+        EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
+        EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
+        EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
+        int32_t ret = clouddiskrdbStore_->GetSrcCloudId(cloudId, srcCloudId);
+        EXPECT_EQ(ret, E_OK);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "GetSrcCloudIdTest004 failed";
+    }
+    GTEST_LOG_(INFO) << "GetSrcCloudIdTest004 end";
+}
+
 /**
  * @tc.name: CreateDentryFile
  * @tc.desc: Verify the CloudDiskRdbStore::CreateDentryFile function