1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define LOG_TAG "CloudDataTest"
16 #include <gtest/gtest.h>
17 #include <unistd.h>
18 
19 #include "accesstoken_kit.h"
20 #include "account/account_delegate.h"
21 #include "bootstrap.h"
22 #include "checker_mock.h"
23 #include "cloud/change_event.h"
24 #include "cloud/cloud_event.h"
25 #include "cloud/cloud_server.h"
26 #include "cloud/cloud_share_event.h"
27 #include "cloud/schema_meta.h"
28 #include "cloud_service_impl.h"
29 #include "cloud_types.h"
30 #include "cloud_types_util.h"
31 #include "cloud_value_util.h"
32 #include "communicator/device_manager_adapter.h"
33 #include "device_matrix.h"
34 #include "eventcenter/event_center.h"
35 #include "feature/feature_system.h"
36 #include "ipc_skeleton.h"
37 #include "log_print.h"
38 #include "metadata/meta_data_manager.h"
39 #include "metadata/store_meta_data.h"
40 #include "metadata/store_meta_data_local.h"
41 #include "mock/db_store_mock.h"
42 #include "mock/general_store_mock.h"
43 #include "rdb_query.h"
44 #include "rdb_service.h"
45 #include "rdb_service_impl.h"
46 #include "rdb_types.h"
47 #include "store/auto_cache.h"
48 #include "store/store_info.h"
49 #include "token_setproc.h"
50 
51 using namespace testing::ext;
52 using namespace OHOS::DistributedData;
53 using namespace OHOS::Security::AccessToken;
54 using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
55 using Querykey = OHOS::CloudData::QueryKey;
56 using CloudSyncInfo = OHOS::CloudData::CloudSyncInfo;
57 using SharingCfm = OHOS::CloudData::SharingUtil::SharingCfm;
58 using Confirmation = OHOS::CloudData::Confirmation;
59 using CenterCode = OHOS::DistributedData::SharingCenter::SharingCode;
60 using Status = OHOS::CloudData::CloudService::Status;
61 using GenErr = OHOS::DistributedData::GeneralError;
62 uint64_t g_selfTokenID = 0;
63 
AllocHapToken(const HapPolicyParams & policy)64 void AllocHapToken(const HapPolicyParams &policy)
65 {
66     HapInfoParams info = {
67         .userID = 100,
68         .bundleName = "test_cloud_bundleName",
69         .instIndex = 0,
70         .appIDDesc = "test_cloud_bundleName",
71         .isSystemApp = true
72     };
73     auto token = AccessTokenKit::AllocHapToken(info, policy);
74     SetSelfTokenID(token.tokenIDEx);
75 }
76 
77 namespace OHOS::Test {
78 namespace DistributedDataTest {
79 static constexpr const char *TEST_CLOUD_BUNDLE = "test_cloud_bundleName";
80 static constexpr const char *TEST_CLOUD_APPID = "test_cloud_appid";
81 static constexpr const char *TEST_CLOUD_STORE = "test_cloud_store";
82 static constexpr const char *TEST_CLOUD_ID = "test_cloud_id";
83 static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_1 = "test_cloud_database_alias_1";
84 static constexpr const char *TEST_CLOUD_DATABASE_ALIAS_2 = "test_cloud_database_alias_2";
85 static constexpr const char *PERMISSION_CLOUDDATA_CONFIG = "ohos.permission.CLOUDDATA_CONFIG";
86 static constexpr const char *PERMISSION_GET_NETWORK_INFO = "ohos.permission.GET_NETWORK_INFO";
87 static constexpr const char *PERMISSION_DISTRIBUTED_DATASYNC = "ohos.permission.DISTRIBUTED_DATASYNC";
88 static constexpr const char *PERMISSION_ACCESS_SERVICE_DM = "ohos.permission.ACCESS_SERVICE_DM";
89 static constexpr const char *PERMISSION_MANAGE_LOCAL_ACCOUNTS = "ohos.permission.MANAGE_LOCAL_ACCOUNTS";
GetPermissionDef(const std::string & permission)90 PermissionDef GetPermissionDef(const std::string &permission)
91 {
92     PermissionDef def = { .permissionName = permission,
93         .bundleName = "test_cloud_bundleName",
94         .grantMode = 1,
95         .availableLevel = APL_SYSTEM_BASIC,
96         .label = "label",
97         .labelId = 1,
98         .description = "test_cloud_bundleName",
99         .descriptionId = 1 };
100     return def;
101 }
102 
GetPermissionStateFull(const std::string & permission)103 PermissionStateFull GetPermissionStateFull(const std::string &permission)
104 {
105     PermissionStateFull stateFull = { .permissionName = permission,
106         .isGeneral = true,
107         .resDeviceID = { "local" },
108         .grantStatus = { PermissionState::PERMISSION_GRANTED },
109         .grantFlags = { 1 } };
110     return stateFull;
111 }
112 class CloudDataTest : public testing::Test {
113 public:
114     static void SetUpTestCase(void);
115     static void TearDownTestCase(void);
116     void SetUp();
117     void TearDown();
118 
119     static SchemaMeta schemaMeta_;
120     static std::shared_ptr<CloudData::CloudServiceImpl> cloudServiceImpl_;
121 
122 protected:
123     static void InitMetaData();
124     static void InitSchemaMeta();
125     static void InitCloudInfo();
126     static std::shared_ptr<DBStoreMock> dbStoreMock_;
127     static StoreMetaData metaData_;
128     static CloudInfo cloudInfo_;
129     static DistributedData::CheckerMock checker_;
130 };
131 
132 class CloudServerMock : public CloudServer {
133 public:
134     CloudInfo GetServerInfo(int32_t userId, bool needSpaceInfo) override;
135     std::pair<int32_t, SchemaMeta> GetAppSchema(int32_t userId, const std::string &bundleName) override;
136     virtual ~CloudServerMock() = default;
137     static constexpr uint64_t REMAINSPACE = 1000;
138     static constexpr uint64_t TATALSPACE = 2000;
139     static constexpr int32_t INVALID_USER_ID = -1;
140 };
141 
GetServerInfo(int32_t userId,bool needSpaceInfo)142 CloudInfo CloudServerMock::GetServerInfo(int32_t userId, bool needSpaceInfo)
143 {
144     CloudInfo cloudInfo;
145     cloudInfo.user = userId;
146     cloudInfo.id = TEST_CLOUD_ID;
147     cloudInfo.remainSpace = REMAINSPACE;
148     cloudInfo.totalSpace = TATALSPACE;
149     cloudInfo.enableCloud = true;
150 
151     CloudInfo::AppInfo appInfo;
152     appInfo.bundleName = TEST_CLOUD_BUNDLE;
153     appInfo.appId = TEST_CLOUD_APPID;
154     appInfo.version = 1;
155     appInfo.cloudSwitch = true;
156 
157     cloudInfo.apps[TEST_CLOUD_BUNDLE] = std::move(appInfo);
158     return cloudInfo;
159 }
160 
GetAppSchema(int32_t userId,const std::string & bundleName)161 std::pair<int32_t, SchemaMeta> CloudServerMock::GetAppSchema(int32_t userId, const std::string &bundleName)
162 {
163     if (userId == INVALID_USER_ID) {
164         return { E_ERROR, CloudDataTest::schemaMeta_ };
165     }
166 
167     if (bundleName.empty()) {
168         SchemaMeta schemaMeta;
169         return { E_OK, schemaMeta };
170     }
171     return { E_OK, CloudDataTest::schemaMeta_ };
172 }
173 
174 std::shared_ptr<DBStoreMock> CloudDataTest::dbStoreMock_ = std::make_shared<DBStoreMock>();
175 SchemaMeta CloudDataTest::schemaMeta_;
176 StoreMetaData CloudDataTest::metaData_;
177 CloudInfo CloudDataTest::cloudInfo_;
178 std::shared_ptr<CloudData::CloudServiceImpl> CloudDataTest::cloudServiceImpl_ =
179     std::make_shared<CloudData::CloudServiceImpl>();
180 DistributedData::CheckerMock CloudDataTest::checker_;
181 
InitMetaData()182 void CloudDataTest::InitMetaData()
183 {
184     metaData_.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
185     metaData_.appId = TEST_CLOUD_APPID;
186     metaData_.bundleName = TEST_CLOUD_BUNDLE;
187     metaData_.tokenId = OHOS::IPCSkeleton::GetCallingTokenID();
188     metaData_.user = std::to_string(DistributedKv::AccountDelegate::GetInstance()->GetUserByToken(metaData_.tokenId));
189     metaData_.area = OHOS::DistributedKv::EL1;
190     metaData_.instanceId = 0;
191     metaData_.isAutoSync = true;
192     metaData_.storeType = DistributedRdb::RDB_DEVICE_COLLABORATION;
193     metaData_.storeId = TEST_CLOUD_STORE;
194     PolicyValue value;
195     value.type = OHOS::DistributedKv::PolicyType::IMMEDIATE_SYNC_ON_ONLINE;
196 }
197 
InitSchemaMeta()198 void CloudDataTest::InitSchemaMeta()
199 {
200     SchemaMeta::Field field1;
201     field1.colName = "test_cloud_field_name1";
202     field1.alias = "test_cloud_field_alias1";
203     SchemaMeta::Field field2;
204     field2.colName = "test_cloud_field_name2";
205     field2.alias = "test_cloud_field_alias2";
206 
207     SchemaMeta::Table table;
208     table.name = "test_cloud_table_name";
209     table.alias = "test_cloud_table_alias";
210     table.fields.emplace_back(field1);
211     table.fields.emplace_back(field2);
212 
213     SchemaMeta::Database database;
214     database.name = TEST_CLOUD_STORE;
215     database.alias = TEST_CLOUD_DATABASE_ALIAS_1;
216     database.tables.emplace_back(table);
217 
218     schemaMeta_.version = 1;
219     schemaMeta_.bundleName = TEST_CLOUD_BUNDLE;
220     schemaMeta_.databases.emplace_back(database);
221     database.alias = TEST_CLOUD_DATABASE_ALIAS_2;
222     schemaMeta_.databases.emplace_back(database);
223 }
224 
InitCloudInfo()225 void CloudDataTest::InitCloudInfo()
226 {
227     cloudInfo_.user = DistributedKv::AccountDelegate::GetInstance()->GetUserByToken(IPCSkeleton::GetCallingTokenID());
228     cloudInfo_.id = TEST_CLOUD_ID;
229     cloudInfo_.enableCloud = true;
230 
231     CloudInfo::AppInfo appInfo;
232     appInfo.bundleName = TEST_CLOUD_BUNDLE;
233     appInfo.appId = TEST_CLOUD_APPID;
234     appInfo.version = 1;
235     appInfo.cloudSwitch = true;
236 
237     cloudInfo_.apps[TEST_CLOUD_BUNDLE] = std::move(appInfo);
238 }
239 
SetUpTestCase(void)240 void CloudDataTest::SetUpTestCase(void)
241 {
242     MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr);
243     MetaDataManager::GetInstance().SetSyncer(
244         [](const auto &, auto) { DeviceMatrix::GetInstance().OnChanged(DeviceMatrix::META_STORE_MASK); });
245 
246     auto cloudServerMock = new CloudServerMock();
247     CloudServer::RegisterCloudInstance(cloudServerMock);
248     HapPolicyParams policy = { .apl = APL_SYSTEM_BASIC,
249         .domain = "test.domain",
250         .permList = { GetPermissionDef(PERMISSION_CLOUDDATA_CONFIG), GetPermissionDef(PERMISSION_GET_NETWORK_INFO),
251             GetPermissionDef(PERMISSION_DISTRIBUTED_DATASYNC), GetPermissionDef(PERMISSION_ACCESS_SERVICE_DM),
252             GetPermissionDef(PERMISSION_MANAGE_LOCAL_ACCOUNTS) },
253         .permStateList = { GetPermissionStateFull(PERMISSION_CLOUDDATA_CONFIG),
254             GetPermissionStateFull(PERMISSION_GET_NETWORK_INFO),
255             GetPermissionStateFull(PERMISSION_DISTRIBUTED_DATASYNC),
256             GetPermissionStateFull(PERMISSION_ACCESS_SERVICE_DM),
257             GetPermissionStateFull(PERMISSION_MANAGE_LOCAL_ACCOUNTS)} };
258     g_selfTokenID = GetSelfTokenID();
259     AllocHapToken(policy);
260     size_t max = 12;
261     size_t min = 5;
262 
263     auto executor = std::make_shared<ExecutorPool>(max, min);
264     cloudServiceImpl_->OnBind(
265         { "CloudDataTest", static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID()), std::move(executor) });
266     Bootstrap::GetInstance().LoadCheckers();
267     auto dmExecutor = std::make_shared<ExecutorPool>(max, min);
268     DeviceManagerAdapter::GetInstance().Init(dmExecutor);
269     InitCloudInfo();
270     InitMetaData();
271     InitSchemaMeta();
272     DeviceManagerAdapter::GetInstance().SetNet(DeviceManagerAdapter::WIFI);
273 }
274 
TearDownTestCase()275 void CloudDataTest::TearDownTestCase()
276 {
277     SetSelfTokenID(g_selfTokenID);
278 }
279 
SetUp()280 void CloudDataTest::SetUp()
281 {
282     MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetKey(), cloudInfo_, true);
283     MetaDataManager::GetInstance().SaveMeta(metaData_.GetKey(), metaData_, true);
284     MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta_, true);
285 }
286 
TearDown()287 void CloudDataTest::TearDown()
288 {
289     MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
290     MetaDataManager::GetInstance().DelMeta(metaData_.GetKey(), true);
291     MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), true);
292 }
293 
294 /**
295 * @tc.name: GetSchema
296 * @tc.desc: GetSchema from cloud when no schema in meta.
297 * @tc.type: FUNC
298 * @tc.require:
299 * @tc.author: ht
300 */
301 HWTEST_F(CloudDataTest, GetSchema, TestSize.Level0)
302 {
303     ZLOGI("CloudDataTest start");
304     auto cloudServerMock = std::make_shared<CloudServerMock>();
305     auto user = DistributedKv::AccountDelegate::GetInstance()->GetUserByToken(OHOS::IPCSkeleton::GetCallingTokenID());
306     auto cloudInfo = cloudServerMock->GetServerInfo(user, true);
307     ASSERT_TRUE(MetaDataManager::GetInstance().DelMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), true));
308     SchemaMeta schemaMeta;
309     ASSERT_FALSE(MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta, true));
310     StoreInfo storeInfo{ OHOS::IPCSkeleton::GetCallingTokenID(), TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, 0 };
311     auto event = std::make_unique<CloudEvent>(CloudEvent::GET_SCHEMA, storeInfo);
312     EventCenter::GetInstance().PostEvent(std::move(event));
313     auto ret = MetaDataManager::GetInstance().LoadMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE), schemaMeta, true);
314     ASSERT_TRUE(ret);
315 }
316 
317 /**
318 * @tc.name: QueryStatistics
319 * @tc.desc: The query interface failed because cloudInfo could not be found from the metadata.
320 * @tc.type: FUNC
321 * @tc.require:
322 */
323 HWTEST_F(CloudDataTest, QueryStatistics001, TestSize.Level0)
324 {
325     ZLOGI("CloudDataTest QueryStatistics001 start");
326     // prepare MetaDta
327     MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
328 
329     auto [status, result] = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "");
330     EXPECT_EQ(status, CloudData::CloudService::ERROR);
331     EXPECT_TRUE(result.empty());
332 }
333 
334 /**
335 * @tc.name: QueryStatistics
336 * @tc.desc: The query interface failed because SchemaMeta could not be found from the metadata.
337 * @tc.type: FUNC
338 * @tc.require:
339 */
340 HWTEST_F(CloudDataTest, QueryStatistics002, TestSize.Level0)
341 {
342     ZLOGI("CloudDataTest QueryStatistics002 start");
343     // prepare MetaDta
344     MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetSchemaKey(TEST_CLOUD_BUNDLE), true);
345     MetaDataManager::GetInstance().SaveMeta(cloudInfo_.GetKey(), cloudInfo_, true);
346 
347     auto [status, result] = cloudServiceImpl_->QueryStatistics("", "", "");
348     EXPECT_EQ(status, CloudData::CloudService::ERROR);
349     EXPECT_TRUE(result.empty());
350     std::tie(status, result) = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, "", "");
351     EXPECT_EQ(status, CloudData::CloudService::ERROR);
352     EXPECT_TRUE(result.empty());
353     std::tie(status, result) = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_STORE, "");
354     EXPECT_EQ(status, CloudData::CloudService::ERROR);
355     EXPECT_TRUE(result.empty());
356     std::tie(status, result) = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "");
357     EXPECT_EQ(status, CloudData::CloudService::ERROR);
358     EXPECT_TRUE(result.empty());
359 }
360 
361 /**
362 * @tc.name: QueryStatistics
363 * @tc.desc: Query the statistics of cloud records in a specified database.
364 * @tc.type: FUNC
365 * @tc.require:
366 */
367 HWTEST_F(CloudDataTest, QueryStatistics003, TestSize.Level0)
368 {
369     ZLOGI("CloudDataTest QueryStatistics003 start");
370     // Construct the statisticInfo data
__anon0b1436170202(const StoreMetaData &metaData) 371     auto creator = [](const StoreMetaData &metaData) -> GeneralStore * {
372         auto store = new (std::nothrow) GeneralStoreMock();
373         if (store != nullptr) {
374             std::map<std::string, Value> entry = { { "inserted", 1 }, { "updated", 2 }, { "normal", 3 } };
375             store->MakeCursor(entry);
376         }
377         return store;
378     };
379     AutoCache::GetInstance().RegCreator(DistributedRdb::RDB_DEVICE_COLLABORATION, creator);
380 
381     auto [status, result] =
382         cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
383     ASSERT_EQ(status, CloudData::CloudService::SUCCESS);
384     ASSERT_EQ(result.size(), 1);
385     for (const auto &it : result) {
386         ASSERT_EQ(it.first, TEST_CLOUD_DATABASE_ALIAS_1);
387         auto statisticInfos = it.second;
388         ASSERT_FALSE(statisticInfos.empty());
389         for (const auto &info : statisticInfos) {
390             EXPECT_EQ(info.inserted, 1);
391             EXPECT_EQ(info.updated, 2);
392             EXPECT_EQ(info.normal, 3);
393         }
394     }
395 }
396 
397 /**
398 * @tc.name: QueryStatistics
399 * @tc.desc: Query the statistics of all local database cloud records.
400 * @tc.type: FUNC
401 * @tc.require:
402 */
403 HWTEST_F(CloudDataTest, QueryStatistics004, TestSize.Level0)
404 {
405     ZLOGI("CloudDataTest QueryStatistics004 start");
406 
407     // Construct the statisticInfo data
__anon0b1436170302(const StoreMetaData &metaData) 408     auto creator = [](const StoreMetaData &metaData) -> GeneralStore * {
409         auto store = new (std::nothrow) GeneralStoreMock();
410         if (store != nullptr) {
411             std::map<std::string, Value> entry = { { "inserted", 1 }, { "updated", 2 }, { "normal", 3 } };
412             store->MakeCursor(entry);
413         }
414         return store;
415     };
416     AutoCache::GetInstance().RegCreator(DistributedRdb::RDB_DEVICE_COLLABORATION, creator);
417 
418     auto [status, result] = cloudServiceImpl_->QueryStatistics(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "");
419     ASSERT_EQ(status, CloudData::CloudService::SUCCESS);
420     ASSERT_EQ(result.size(), 2);
421     for (const auto &it : result) {
422         auto statisticInfos = it.second;
423         ASSERT_FALSE(statisticInfos.empty());
424         for (const auto &info : statisticInfos) {
425             EXPECT_EQ(info.inserted, 1);
426             EXPECT_EQ(info.updated, 2);
427             EXPECT_EQ(info.normal, 3);
428         }
429     }
430 }
431 
432 /**
433 * @tc.name: QueryLastSyncInfo001
434 * @tc.desc: The query last sync info interface failed because account is false.
435 * @tc.type: FUNC
436 * @tc.require:
437  */
438 HWTEST_F(CloudDataTest, QueryLastSyncInfo001, TestSize.Level0)
439 {
440     ZLOGI("CloudDataTest QueryLastSyncInfo001 start");
441     auto [status, result] =
442         cloudServiceImpl_->QueryLastSyncInfo("accountId", TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
443     EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
444     EXPECT_TRUE(result.empty());
445 }
446 
447 /**
448 * @tc.name: QueryLastSyncInfo002
449 * @tc.desc: The query last sync info interface failed because bundleName is false.
450 * @tc.type: FUNC
451 * @tc.require:
452  */
453 HWTEST_F(CloudDataTest, QueryLastSyncInfo002, TestSize.Level0)
454 {
455     ZLOGI("CloudDataTest QueryLastSyncInfo002 start");
456     auto [status, result] =
457         cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, "bundleName", TEST_CLOUD_DATABASE_ALIAS_1);
458     EXPECT_EQ(status, CloudData::CloudService::Status::INVALID_ARGUMENT);
459     EXPECT_TRUE(result.empty());
460 }
461 
462 /**
463 * @tc.name: QueryLastSyncInfo003
464 * @tc.desc: The query last sync info interface failed because storeId is false.
465 * @tc.type: FUNC
466 * @tc.require:
467  */
468 HWTEST_F(CloudDataTest, QueryLastSyncInfo003, TestSize.Level0)
469 {
470     ZLOGI("CloudDataTest QueryLastSyncInfo003 start");
471     auto [status, result] = cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, "storeId");
472     EXPECT_EQ(status, CloudData::CloudService::INVALID_ARGUMENT);
473     EXPECT_TRUE(result.empty());
474 }
475 
476 /**
477 * @tc.name: QueryLastSyncInfo004
478 * @tc.desc: The query last sync info interface failed when switch is close.
479 * @tc.type: FUNC
480 * @tc.require:
481  */
482 HWTEST_F(CloudDataTest, QueryLastSyncInfo004, TestSize.Level0)
483 {
484     ZLOGI("CloudDataTest QueryLastSyncInfo004 start");
485     auto ret = cloudServiceImpl_->DisableCloud(TEST_CLOUD_ID);
486     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
487     cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
488 
489     sleep(1);
490 
491     auto [status, result] =
492         cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
493     EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
494     EXPECT_TRUE(!result.empty());
495     EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].code = E_CLOUD_DISABLED);
496 }
497 
498 /**
499 * @tc.name: QueryLastSyncInfo005
500 * @tc.desc: The query last sync info interface failed when app cloud switch is close.
501 * @tc.type: FUNC
502 * @tc.require:
503  */
504 HWTEST_F(CloudDataTest, QueryLastSyncInfo005, TestSize.Level0)
505 {
506     ZLOGI("CloudDataTest QueryLastSyncInfo005 start");
507     std::map<std::string, int32_t> switches;
508     switches.emplace(TEST_CLOUD_ID, true);
509     CloudInfo info;
510     MetaDataManager::GetInstance().LoadMeta(cloudInfo_.GetKey(), info, true);
511     info.apps[TEST_CLOUD_BUNDLE].cloudSwitch = false;
512     MetaDataManager::GetInstance().SaveMeta(info.GetKey(), info, true);
513     cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
514     sleep(1);
515 
516     auto [status, result] =
517         cloudServiceImpl_->QueryLastSyncInfo(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, TEST_CLOUD_DATABASE_ALIAS_1);
518     EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
519     EXPECT_TRUE(!result.empty());
520     EXPECT_TRUE(result[TEST_CLOUD_DATABASE_ALIAS_1].code = E_CLOUD_DISABLED);
521 }
522 
523 /**
524 * @tc.name: Share
525 * @tc.desc:
526 * @tc.type: FUNC
527 * @tc.require:
528  */
529 HWTEST_F(CloudDataTest, Share001, TestSize.Level0)
530 {
531     std::string sharingRes = "";
532     CloudData::Participants participants{};
533     CloudData::Results results;
534     auto ret = cloudServiceImpl_->Share(sharingRes, participants, results);
535     EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
536 }
537 
538 /**
539 * @tc.name: Unshare
540 * @tc.desc:
541 * @tc.type: FUNC
542 * @tc.require:
543  */
544 HWTEST_F(CloudDataTest, Unshare001, TestSize.Level0)
545 {
546     std::string sharingRes = "";
547     CloudData::Participants participants{};
548     CloudData::Results results;
549     auto ret = cloudServiceImpl_->Unshare(sharingRes, participants, results);
550     EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
551 }
552 
553 /**
554 * @tc.name: ChangePrivilege
555 * @tc.desc:
556 * @tc.type: FUNC
557 * @tc.require:
558  */
559 HWTEST_F(CloudDataTest, ChangePrivilege001, TestSize.Level0)
560 {
561     std::string sharingRes = "";
562     CloudData::Participants participants{};
563     CloudData::Results results;
564     auto ret = cloudServiceImpl_->ChangePrivilege(sharingRes, participants, results);
565     EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
566 }
567 
568 /**
569 * @tc.name: ChangeConfirmation
570 * @tc.desc:
571 * @tc.type: FUNC
572 * @tc.require:
573  */
574 HWTEST_F(CloudDataTest, ChangeConfirmation001, TestSize.Level0)
575 {
576     std::string sharingRes = "";
577     int32_t confirmation = 0;
578     std::pair<int32_t, std::string> result;
579     auto ret = cloudServiceImpl_->ChangeConfirmation(sharingRes, confirmation, result);
580     EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
581 }
582 
583 /**
584 * @tc.name: ConfirmInvitation
585 * @tc.desc:
586 * @tc.type: FUNC
587 * @tc.require:
588  */
589 HWTEST_F(CloudDataTest, ConfirmInvitation001, TestSize.Level0)
590 {
591     std::string sharingRes = "";
592     int32_t confirmation = 0;
593     std::tuple<int32_t, std::string, std::string> result;
594     auto ret = cloudServiceImpl_->ConfirmInvitation(sharingRes, confirmation, result);
595     EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
596 }
597 
598 /**
599 * @tc.name: Exit
600 * @tc.desc:
601 * @tc.type: FUNC
602 * @tc.require:
603  */
604 HWTEST_F(CloudDataTest, Exit001, TestSize.Level0)
605 {
606     std::string sharingRes = "";
607     std::pair<int32_t, std::string> result;
608     auto ret = cloudServiceImpl_->Exit(sharingRes, result);
609     EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
610 }
611 
612 /**
613 * @tc.name: Query
614 * @tc.desc:
615 * @tc.type: FUNC
616 * @tc.require:
617  */
618 HWTEST_F(CloudDataTest, Query001, TestSize.Level0)
619 {
620     std::string sharingRes = "";
621     CloudData::QueryResults result;
622     auto ret = cloudServiceImpl_->Query(sharingRes, result);
623     EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
624 }
625 
626 /**
627 * @tc.name: QueryByInvitation
628 * @tc.desc:
629 * @tc.type: FUNC
630 * @tc.require:
631  */
632 HWTEST_F(CloudDataTest, QueryByInvitation001, TestSize.Level0)
633 {
634     std::string invitation = "";
635     CloudData::QueryResults result;
636     auto ret = cloudServiceImpl_->QueryByInvitation(invitation, result);
637     EXPECT_EQ(ret, CloudData::CloudService::NOT_SUPPORT);
638 }
639 
640 /**
641 * @tc.name: AllocResourceAndShare
642 * @tc.desc:
643 * @tc.type: FUNC
644 * @tc.require:
645  */
646 HWTEST_F(CloudDataTest, AllocResourceAndShare001, TestSize.Level0)
647 {
648     DistributedRdb::PredicatesMemo predicates;
649     predicates.tables_.push_back(TEST_CLOUD_BUNDLE);
650     std::vector<std::string> columns;
651     CloudData::Participants participants;
652     auto [ret, _] = cloudServiceImpl_->AllocResourceAndShare(TEST_CLOUD_STORE, predicates, columns, participants);
653     EXPECT_EQ(ret, E_ERROR);
654 }
655 
656 /**
657 * @tc.name: SetGlobalCloudStrategy
658 * @tc.desc:
659 * @tc.type: FUNC
660 * @tc.require:
661  */
662 HWTEST_F(CloudDataTest, SetGlobalCloudStrategy001, TestSize.Level0)
663 {
664     std::vector<CommonType::Value> values;
665     values.push_back(CloudData::NetWorkStrategy::WIFI);
666     CloudData::Strategy strategy = CloudData::Strategy::STRATEGY_BUTT;
667     auto ret = cloudServiceImpl_->SetGlobalCloudStrategy(strategy, values);
668     EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
669     strategy = CloudData::Strategy::STRATEGY_NETWORK;
670     ret = cloudServiceImpl_->SetGlobalCloudStrategy(strategy, values);
671     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
672 }
673 
674 /**
675 * @tc.name: SetCloudStrategy
676 * @tc.desc:
677 * @tc.type: FUNC
678 * @tc.require:
679  */
680 HWTEST_F(CloudDataTest, SetCloudStrategy001, TestSize.Level0)
681 {
682     std::vector<CommonType::Value> values;
683     values.push_back(CloudData::NetWorkStrategy::WIFI);
684     CloudData::Strategy strategy = CloudData::Strategy::STRATEGY_BUTT;
685     auto ret = cloudServiceImpl_->SetCloudStrategy(strategy, values);
686     EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
687     strategy = CloudData::Strategy::STRATEGY_NETWORK;
688     ret = cloudServiceImpl_->SetCloudStrategy(strategy, values);
689     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
690 }
691 
692 /**
693 * @tc.name: Clean
694 * @tc.desc:
695 * @tc.type: FUNC
696 * @tc.require:
697  */
698 HWTEST_F(CloudDataTest, Clean001, TestSize.Level0)
699 {
700     std::map<std::string, int32_t> actions;
701     actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::Action::CLEAR_CLOUD_BUTT);
702     std::string id = "testId";
703     std::string bundleName = "testBundleName";
704     auto ret = cloudServiceImpl_->Clean(id, actions);
705     EXPECT_EQ(ret, CloudData::CloudService::ERROR);
706     ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
707     EXPECT_EQ(ret, CloudData::CloudService::ERROR);
708     actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::Action::CLEAR_CLOUD_INFO);
709     actions.insert_or_assign(bundleName, CloudData::CloudService::Action::CLEAR_CLOUD_DATA_AND_INFO);
710     ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
711     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
712 }
713 
714 /**
715 * @tc.name: Clean
716 * @tc.desc:
717 * @tc.type: FUNC
718 * @tc.require:
719  */
720 HWTEST_F(CloudDataTest, Clean002, TestSize.Level0)
721 {
722     MetaDataManager::GetInstance().DelMeta(metaData_.GetKey(), true);
723     std::map<std::string, int32_t> actions;
724     actions.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::Action::CLEAR_CLOUD_INFO);
725     auto ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
726     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
727     StoreMetaDataLocal localMeta;
728     localMeta.isPublic = false;
729     MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyLocal(), localMeta, true);
730     ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
731     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
732     localMeta.isPublic = true;
733     MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyLocal(), localMeta, true);
734     ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
735     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
736     metaData_.user = "0";
737     MetaDataManager::GetInstance().SaveMeta(metaData_.GetKey(), metaData_, true);
738     ret = cloudServiceImpl_->Clean(TEST_CLOUD_ID, actions);
739     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
740     MetaDataManager::GetInstance().DelMeta(metaData_.GetKey(), true);
741     metaData_.user = std::to_string(DistributedKv::AccountDelegate::GetInstance()->GetUserByToken(metaData_.tokenId));
742     MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyLocal(), true);
743 }
744 
745 /**
746 * @tc.name: NotifyDataChange
747 * @tc.desc:
748 * @tc.type: FUNC
749 * @tc.require:
750  */
751 HWTEST_F(CloudDataTest, NotifyDataChange001, TestSize.Level0)
752 {
753     auto ret = cloudServiceImpl_->NotifyDataChange(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE);
754     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
755 }
756 
757 /**
758 * @tc.name: NotifyDataChange
759 * @tc.desc:
760 * @tc.type: FUNC
761 * @tc.require:
762  */
763 HWTEST_F(CloudDataTest, NotifyDataChange002, TestSize.Level0)
764 {
765     constexpr const int32_t invalidUserId = -1;
766     std::string extraData;
767     auto ret = cloudServiceImpl_->NotifyDataChange("", extraData, invalidUserId);
768     EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
769     ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
770     EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
771     extraData = "{data:test}";
772     ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
773     EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
774     extraData = "{\"data\":\"{\\\"accountId\\\":\\\"id\\\",\\\"bundleName\\\":\\\"test_cloud_"
775                 "bundleName\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", \\\"databaseScopes\\\": "
776                 "\\\"[\\\\\\\"private\\\\\\\", "
777                 "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"test_cloud_table_alias\\\\\\\"]\\\"}\"}";
778     ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
779     EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
780     extraData = "{\"data\":\"{\\\"accountId\\\":\\\"test_cloud_id\\\",\\\"bundleName\\\":\\\"cloud_"
781                 "bundleName_test\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", "
782                 "\\\"databaseScopes\\\": "
783                 "\\\"[\\\\\\\"private\\\\\\\", "
784                 "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"test_cloud_table_alias\\\\\\\"]\\\"}\"}";
785     ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, invalidUserId);
786     EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
787 }
788 
789 /**
790 * @tc.name: NotifyDataChange
791 * @tc.desc:
792 * @tc.type: FUNC
793 * @tc.require:
794  */
795 HWTEST_F(CloudDataTest, NotifyDataChange003, TestSize.Level0)
796 {
797     constexpr const int32_t userId = 100;
798     constexpr const int32_t defaultUserId = 0;
799     std::string extraData = "{\"data\":\"{\\\"accountId\\\":\\\"test_cloud_id\\\",\\\"bundleName\\\":\\\"test_cloud_"
800                             "bundleName\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", "
801                             "\\\"databaseScopes\\\": "
802                             "\\\"[\\\\\\\"private\\\\\\\", "
803                             "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"\\\\\\\"]\\\"}\"}";
804     auto ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, defaultUserId);
805     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
806     extraData = "{\"data\":\"{\\\"accountId\\\":\\\"test_cloud_id\\\",\\\"bundleName\\\":\\\"test_cloud_"
807                 "bundleName\\\",\\\"containerName\\\":\\\"test_cloud_database_alias_1\\\", \\\"databaseScopes\\\": "
808                 "\\\"[\\\\\\\"private\\\\\\\", "
809                 "\\\\\\\"shared\\\\\\\"]\\\",\\\"recordTypes\\\":\\\"[\\\\\\\"test_cloud_table_alias\\\\\\\"]\\\"}\"}";
810     ret = cloudServiceImpl_->NotifyDataChange(CloudData::DATA_CHANGE_EVENT_ID, extraData, userId);
811     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
812 }
813 
814 /**
815 * @tc.name: OnReady
816 * @tc.desc:
817 * @tc.type: FUNC
818 * @tc.require:
819  */
820 HWTEST_F(CloudDataTest, OnReady001, TestSize.Level0)
821 {
822     std::string device = "test";
823     auto ret = cloudServiceImpl_->OnReady(device);
824     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
825     ret = cloudServiceImpl_->OnReady(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
826     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
827 }
828 
829 /**
830 * @tc.name: Offline
831 * @tc.desc:
832 * @tc.type: FUNC
833 * @tc.require:
834  */
835 HWTEST_F(CloudDataTest, Offline001, TestSize.Level0)
836 {
837     std::string device = "test";
838     auto ret = cloudServiceImpl_->Offline(device);
839     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
840     ret = cloudServiceImpl_->Offline(DeviceManagerAdapter::CLOUD_DEVICE_UUID);
841     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
842 }
843 
844 /**
845 * @tc.name: CloudShare
846 * @tc.desc:
847 * @tc.type: FUNC
848 * @tc.require:
849  */
850 HWTEST_F(CloudDataTest, CloudShare001, TestSize.Level0)
851 {
852     ZLOGI("weisx CloudShare start");
853     StoreInfo storeInfo{ OHOS::IPCSkeleton::GetCallingTokenID(), TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, 0 };
854     std::pair<int32_t, std::shared_ptr<Cursor>> result;
__anon0b1436170402(int32_t status, std::shared_ptr<Cursor> cursor) 855     CloudShareEvent::Callback asyncCallback = [&result](int32_t status, std::shared_ptr<Cursor> cursor) {
856         result.first = status;
857         result.second = cursor;
858     };
859     auto event = std::make_unique<CloudShareEvent>(storeInfo, nullptr, nullptr);
860     EventCenter::GetInstance().PostEvent(std::move(event));
861     auto event1 = std::make_unique<CloudShareEvent>(storeInfo, nullptr, asyncCallback);
862     EventCenter::GetInstance().PostEvent(std::move(event1));
863     EXPECT_EQ(result.first, GeneralError::E_ERROR);
864     auto rdbQuery = std::make_shared<DistributedRdb::RdbQuery>();
865     auto event2 = std::make_unique<CloudShareEvent>(storeInfo, rdbQuery, nullptr);
866     EventCenter::GetInstance().PostEvent(std::move(event2));
867     auto event3 = std::make_unique<CloudShareEvent>(storeInfo, rdbQuery, asyncCallback);
868     EventCenter::GetInstance().PostEvent(std::move(event3));
869     EXPECT_EQ(result.first, GeneralError::E_ERROR);
870 }
871 
872 /**
873 * @tc.name: OnUserChange
874 * @tc.desc:
875 * @tc.type: FUNC
876 * @tc.require:
877  */
878 HWTEST_F(CloudDataTest, OnUserChange001, TestSize.Level0)
879 {
880     constexpr const uint32_t ACCOUNT_DEFAULT = 2;
881     constexpr const uint32_t ACCOUNT_DELETE = 3;
882     constexpr const uint32_t ACCOUNT_SWITCHED = 4;
883     constexpr const uint32_t ACCOUNT_UNLOCKED = 5;
884     auto ret = cloudServiceImpl_->OnUserChange(ACCOUNT_DEFAULT, "0", "test");
885     EXPECT_EQ(ret, GeneralError::E_OK);
886     ret = cloudServiceImpl_->OnUserChange(ACCOUNT_DELETE, "0", "test");
887     EXPECT_EQ(ret, GeneralError::E_OK);
888     ret = cloudServiceImpl_->OnUserChange(ACCOUNT_SWITCHED, "0", "test");
889     EXPECT_EQ(ret, GeneralError::E_OK);
890     ret = cloudServiceImpl_->OnUserChange(ACCOUNT_UNLOCKED, "0", "test");
891     EXPECT_EQ(ret, GeneralError::E_OK);
892 }
893 
894 /**
895 * @tc.name: DisableCloud
896 * @tc.desc:
897 * @tc.type: FUNC
898 * @tc.require:
899  */
900 HWTEST_F(CloudDataTest, DisableCloud001, TestSize.Level0)
901 {
902     auto ret = cloudServiceImpl_->DisableCloud("test");
903     EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
904     ret = cloudServiceImpl_->DisableCloud(TEST_CLOUD_ID);
905     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
906 }
907 
908 /**
909 * @tc.name: ChangeAppSwitch
910 * @tc.desc:
911 * @tc.type: FUNC
912 * @tc.require:
913  */
914 HWTEST_F(CloudDataTest, ChangeAppSwitch, TestSize.Level0)
915 {
916     std::string id = "testId";
917     std::string bundleName = "testName";
918     auto ret = cloudServiceImpl_->ChangeAppSwitch(id, bundleName, CloudData::CloudService::SWITCH_ON);
919     EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
920     ret = cloudServiceImpl_->ChangeAppSwitch(TEST_CLOUD_ID, bundleName, CloudData::CloudService::SWITCH_ON);
921     EXPECT_EQ(ret, CloudData::CloudService::INVALID_ARGUMENT);
922     ret = cloudServiceImpl_->ChangeAppSwitch(TEST_CLOUD_ID, TEST_CLOUD_BUNDLE, CloudData::CloudService::SWITCH_OFF);
923     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
924 }
925 
926 /**
927 * @tc.name: EnableCloud
928 * @tc.desc:
929 * @tc.type: FUNC
930 * @tc.require:
931  */
932 HWTEST_F(CloudDataTest, EnableCloud, TestSize.Level0)
933 {
934     std::string bundleName = "testName";
935     std::map<std::string, int32_t> switches;
936     switches.insert_or_assign(TEST_CLOUD_BUNDLE, CloudData::CloudService::SWITCH_ON);
937     switches.insert_or_assign(bundleName, CloudData::CloudService::SWITCH_ON);
938     auto ret = cloudServiceImpl_->EnableCloud(TEST_CLOUD_ID, switches);
939     EXPECT_EQ(ret, CloudData::CloudService::SUCCESS);
940 }
941 
942 /**
943 * @tc.name: OnEnableCloud
944 * @tc.desc:
945 * @tc.type: FUNC
946 * @tc.require:
947  */
948 HWTEST_F(CloudDataTest, OnEnableCloud, TestSize.Level0)
949 {
950     MessageParcel reply;
951     MessageParcel data;
952     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
953     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ENABLE_CLOUD, data, reply);
954     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
955     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
956     std::string id = "testId";
957     std::map<std::string, int32_t> switches;
958     ITypesUtil::Marshal(data, id, switches);
959     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ENABLE_CLOUD, data, reply);
960     EXPECT_EQ(ret, ERR_NONE);
961 }
962 
963 /**
964 * @tc.name: OnDisableCloud
965 * @tc.desc:
966 * @tc.type: FUNC
967 * @tc.require:
968  */
969 HWTEST_F(CloudDataTest, OnDisableCloud, TestSize.Level0)
970 {
971     MessageParcel reply;
972     MessageParcel data;
973     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
974     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_DISABLE_CLOUD, data, reply);
975     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
976     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
977     data.WriteString(TEST_CLOUD_ID);
978     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_DISABLE_CLOUD, data, reply);
979     EXPECT_EQ(ret, ERR_NONE);
980 }
981 
982 /**
983 * @tc.name: OnChangeAppSwitch
984 * @tc.desc:
985 * @tc.type: FUNC
986 * @tc.require:
987  */
988 HWTEST_F(CloudDataTest, OnChangeAppSwitch, TestSize.Level0)
989 {
990     MessageParcel reply;
991     MessageParcel data;
992     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
993     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_APP_SWITCH, data, reply);
994     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
995     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
996     data.WriteString(TEST_CLOUD_ID);
997     data.WriteString(TEST_CLOUD_BUNDLE);
998     data.WriteInt32(CloudData::CloudService::SWITCH_ON);
999     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_APP_SWITCH, data, reply);
1000     EXPECT_EQ(ret, ERR_NONE);
1001 }
1002 
1003 /**
1004 * @tc.name: OnClean
1005 * @tc.desc:
1006 * @tc.type: FUNC
1007 * @tc.require:
1008  */
1009 HWTEST_F(CloudDataTest, OnClean, TestSize.Level0)
1010 {
1011     MessageParcel reply;
1012     MessageParcel data;
1013     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1014     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CLEAN, data, reply);
1015     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1016     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1017     std::string id = TEST_CLOUD_ID;
1018     std::map<std::string, int32_t> actions;
1019     ITypesUtil::Marshal(data, id, actions);
1020     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CLEAN, data, reply);
1021     EXPECT_EQ(ret, ERR_NONE);
1022 }
1023 
1024 /**
1025 * @tc.name: OnNotifyDataChange
1026 * @tc.desc:
1027 * @tc.type: FUNC
1028 * @tc.require:
1029  */
1030 HWTEST_F(CloudDataTest, OnNotifyDataChange, TestSize.Level0)
1031 {
1032     MessageParcel reply;
1033     MessageParcel data;
1034     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1035     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE, data, reply);
1036     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1037     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1038     data.WriteString(TEST_CLOUD_ID);
1039     data.WriteString(TEST_CLOUD_BUNDLE);
1040     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE, data, reply);
1041     EXPECT_EQ(ret, ERR_NONE);
1042 }
1043 
1044 /**
1045 * @tc.name: OnNotifyChange
1046 * @tc.desc:
1047 * @tc.type: FUNC
1048 * @tc.require:
1049  */
1050 HWTEST_F(CloudDataTest, OnNotifyChange, TestSize.Level0)
1051 {
1052     MessageParcel reply;
1053     MessageParcel data;
1054     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1055     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE_EXT, data, reply);
1056     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1057     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1058     data.WriteString(TEST_CLOUD_ID);
1059     data.WriteString(TEST_CLOUD_BUNDLE);
1060     int32_t userId = 100;
1061     data.WriteInt32(userId);
1062     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_NOTIFY_DATA_CHANGE_EXT, data, reply);
1063     EXPECT_EQ(ret, ERR_NONE);
1064 }
1065 
1066 /**
1067 * @tc.name: OnQueryStatistics
1068 * @tc.desc:
1069 * @tc.type: FUNC
1070 * @tc.require:
1071  */
1072 HWTEST_F(CloudDataTest, OnQueryStatistics, TestSize.Level0)
1073 {
1074     MessageParcel reply;
1075     MessageParcel data;
1076     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1077     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_STATISTICS, data, reply);
1078     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1079     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1080     data.WriteString(TEST_CLOUD_ID);
1081     data.WriteString(TEST_CLOUD_BUNDLE);
1082     data.WriteString(TEST_CLOUD_STORE);
1083     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_STATISTICS, data, reply);
1084     EXPECT_EQ(ret, ERR_NONE);
1085 }
1086 
1087 /**
1088 * @tc.name: OnQueryLastSyncInfo
1089 * @tc.desc:
1090 * @tc.type: FUNC
1091 * @tc.require:
1092  */
1093 HWTEST_F(CloudDataTest, OnQueryLastSyncInfo, TestSize.Level0)
1094 {
1095     MessageParcel reply;
1096     MessageParcel data;
1097     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1098     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_LAST_SYNC_INFO, data, reply);
1099     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1100     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1101     data.WriteString(TEST_CLOUD_ID);
1102     data.WriteString(TEST_CLOUD_BUNDLE);
1103     data.WriteString(TEST_CLOUD_STORE);
1104     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_LAST_SYNC_INFO, data, reply);
1105     EXPECT_EQ(ret, ERR_NONE);
1106 }
1107 
1108 /**
1109 * @tc.name: OnSetGlobalCloudStrategy
1110 * @tc.desc:
1111 * @tc.type: FUNC
1112 * @tc.require:
1113  */
1114 HWTEST_F(CloudDataTest, OnSetGlobalCloudStrategy, TestSize.Level0)
1115 {
1116     MessageParcel reply;
1117     MessageParcel data;
1118     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1119     auto ret =
1120         cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_GLOBAL_CLOUD_STRATEGY, data, reply);
1121     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1122     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1123     uint32_t strategy = 0;
1124     std::vector<CommonType::Value> values;
1125     ITypesUtil::Marshal(data, strategy, values);
1126     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_GLOBAL_CLOUD_STRATEGY, data, reply);
1127     EXPECT_EQ(ret, ERR_NONE);
1128 }
1129 
1130 /**
1131 * @tc.name: OnAllocResourceAndShare
1132 * @tc.desc:
1133 * @tc.type: FUNC
1134 * @tc.require:
1135  */
1136 HWTEST_F(CloudDataTest, OnAllocResourceAndShare, TestSize.Level0)
1137 {
1138     MessageParcel reply;
1139     MessageParcel data;
1140     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1141     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ALLOC_RESOURCE_AND_SHARE, data, reply);
1142     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1143     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1144     std::string storeId = "storeId";
1145     DistributedRdb::PredicatesMemo predicates;
1146     std::vector<std::string> columns;
1147     std::vector<CloudData::Participant> participants;
1148     ITypesUtil::Marshal(data, storeId, predicates, columns, participants);
1149     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_ALLOC_RESOURCE_AND_SHARE, data, reply);
1150     EXPECT_EQ(ret, ERR_NONE);
1151 }
1152 
1153 /**
1154 * @tc.name: OnShare
1155 * @tc.desc:
1156 * @tc.type: FUNC
1157 * @tc.require:
1158  */
1159 HWTEST_F(CloudDataTest, OnShare, TestSize.Level0)
1160 {
1161     MessageParcel reply;
1162     MessageParcel data;
1163     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1164     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SHARE, data, reply);
1165     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1166     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1167     std::string sharingRes;
1168     CloudData::Participants participants;
1169     CloudData::Results results;
1170     ITypesUtil::Marshal(data, sharingRes, participants, results);
1171     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SHARE, data, reply);
1172     EXPECT_EQ(ret, ERR_NONE);
1173 }
1174 
1175 /**
1176 * @tc.name: OnUnshare
1177 * @tc.desc:
1178 * @tc.type: FUNC
1179 * @tc.require:
1180  */
1181 HWTEST_F(CloudDataTest, OnUnshare, TestSize.Level0)
1182 {
1183     MessageParcel reply;
1184     MessageParcel data;
1185     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1186     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_UNSHARE, data, reply);
1187     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1188     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1189     std::string sharingRes;
1190     CloudData::Participants participants;
1191     CloudData::Results results;
1192     ITypesUtil::Marshal(data, sharingRes, participants, results);
1193     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_UNSHARE, data, reply);
1194     EXPECT_EQ(ret, ERR_NONE);
1195 }
1196 
1197 /**
1198 * @tc.name: OnExit
1199 * @tc.desc:
1200 * @tc.type: FUNC
1201 * @tc.require:
1202  */
1203 HWTEST_F(CloudDataTest, OnExit, TestSize.Level0)
1204 {
1205     MessageParcel reply;
1206     MessageParcel data;
1207     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1208     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_EXIT, data, reply);
1209     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1210     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1211     std::string sharingRes;
1212     std::pair<int32_t, std::string> result;
1213     ITypesUtil::Marshal(data, sharingRes, result);
1214     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_EXIT, data, reply);
1215     EXPECT_EQ(ret, ERR_NONE);
1216 }
1217 
1218 /**
1219 * @tc.name: OnChangePrivilege
1220 * @tc.desc:
1221 * @tc.type: FUNC
1222 * @tc.require:
1223  */
1224 HWTEST_F(CloudDataTest, OnChangePrivilege, TestSize.Level0)
1225 {
1226     MessageParcel reply;
1227     MessageParcel data;
1228     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1229     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_PRIVILEGE, data, reply);
1230     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1231     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1232     std::string sharingRes;
1233     CloudData::Participants participants;
1234     CloudData::Results results;
1235     ITypesUtil::Marshal(data, sharingRes, participants, results);
1236     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_PRIVILEGE, data, reply);
1237     EXPECT_EQ(ret, ERR_NONE);
1238 }
1239 
1240 /**
1241 * @tc.name: OnQuery
1242 * @tc.desc:
1243 * @tc.type: FUNC
1244 * @tc.require:
1245  */
1246 HWTEST_F(CloudDataTest, OnQuery, TestSize.Level0)
1247 {
1248     MessageParcel reply;
1249     MessageParcel data;
1250     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1251     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY, data, reply);
1252     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1253     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1254     std::string sharingRes;
1255     CloudData::QueryResults results;
1256     ITypesUtil::Marshal(data, sharingRes, results);
1257     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY, data, reply);
1258     EXPECT_EQ(ret, ERR_NONE);
1259 }
1260 
1261 /**
1262 * @tc.name: OnQueryByInvitation
1263 * @tc.desc:
1264 * @tc.type: FUNC
1265 * @tc.require:
1266  */
1267 HWTEST_F(CloudDataTest, OnQueryByInvitation, TestSize.Level0)
1268 {
1269     MessageParcel reply;
1270     MessageParcel data;
1271     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1272     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_BY_INVITATION, data, reply);
1273     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1274     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1275     std::string invitation;
1276     CloudData::QueryResults results;
1277     ITypesUtil::Marshal(data, invitation, results);
1278     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_QUERY_BY_INVITATION, data, reply);
1279     EXPECT_EQ(ret, ERR_NONE);
1280 }
1281 
1282 /**
1283 * @tc.name: OnConfirmInvitation
1284 * @tc.desc:
1285 * @tc.type: FUNC
1286 * @tc.require:
1287  */
1288 HWTEST_F(CloudDataTest, OnConfirmInvitation, TestSize.Level0)
1289 {
1290     MessageParcel reply;
1291     MessageParcel data;
1292     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1293     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CONFIRM_INVITATION, data, reply);
1294     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1295     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1296     std::string invitation;
1297     int32_t confirmation = 0;
1298     std::tuple<int32_t, std::string, std::string> result;
1299     ITypesUtil::Marshal(data, invitation, confirmation, result);
1300     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CONFIRM_INVITATION, data, reply);
1301     EXPECT_EQ(ret, ERR_NONE);
1302 }
1303 
1304 /**
1305 * @tc.name: OnChangeConfirmation
1306 * @tc.desc:
1307 * @tc.type: FUNC
1308 * @tc.require:
1309  */
1310 HWTEST_F(CloudDataTest, OnChangeConfirmation, TestSize.Level0)
1311 {
1312     MessageParcel reply;
1313     MessageParcel data;
1314     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1315     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_CONFIRMATION, data, reply);
1316     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1317     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1318     std::string sharingRes;
1319     int32_t confirmation = 0;
1320     std::pair<int32_t, std::string> result;
1321     ITypesUtil::Marshal(data, sharingRes, confirmation, result);
1322     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_CHANGE_CONFIRMATION, data, reply);
1323     EXPECT_EQ(ret, ERR_NONE);
1324 }
1325 
1326 /**
1327 * @tc.name: OnSetCloudStrategy
1328 * @tc.desc:
1329 * @tc.type: FUNC
1330 * @tc.require:
1331  */
1332 HWTEST_F(CloudDataTest, OnSetCloudStrategy, TestSize.Level0)
1333 {
1334     MessageParcel reply;
1335     MessageParcel data;
1336     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1337     auto ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_CLOUD_STRATEGY, data, reply);
1338     EXPECT_EQ(ret, IPC_STUB_INVALID_DATA_ERR);
1339     data.WriteInterfaceToken(cloudServiceImpl_->GetDescriptor());
1340     uint32_t strategy = 0;
1341     std::vector<CommonType::Value> values;
1342     ITypesUtil::Marshal(data, strategy, values);
1343     ret = cloudServiceImpl_->OnRemoteRequest(CloudData::CloudService::TRANS_SET_CLOUD_STRATEGY, data, reply);
1344     EXPECT_EQ(ret, ERR_NONE);
1345 }
1346 
1347 /**
1348 * @tc.name: SharingUtil001
1349 * @tc.desc:
1350 * @tc.type: FUNC
1351 * @tc.require:
1352  */
1353 HWTEST_F(CloudDataTest, SharingUtil001, TestSize.Level0)
1354 {
1355     auto cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_UNKNOWN);
1356     EXPECT_EQ(cfm, SharingCfm::CFM_UNKNOWN);
1357     cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_ACCEPTED);
1358     EXPECT_EQ(cfm, SharingCfm::CFM_ACCEPTED);
1359     cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_REJECTED);
1360     EXPECT_EQ(cfm, SharingCfm::CFM_REJECTED);
1361     cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_SUSPENDED);
1362     EXPECT_EQ(cfm, SharingCfm::CFM_SUSPENDED);
1363     cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_UNAVAILABLE);
1364     EXPECT_EQ(cfm, SharingCfm::CFM_UNAVAILABLE);
1365     cfm = CloudData::SharingUtil::Convert(Confirmation::CFM_BUTT);
1366     EXPECT_EQ(cfm, SharingCfm::CFM_UNKNOWN);
1367 }
1368 
1369 /**
1370 * @tc.name: SharingUtil002
1371 * @tc.desc:
1372 * @tc.type: FUNC
1373 * @tc.require:
1374  */
1375 HWTEST_F(CloudDataTest, SharingUtil002, TestSize.Level0)
1376 {
1377     auto cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_UNKNOWN);
1378     EXPECT_EQ(cfm, Confirmation::CFM_UNKNOWN);
1379     cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_ACCEPTED);
1380     EXPECT_EQ(cfm, Confirmation::CFM_ACCEPTED);
1381     cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_REJECTED);
1382     EXPECT_EQ(cfm, Confirmation::CFM_REJECTED);
1383     cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_SUSPENDED);
1384     EXPECT_EQ(cfm, Confirmation::CFM_SUSPENDED);
1385     cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_UNAVAILABLE);
1386     EXPECT_EQ(cfm, Confirmation::CFM_UNAVAILABLE);
1387     cfm = CloudData::SharingUtil::Convert(SharingCfm::CFM_BUTT);
1388     EXPECT_EQ(cfm, Confirmation::CFM_UNKNOWN);
1389 }
1390 
1391 /**
1392 * @tc.name: SharingUtil003
1393 * @tc.desc:
1394 * @tc.type: FUNC
1395 * @tc.require:
1396  */
1397 HWTEST_F(CloudDataTest, SharingUtil003, TestSize.Level0)
1398 {
1399     auto status = CloudData::SharingUtil::Convert(CenterCode::IPC_ERROR);
1400     EXPECT_EQ(status, Status::IPC_ERROR);
1401     status = CloudData::SharingUtil::Convert(CenterCode::NOT_SUPPORT);
1402     EXPECT_EQ(status, Status::SUCCESS);
1403 }
1404 
1405 /**
1406 * @tc.name: SharingUtil004
1407 * @tc.desc:
1408 * @tc.type: FUNC
1409 * @tc.require:
1410  */
1411 HWTEST_F(CloudDataTest, SharingUtil004, TestSize.Level0)
1412 {
1413     auto status = CloudData::SharingUtil::Convert(GenErr::E_OK);
1414     EXPECT_EQ(status, Status::SUCCESS);
1415     status = CloudData::SharingUtil::Convert(GenErr::E_ERROR);
1416     EXPECT_EQ(status, Status::ERROR);
1417     status = CloudData::SharingUtil::Convert(GenErr::E_INVALID_ARGS);
1418     EXPECT_EQ(status, Status::INVALID_ARGUMENT);
1419     status = CloudData::SharingUtil::Convert(GenErr::E_BLOCKED_BY_NETWORK_STRATEGY);
1420     EXPECT_EQ(status, Status::STRATEGY_BLOCKING);
1421     status = CloudData::SharingUtil::Convert(GenErr::E_CLOUD_DISABLED);
1422     EXPECT_EQ(status, Status::CLOUD_DISABLE);
1423     status = CloudData::SharingUtil::Convert(GenErr::E_NETWORK_ERROR);
1424     EXPECT_EQ(status, Status::NETWORK_ERROR);
1425     status = CloudData::SharingUtil::Convert(GenErr::E_BUSY);
1426     EXPECT_EQ(status, Status::ERROR);
1427 }
1428 
1429 /**
1430 * @tc.name: DoCloudSync
1431 * @tc.desc: Test the executor_ uninitialized and initialized scenarios
1432 * @tc.type: FUNC
1433 * @tc.require:
1434  */
1435 HWTEST_F(CloudDataTest, DoCloudSync, TestSize.Level0)
1436 {
1437     int32_t user = 100;
1438     CloudData::SyncManager sync;
1439     CloudData::SyncManager::SyncInfo info(user);
1440     auto ret = sync.DoCloudSync(info);
1441     EXPECT_EQ(ret, GenErr::E_NOT_INIT);
1442     ret = sync.StopCloudSync(user);
1443     EXPECT_EQ(ret, GenErr::E_NOT_INIT);
1444     size_t max = 12;
1445     size_t min = 5;
1446     sync.executor_ = std::make_shared<ExecutorPool>(max, min);
1447     ret = sync.DoCloudSync(info);
1448     EXPECT_EQ(ret, GenErr::E_OK);
1449     int32_t invalidUser = -1;
1450     sync.StopCloudSync(invalidUser);
1451     ret = sync.StopCloudSync(user);
1452     EXPECT_EQ(ret, GenErr::E_OK);
1453 }
1454 
1455 /**
1456 * @tc.name: GetPostEventTask
1457 * @tc.desc: Test the interface to verify the package name and table name
1458 * @tc.type: FUNC
1459 * @tc.require:
1460  */
1461 HWTEST_F(CloudDataTest, GetPostEventTask, TestSize.Level0)
1462 {
1463     std::vector<SchemaMeta> schemas;
1464     schemaMeta_.databases[0].name = "test";
1465     schemas.push_back(schemaMeta_);
1466     schemaMeta_.bundleName = "test";
1467     schemas.push_back(schemaMeta_);
1468 
1469     int32_t user = 100;
1470     CloudData::SyncManager::SyncInfo info(user);
1471     std::vector<std::string> value;
1472     info.tables_.insert_or_assign(TEST_CLOUD_STORE, value);
1473 
1474     CloudData::SyncManager sync;
1475     std::map<std::string, std::string> traceIds;
1476     auto task = sync.GetPostEventTask(schemas, cloudInfo_, info, true, traceIds);
1477     task();
1478     EXPECT_TRUE(sync.lastSyncInfos_.Empty());
1479 }
1480 
1481 /**
1482 * @tc.name: GetRetryer
1483 * @tc.desc: Test the input parameters of different interfaces
1484 * @tc.type: FUNC
1485 * @tc.require:
1486  */
1487 HWTEST_F(CloudDataTest, GetRetryer, TestSize.Level0)
1488 {
1489     int32_t user = 100;
1490     CloudData::SyncManager::SyncInfo info(user);
1491     CloudData::SyncManager sync;
1492     CloudData::SyncManager::Duration duration;
1493     std::string prepareTraceId;
1494     auto ret = sync.GetRetryer(CloudData::SyncManager::RETRY_TIMES, info, user)(duration, E_OK, E_OK, prepareTraceId);
1495     EXPECT_TRUE(ret);
1496     ret = sync.GetRetryer(CloudData::SyncManager::RETRY_TIMES, info, user)(duration, E_SYNC_TASK_MERGED,
1497         E_SYNC_TASK_MERGED, prepareTraceId);
1498     EXPECT_TRUE(ret);
1499     ret = sync.GetRetryer(0, info, user)(duration, E_OK, E_OK, prepareTraceId);
1500     EXPECT_TRUE(ret);
1501     ret = sync.GetRetryer(0, info, user)(duration, E_SYNC_TASK_MERGED, E_SYNC_TASK_MERGED, prepareTraceId);
1502     EXPECT_TRUE(ret);
1503 }
1504 
1505 /**
1506 * @tc.name: GetCallback
1507 * @tc.desc: Test the processing logic of different progress callbacks
1508 * @tc.type: FUNC
1509 * @tc.require:
1510  */
1511 HWTEST_F(CloudDataTest, GetCallback, TestSize.Level0)
1512 {
1513     int32_t user = 100;
1514     CloudData::SyncManager::SyncInfo info(user);
1515     CloudData::SyncManager sync;
1516     DistributedData::GenDetails result;
1517     StoreInfo storeInfo;
1518     storeInfo.user = user;
1519     storeInfo.bundleName = "testBundleName";
1520     int32_t triggerMode = MODE_DEFAULT;
1521     std::string prepareTraceId;
1522     GenAsync async = nullptr;
1523     sync.GetCallback(async, storeInfo, triggerMode, prepareTraceId, user)(result);
1524     int32_t process = 0;
__anon0b1436170502(const GenDetails &details) 1525     async = [&process](const GenDetails &details) { process = details.begin()->second.progress; };
1526     GenProgressDetail detail;
1527     detail.progress = GenProgress::SYNC_IN_PROGRESS;
1528     result.insert_or_assign("test", detail);
1529     sync.GetCallback(async, storeInfo, triggerMode, prepareTraceId, user)(result);
1530     EXPECT_EQ(process, GenProgress::SYNC_IN_PROGRESS);
1531     detail.progress = GenProgress::SYNC_FINISH;
1532     result.insert_or_assign("test", detail);
1533     storeInfo.user = -1;
1534     sync.GetCallback(async, storeInfo, triggerMode, prepareTraceId, user)(result);
1535     storeInfo.user = user;
1536     sync.GetCallback(async, storeInfo, triggerMode, prepareTraceId, user)(result);
1537     EXPECT_EQ(process, GenProgress::SYNC_FINISH);
1538 }
1539 
1540 /**
1541 * @tc.name: GetInterval
1542 * @tc.desc: Test the Interval transformation logic of the interface
1543 * @tc.type: FUNC
1544 * @tc.require:
1545  */
1546 HWTEST_F(CloudDataTest, GetInterval, TestSize.Level0)
1547 {
1548     CloudData::SyncManager sync;
1549 
1550     auto ret = sync.GetInterval(E_LOCKED_BY_OTHERS);
1551     EXPECT_EQ(ret, CloudData::SyncManager::LOCKED_INTERVAL);
1552     ret = sync.GetInterval(E_BUSY);
1553     EXPECT_EQ(ret, CloudData::SyncManager::BUSY_INTERVAL);
1554     ret = sync.GetInterval(E_OK);
1555     EXPECT_EQ(ret, CloudData::SyncManager::RETRY_INTERVAL);
1556 }
1557 
1558 /**
1559 * @tc.name: GetCloudSyncInfo
1560 * @tc.desc: Test get cloudInfo
1561 * @tc.type: FUNC
1562 * @tc.require:
1563  */
1564 HWTEST_F(CloudDataTest, GetCloudSyncInfo, TestSize.Level0)
1565 {
1566     CloudData::SyncManager sync;
1567     CloudInfo cloud;
1568     cloud.user = cloudInfo_.user;
1569     cloud.enableCloud = false;
1570     CloudData::SyncManager::SyncInfo info(cloudInfo_.user);
1571     MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
1572     info.bundleName_ = "test";
1573     auto ret = sync.GetCloudSyncInfo(info, cloud);
1574     EXPECT_TRUE(!ret.empty());
1575 }
1576 
1577 /**
1578 * @tc.name: RetryCallback
1579 * @tc.desc: Test the retry logic
1580 * @tc.type: FUNC
1581 * @tc.require:
1582  */
1583 HWTEST_F(CloudDataTest, RetryCallback, TestSize.Level0)
1584 {
1585     int32_t user = 100;
1586     std::string prepareTraceId;
1587     CloudData::SyncManager sync;
1588     StoreInfo storeInfo;
1589     int32_t retCode = -1;
1590     CloudData::SyncManager::Retryer retry = [&retCode](CloudData::SyncManager::Duration interval, int32_t code,
__anon0b1436170602(CloudData::SyncManager::Duration interval, int32_t code, int32_t dbCode, const std::string &prepareTraceId) 1591                                                 int32_t dbCode, const std::string &prepareTraceId) {
1592         retCode = code;
1593         return true;
1594     };
1595     DistributedData::GenDetails result;
1596     auto task = sync.RetryCallback(storeInfo, retry, MODE_DEFAULT, prepareTraceId, user);
1597     task(result);
1598     GenProgressDetail detail;
1599     detail.progress = GenProgress::SYNC_IN_PROGRESS;
1600     detail.code = 100;
1601     result.insert_or_assign("test", detail);
1602     task = sync.RetryCallback(storeInfo, retry, MODE_DEFAULT, prepareTraceId, user);
1603     task(result);
1604     EXPECT_EQ(retCode, detail.code);
1605 }
1606 
1607 /**
1608 * @tc.name: UpdateCloudInfoFromServer
1609 * @tc.desc: Test updating cloudinfo from the server
1610 * @tc.type: FUNC
1611 * @tc.require:
1612  */
1613 HWTEST_F(CloudDataTest, UpdateCloudInfoFromServer, TestSize.Level0)
1614 {
1615     auto ret = cloudServiceImpl_->UpdateCloudInfoFromServer(cloudInfo_.user);
1616     EXPECT_EQ(ret, E_OK);
1617 }
1618 
1619 /**
1620 * @tc.name: GetCloudInfo
1621 * @tc.desc: Test get cloudInfo
1622 * @tc.type: FUNC
1623 * @tc.require:
1624  */
1625 HWTEST_F(CloudDataTest, GetCloudInfo, TestSize.Level0)
1626 {
1627     MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
1628     auto ret = cloudServiceImpl_->GetCloudInfo(cloudInfo_.user);
1629     EXPECT_EQ(ret.first, CloudData::SUCCESS);
1630 }
1631 
1632 /**
1633 * @tc.name: SubTask
1634 * @tc.desc: Test the subtask execution logic
1635 * @tc.type: FUNC
1636 * @tc.require:
1637  */
1638 HWTEST_F(CloudDataTest, SubTask, TestSize.Level0)
1639 {
1640     DistributedData::Subscription sub;
1641     cloudServiceImpl_->InitSubTask(sub, 0);
1642     MetaDataManager::GetInstance().LoadMeta(Subscription::GetKey(cloudInfo_.user), sub, true);
1643     cloudServiceImpl_->InitSubTask(sub, 0);
1644     int32_t userId = 0;
__anon0b1436170702() 1645     CloudData::CloudServiceImpl::Task task = [&userId]() { userId = cloudInfo_.user; };
1646     cloudServiceImpl_->GenSubTask(task, cloudInfo_.user)();
1647     EXPECT_EQ(userId, cloudInfo_.user);
1648 }
1649 
1650 /**
1651 * @tc.name: ConvertCursor
1652 * @tc.desc: Test the cursor conversion logic when the ResultSet is empty and non-null
1653 * @tc.type: FUNC
1654 * @tc.require:
1655  */
1656 HWTEST_F(CloudDataTest, ConvertCursor, TestSize.Level0)
1657 {
1658     std::map<std::string, DistributedData::Value> entry;
1659     entry.insert_or_assign("test", "entry");
1660     auto resultSet = std::make_shared<CursorMock::ResultSet>(1, entry);
1661     auto cursor = std::make_shared<CursorMock>(resultSet);
1662     auto result = cloudServiceImpl_->ConvertCursor(cursor);
1663     EXPECT_TRUE(!result.empty());
1664     auto resultSet1 = std::make_shared<CursorMock::ResultSet>();
1665     auto cursor1 = std::make_shared<CursorMock>(resultSet1);
1666     auto result1 = cloudServiceImpl_->ConvertCursor(cursor1);
1667     EXPECT_TRUE(result1.empty());
1668 }
1669 
1670 /**
1671 * @tc.name: GetDbInfoFromExtraData
1672 * @tc.desc: Test the GetDbInfoFromExtraData function input parameters of different parameters
1673 * @tc.type: FUNC
1674 * @tc.require:
1675  */
1676 HWTEST_F(CloudDataTest, GetDbInfoFromExtraData, TestSize.Level0)
1677 {
1678     SchemaMeta::Database database;
1679     database.name = TEST_CLOUD_STORE;
1680     database.alias = TEST_CLOUD_DATABASE_ALIAS_1;
1681 
1682     SchemaMeta schemaMeta;
1683     schemaMeta.databases.push_back(database);
1684 
1685     SchemaMeta::Table table;
1686     table.name = "test_cloud_table_name";
1687     table.alias = "test_cloud_table_alias";
1688     database.tables.push_back(table);
1689     SchemaMeta::Table table1;
1690     table1.name = "test_cloud_table_name1";
1691     table1.alias = "test_cloud_table_alias1";
1692     table1.sharedTableName = "test_share_table_name1";
1693     database.tables.emplace_back(table1);
1694 
1695     database.alias = TEST_CLOUD_DATABASE_ALIAS_2;
1696     schemaMeta.databases.push_back(database);
1697 
1698     ExtraData extraData;
1699     extraData.info.containerName = TEST_CLOUD_DATABASE_ALIAS_2;
1700     auto result = cloudServiceImpl_->GetDbInfoFromExtraData(extraData, schemaMeta);
1701     EXPECT_EQ(result.begin()->first, TEST_CLOUD_STORE);
1702 
1703     std::string tableName = "test_cloud_table_alias2";
1704     extraData.info.tables.emplace_back(tableName);
1705     result = cloudServiceImpl_->GetDbInfoFromExtraData(extraData, schemaMeta);
1706     EXPECT_EQ(result.begin()->first, TEST_CLOUD_STORE);
1707 
1708     std::string tableName1 = "test_cloud_table_alias1";
1709     extraData.info.tables.emplace_back(tableName1);
1710     extraData.info.scopes.emplace_back(DistributedData::ExtraData::SHARED_TABLE);
1711     result = cloudServiceImpl_->GetDbInfoFromExtraData(extraData, schemaMeta);
1712     EXPECT_EQ(result.begin()->first, TEST_CLOUD_STORE);
1713 }
1714 
1715 /**
1716 * @tc.name: QueryTableStatistic
1717 * @tc.desc: Test the QueryTableStatistic function input parameters of different parameters
1718 * @tc.type: FUNC
1719 * @tc.require:
1720  */
1721 HWTEST_F(CloudDataTest, QueryTableStatistic, TestSize.Level0)
1722 {
1723     auto store = std::make_shared<GeneralStoreMock>();
1724     if (store != nullptr) {
1725         std::map<std::string, Value> entry = { { "inserted", "TEST" }, { "updated", "TEST" }, { "normal", "TEST" } };
1726         store->MakeCursor(entry);
1727     }
1728     auto [ret, result] = cloudServiceImpl_->QueryTableStatistic("test", store);
1729     EXPECT_TRUE(ret);
1730     if (store != nullptr) {
1731         std::map<std::string, Value> entry = { { "Test", 1 } };
1732         store->MakeCursor(entry);
1733     }
1734     std::tie(ret, result) = cloudServiceImpl_->QueryTableStatistic("test", store);
1735     EXPECT_TRUE(ret);
1736 
1737     if (store != nullptr) {
1738         store->cursor_ = nullptr;
1739     }
1740     std::tie(ret, result) = cloudServiceImpl_->QueryTableStatistic("test", store);
1741     EXPECT_FALSE(ret);
1742 }
1743 
1744 /**
1745 * @tc.name: GetSchemaMeta
1746 * @tc.desc: Test the GetSchemaMeta function input parameters of different parameters
1747 * @tc.type: FUNC
1748 * @tc.require:
1749  */
1750 HWTEST_F(CloudDataTest, GetSchemaMeta, TestSize.Level0)
1751 {
1752     int32_t userId = 101;
1753     int32_t instanceId = 0;
1754     CloudInfo cloudInfo;
1755     cloudInfo.user = userId;
1756     cloudInfo.id = TEST_CLOUD_ID;
1757     cloudInfo.enableCloud = true;
1758 
1759     CloudInfo::AppInfo appInfo;
1760     appInfo.bundleName = TEST_CLOUD_BUNDLE;
1761     appInfo.appId = TEST_CLOUD_APPID;
1762     appInfo.version = 1;
1763     appInfo.cloudSwitch = true;
1764 
1765     cloudInfo.apps[TEST_CLOUD_BUNDLE] = std::move(appInfo);
1766     MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true);
1767     std::string bundleName = "testName";
1768     auto [status, meta] = cloudServiceImpl_->GetSchemaMeta(userId, bundleName, instanceId);
1769     EXPECT_EQ(status, CloudData::CloudService::ERROR);
1770     bundleName = TEST_CLOUD_BUNDLE;
1771     DistributedData::SchemaMeta schemeMeta;
1772     schemeMeta.bundleName = TEST_CLOUD_BUNDLE;
1773     schemeMeta.metaVersion = DistributedData::SchemaMeta::CURRENT_VERSION + 1;
1774     MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE, instanceId), schemeMeta, true);
1775     std::tie(status, meta) = cloudServiceImpl_->GetSchemaMeta(userId, bundleName, instanceId);
1776     EXPECT_EQ(status, CloudData::CloudService::ERROR);
1777     schemeMeta.metaVersion = DistributedData::SchemaMeta::CURRENT_VERSION;
1778     MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE, instanceId), schemeMeta, true);
1779     std::tie(status, meta) = cloudServiceImpl_->GetSchemaMeta(userId, bundleName, instanceId);
1780     EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
1781     EXPECT_EQ(meta.metaVersion, DistributedData::SchemaMeta::CURRENT_VERSION);
1782     MetaDataManager::GetInstance().DelMeta(cloudInfo.GetSchemaKey(TEST_CLOUD_BUNDLE, instanceId), true);
1783     MetaDataManager::GetInstance().DelMeta(cloudInfo.GetKey(), true);
1784 }
1785 
1786 /**
1787 * @tc.name: GetAppSchemaFromServer
1788 * @tc.desc: Test the GetAppSchemaFromServer function input parameters of different parameters
1789 * @tc.type: FUNC
1790 * @tc.require:
1791  */
1792 HWTEST_F(CloudDataTest, GetAppSchemaFromServer, TestSize.Level0)
1793 {
1794     int32_t userId = CloudServerMock::INVALID_USER_ID;
1795     std::string bundleName;
1796     DeviceManagerAdapter::GetInstance().SetNet(DeviceManagerAdapter::NONE);
1797     DeviceManagerAdapter::GetInstance().expireTime_ =
1798         std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch())
1799             .count() +
1800         1000;
1801     auto [status, meta] = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
1802     EXPECT_EQ(status, CloudData::CloudService::NETWORK_ERROR);
1803     DeviceManagerAdapter::GetInstance().SetNet(DeviceManagerAdapter::WIFI);
1804     std::tie(status, meta) = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
1805     EXPECT_EQ(status, CloudData::CloudService::SCHEMA_INVALID);
1806     userId = 100;
1807     std::tie(status, meta) = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
1808     EXPECT_EQ(status, CloudData::CloudService::SCHEMA_INVALID);
1809     bundleName = TEST_CLOUD_BUNDLE;
1810     std::tie(status, meta) = cloudServiceImpl_->GetAppSchemaFromServer(userId, bundleName);
1811     EXPECT_EQ(status, CloudData::CloudService::SUCCESS);
1812     EXPECT_EQ(meta.bundleName, schemaMeta_.bundleName);
1813 }
1814 
1815 /**
1816 * @tc.name: OnAppUninstall
1817 * @tc.desc: Test the OnAppUninstall function delete the subscription data
1818 * @tc.type: FUNC
1819 * @tc.require:
1820  */
1821 HWTEST_F(CloudDataTest, OnAppUninstall, TestSize.Level0)
1822 {
1823     ZLOGI("weisx test OnAppUninstall 111");
1824     CloudData::CloudServiceImpl::CloudStatic cloudStatic;
1825     int32_t userId = 1001;
1826     Subscription sub;
1827     sub.expiresTime.insert_or_assign(TEST_CLOUD_BUNDLE, 0);
1828     MetaDataManager::GetInstance().SaveMeta(Subscription::GetKey(userId), sub, true);
1829     CloudInfo cloudInfo;
1830     cloudInfo.user = userId;
1831     CloudInfo::AppInfo appInfo;
1832     cloudInfo.apps.insert_or_assign(TEST_CLOUD_BUNDLE, appInfo);
1833     MetaDataManager::GetInstance().SaveMeta(cloudInfo.GetKey(), cloudInfo, true);
1834     int32_t index = 1;
1835     auto ret = cloudStatic.OnAppUninstall(TEST_CLOUD_BUNDLE, userId, index);
1836     EXPECT_EQ(ret, E_OK);
1837     Subscription sub1;
1838     EXPECT_TRUE(MetaDataManager::GetInstance().LoadMeta(Subscription::GetKey(userId), sub1, true));
1839     EXPECT_EQ(sub1.expiresTime.size(), 0);
1840 }
1841 
1842 /**
1843 * @tc.name: GetCloudInfo
1844 * @tc.desc: Test the GetCloudInfo with invalid parameters
1845 * @tc.type: FUNC
1846 * @tc.require:
1847  */
1848 HWTEST_F(CloudDataTest, GetCloudInfo001, TestSize.Level0)
1849 {
1850     ZLOGI("weisx test OnAppUninstall 111");
1851     int32_t userId = 1000;
1852     auto [status, cloudInfo] = cloudServiceImpl_->GetCloudInfo(userId);
1853     EXPECT_EQ(status, CloudData::CloudService::ERROR);
1854     DeviceManagerAdapter::GetInstance().SetNet(DeviceManagerAdapter::NONE);
1855     DeviceManagerAdapter::GetInstance().expireTime_ =
1856         std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now().time_since_epoch())
1857             .count() +
1858         1000;
1859     MetaDataManager::GetInstance().DelMeta(cloudInfo_.GetKey(), true);
1860     std::tie(status, cloudInfo) = cloudServiceImpl_->GetCloudInfo(cloudInfo_.user);
1861     EXPECT_EQ(status, CloudData::CloudService::NETWORK_ERROR);
1862     DeviceManagerAdapter::GetInstance().SetNet(DeviceManagerAdapter::WIFI);
1863 }
1864 
1865 /**
1866 * @tc.name: PreShare
1867 * @tc.desc: Test the PreShare with invalid parameters
1868 * @tc.type: FUNC
1869 * @tc.require:
1870  */
1871 HWTEST_F(CloudDataTest, PreShare, TestSize.Level0)
1872 {
1873     int32_t userId = 1000;
1874     StoreInfo info;
1875     info.instanceId = 0;
1876     info.bundleName = TEST_CLOUD_BUNDLE;
1877     info.storeName = TEST_CLOUD_BUNDLE;
1878     info.user = userId;
1879     StoreMetaData meta(info);
1880     meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
1881     MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true);
1882     DistributedRdb::RdbQuery query;
1883     auto [status, cursor] = cloudServiceImpl_->PreShare(info, query);
1884     EXPECT_EQ(status, GeneralError::E_ERROR);
1885 }
1886 
1887 /**
1888 * @tc.name: InitSubTask
1889 * @tc.desc: Test the InitSubTask with invalid parameters
1890 * @tc.type: FUNC
1891 * @tc.require:
1892  */
1893 HWTEST_F(CloudDataTest, InitSubTask, TestSize.Level0)
1894 {
1895     uint64_t minInterval = 0;
1896     uint64_t expire = 24 * 60 * 60 * 1000; // 24hours, ms
1897     ExecutorPool::TaskId taskId = 100;
1898     Subscription sub;
1899     sub.expiresTime.insert_or_assign(TEST_CLOUD_BUNDLE, expire);
1900     std::shared_ptr<ExecutorPool> executor = std::move(cloudServiceImpl_->executor_);
1901     cloudServiceImpl_->executor_ = nullptr;
1902     cloudServiceImpl_->InitSubTask(sub, minInterval);
1903     EXPECT_EQ(sub.GetMinExpireTime(), expire);
1904     cloudServiceImpl_->executor_ = std::move(executor);
1905     cloudServiceImpl_->subTask_ = taskId;
1906     cloudServiceImpl_->InitSubTask(sub, minInterval);
1907     EXPECT_NE(cloudServiceImpl_->subTask_, taskId);
1908     cloudServiceImpl_->subTask_ = taskId;
1909     cloudServiceImpl_->expireTime_ = 0;
1910     cloudServiceImpl_->InitSubTask(sub, minInterval);
1911     EXPECT_EQ(cloudServiceImpl_->subTask_, taskId);
1912     cloudServiceImpl_->subTask_ = ExecutorPool::INVALID_TASK_ID;
1913     cloudServiceImpl_->InitSubTask(sub, minInterval);
1914     EXPECT_NE(cloudServiceImpl_->subTask_, ExecutorPool::INVALID_TASK_ID);
1915 }
1916 } // namespace DistributedDataTest
1917 } // namespace OHOS::Test