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