1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "cloud_sync_service.h"
19 #include "cloud_sync_common.h"
20 #include "dfs_error.h"
21 #include "service_callback_mock.h"
22 #include "utils_log.h"
23 #include "i_cloud_download_callback_mock.h"
24
25 namespace OHOS {
26 namespace FileManagement::CloudSync {
27 namespace Test {
28 using namespace testing::ext;
29 using namespace std;
30
31 std::shared_ptr<CloudSyncService> g_servicePtr_;
32
33 class CloudSyncServiceTest : public testing::Test {
34 public:
35 static void SetUpTestCase(void);
36 static void TearDownTestCase(void);
37 void SetUp();
38 void TearDown();
39 };
40
SetUpTestCase(void)41 void CloudSyncServiceTest::SetUpTestCase(void)
42 {
43 if (g_servicePtr_ == nullptr) {
44 int32_t saId = 5204;
45 g_servicePtr_ = std::make_shared<CloudSyncService>(saId);
46 ASSERT_TRUE(g_servicePtr_ != nullptr) << "SystemAbility failed";
47 }
48 std::cout << "SetUpTestCase" << std::endl;
49 g_servicePtr_->dataSyncManager_ = make_shared<CloudFile::DataSyncManager>();
50 }
51
TearDownTestCase(void)52 void CloudSyncServiceTest::TearDownTestCase(void)
53 {
54 std::cout << "TearDownTestCase" << std::endl;
55 }
56
SetUp(void)57 void CloudSyncServiceTest::SetUp(void)
58 {
59 std::cout << "SetUp" << std::endl;
60 }
61
TearDown(void)62 void CloudSyncServiceTest::TearDown(void)
63 {
64 std::cout << "TearDown" << std::endl;
65 }
66
67 /**
68 * @tc.name:GetHmdfsPathTest001
69 * @tc.desc:Verify the GetHmdfsPath function.
70 * @tc.type:FUNC
71 * @tc.require: I6H5MH
72 */
73 HWTEST_F(CloudSyncServiceTest, GetHmdfsPathTest001, TestSize.Level1)
74 {
75 GTEST_LOG_(INFO) << "GetHmdfsPathTest001 start";
76 try {
77 std::string uri = "";
78 int32_t userId = 100;
79 std::string ret = g_servicePtr_->GetHmdfsPath(uri, userId);
80 EXPECT_EQ(ret, "");
81 } catch (...) {
82 EXPECT_TRUE(false);
83 GTEST_LOG_(INFO) << "GetHmdfsPathTest001 FAILED";
84 }
85 GTEST_LOG_(INFO) << "GetHmdfsPathTest001 end";
86 }
87
88 /**
89 * @tc.name:GetHmdfsPathTest002
90 * @tc.desc:Verify the GetHmdfsPath function.
91 * @tc.type:FUNC
92 * @tc.require: I6H5MH
93 */
94 HWTEST_F(CloudSyncServiceTest, GetHmdfsPathTest002, TestSize.Level1)
95 {
96 GTEST_LOG_(INFO) << "GetHmdfsPathTest002 start";
97 try {
98 std::string uri = "invaild_uri";
99 int32_t userId = 100;
100 std::string ret = g_servicePtr_->GetHmdfsPath(uri, userId);
101 EXPECT_EQ(ret, "");
102 } catch (...) {
103 EXPECT_TRUE(false);
104 GTEST_LOG_(INFO) << "GetHmdfsPathTest002 FAILED";
105 }
106 GTEST_LOG_(INFO) << "GetHmdfsPathTest002 end";
107 }
108
109 /**
110 * @tc.name:GetHmdfsPathTest003
111 * @tc.desc:Verify the GetHmdfsPath function.
112 * @tc.type:FUNC
113 * @tc.require: I6H5MH
114 */
115 HWTEST_F(CloudSyncServiceTest, GetHmdfsPathTest003, TestSize.Level1)
116 {
117 GTEST_LOG_(INFO) << "GetHmdfsPathTest003 start";
118 try {
119 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/dir/1.txt";
120 int32_t userId = 100;
121 std::string ret = g_servicePtr_->GetHmdfsPath(uri, userId);
122 std::string out = "/mnt/hmdfs/100/account/device_view/local/data/com.hmos.notepad/dir/1.txt";
123 EXPECT_EQ(ret, out);
124 } catch (...) {
125 EXPECT_TRUE(false);
126 GTEST_LOG_(INFO) << "GetHmdfsPathTest003 FAILED";
127 }
128 GTEST_LOG_(INFO) << "GetHmdfsPathTest003 end";
129 }
130
131 /**
132 * @tc.name: OnStopTest
133 * @tc.desc: Verify the OnStop function.
134 * @tc.type: FUNC
135 * @tc.require: I6H5MH
136 */
137 HWTEST_F(CloudSyncServiceTest, OnStopTest, TestSize.Level1)
138 {
139 GTEST_LOG_(INFO) << "OnStop start";
140 try {
141 g_servicePtr_->OnStop();
142 } catch (...) {
143 EXPECT_TRUE(false);
144 GTEST_LOG_(INFO) << "OnStop FAILED";
145 }
146 GTEST_LOG_(INFO) << "OnStop end";
147 }
148
149 /**
150 * @tc.name: OnAddSystemAbilityTest
151 * @tc.desc: Verify the OnAddSystemAbility function.
152 * @tc.type: FUNC
153 * @tc.require: I6H5MH
154 */
155 HWTEST_F(CloudSyncServiceTest, OnAddSystemAbilityTest, TestSize.Level1)
156 {
157 GTEST_LOG_(INFO) << "OnAddSystemAbility start";
158 try {
159 int32_t systemAbilityId = 100;
160 std::string deviceId = "";
161 g_servicePtr_->OnAddSystemAbility(systemAbilityId, deviceId);
162 } catch (...) {
163 EXPECT_TRUE(false);
164 GTEST_LOG_(INFO) << "OnAddSystemAbility FAILED";
165 }
166 GTEST_LOG_(INFO) << "OnAddSystemAbility end";
167 }
168
169 /**
170 * @tc.name: LoadRemoteSATest
171 * @tc.desc: Verify the LoadRemoteSA function.
172 * @tc.type: FUNC
173 * @tc.require: I6H5MH
174 */
175 HWTEST_F(CloudSyncServiceTest, LoadRemoteSATest, TestSize.Level1)
176 {
177 GTEST_LOG_(INFO) << "LoadRemoteSA start";
178 try {
179 std::string deviceId = "";
180 int ret = g_servicePtr_->LoadRemoteSA(deviceId);
181 EXPECT_EQ(ret, E_SA_LOAD_FAILED);
182 } catch (...) {
183 EXPECT_TRUE(false);
184 GTEST_LOG_(INFO) << "LoadRemoteSA FAILED";
185 }
186 GTEST_LOG_(INFO) << "LoadRemoteSA end";
187 }
188
189 /**
190 * @tc.name:UnRegisterCallbackInnerTest
191 * @tc.desc:Verify the UnRegisterCallbackInner function.
192 * @tc.type:FUNC
193 * @tc.require: I6H5MH
194 */
195 HWTEST_F(CloudSyncServiceTest, UnRegisterCallbackInnerTest, TestSize.Level1)
196 {
197 GTEST_LOG_(INFO) << "UnRegisterCallbackInner Start";
198 try {
199 std::string bundleName = "";
200 int ret = g_servicePtr_->UnRegisterCallbackInner(bundleName);
201 EXPECT_EQ(ret, E_OK);
202 } catch (...) {
203 EXPECT_TRUE(false);
204 GTEST_LOG_(INFO) << "UnRegisterCallbackInner FAILED";
205 }
206 GTEST_LOG_(INFO) << "UnRegisterCallbackInner End";
207 }
208
209 /**
210 * @tc.name:RegisterCallbackInnerTest001
211 * @tc.desc:Verify the RegisterCallbackInner function.
212 * @tc.type:FUNC
213 * @tc.require: I6H5MH
214 */
215 HWTEST_F(CloudSyncServiceTest, RegisterCallbackInnerTest001, TestSize.Level1)
216 {
217 GTEST_LOG_(INFO) << "RegisterCallbackInner start";
218 try {
219 std::string bundleName = "";
220 sptr<CloudSyncCallbackMock> callback = sptr(new CloudSyncCallbackMock());
221 int ret = g_servicePtr_->RegisterCallbackInner(callback, bundleName);
222 EXPECT_EQ(ret, E_OK);
223 } catch (...) {
224 EXPECT_TRUE(false);
225 GTEST_LOG_(INFO) << "RegisterCallbackInner FAILED";
226 }
227 GTEST_LOG_(INFO) << "RegisterCallbackInner end";
228 }
229
230 /**
231 * @tc.name:RegisterCallbackInnerTest002
232 * @tc.desc:Verify the RegisterCallbackInner function.
233 * @tc.type:FUNC
234 * @tc.require: I6H5MH
235 */
236 HWTEST_F(CloudSyncServiceTest, RegisterCallbackInnerTest002, TestSize.Level1)
237 {
238 GTEST_LOG_(INFO) << "RegisterCallbackInner error branch start";
239 try {
240 std::string bundleName = "com.ohos.photos";
241 sptr<CloudSyncCallbackMock> callback = nullptr;
242 int ret = g_servicePtr_->RegisterCallbackInner(callback, bundleName);
243 EXPECT_EQ(ret, E_INVAL_ARG);
244 } catch (...) {
245 EXPECT_TRUE(false);
246 GTEST_LOG_(INFO) << "RegisterCallbackInner error branch FAILED";
247 }
248 GTEST_LOG_(INFO) << "RegisterCallbackInner error branch end";
249 }
250
251 /**
252 * @tc.name:TriggerSyncInnerTest
253 * @tc.desc:Verify the TriggerSyncInner function.
254 * @tc.type:FUNC
255 * @tc.require: I6H5MH
256 */
257 HWTEST_F(CloudSyncServiceTest, TriggerSyncInnerTest, TestSize.Level1)
258 {
259 GTEST_LOG_(INFO) << "TriggerSyncInner start";
260 try {
261 std::string bundleName = "com.ohos.photos";
262 int32_t userId = 0;
263 int ret = g_servicePtr_->TriggerSyncInner(bundleName, userId);
264 EXPECT_EQ(ret, E_INVAL_ARG);
265 } catch (...) {
266 EXPECT_TRUE(false);
267 GTEST_LOG_(INFO) << "TriggerSyncInner FAILED";
268 }
269 GTEST_LOG_(INFO) << "TriggerSyncInner end";
270 }
271
272 /**
273 * @tc.name:StopSyncInnerTest
274 * @tc.desc:Verify the StopSyncInner function.
275 * @tc.type:FUNC
276 * @tc.require: I6H5MH
277 */
278 HWTEST_F(CloudSyncServiceTest, StopSyncInnerTest, TestSize.Level1)
279 {
280 GTEST_LOG_(INFO) << "StopSyncInner Start";
281 try {
282 std::string bundleName = "";
283 int ret = g_servicePtr_->StopSyncInner(bundleName);
284 EXPECT_EQ(ret, E_OK);
285 } catch (...) {
286 EXPECT_TRUE(false);
287 GTEST_LOG_(INFO) << "StopSyncInner FAILED";
288 }
289 GTEST_LOG_(INFO) << "StopSyncInner End";
290 }
291
292 /**
293 * @tc.name:CleanCacheInnerTest
294 * @tc.desc:Verify the CleanCacheInner function.
295 * @tc.type:FUNC
296 * @tc.require: I6H5MH
297 */
298 HWTEST_F(CloudSyncServiceTest, CleanCacheInnerTest, TestSize.Level1)
299 {
300 GTEST_LOG_(INFO) << "CleanCacheInner Start";
301 try {
302 std::string uri = "";
303 int ret = g_servicePtr_->CleanCacheInner(uri);
304 EXPECT_EQ(ret, E_OK);
305 } catch (...) {
306 EXPECT_TRUE(false);
307 GTEST_LOG_(INFO) << "CleanCacheInner FAILED";
308 }
309 GTEST_LOG_(INFO) << "CleanCacheInner End";
310 }
311
312 /**
313 * @tc.name:EnableCloudTest
314 * @tc.desc:Verify the EnableCloud function.
315 * @tc.type:FUNC
316 * @tc.require: I6H5MH
317 */
318 HWTEST_F(CloudSyncServiceTest, EnableCloudTest, TestSize.Level1)
319 {
320 GTEST_LOG_(INFO) << "EnableCloud start";
321 try {
322 std::string accountId = "testId";
323 SwitchDataObj switchData;
324 int ret = g_servicePtr_->EnableCloud(accountId, switchData);
325 EXPECT_EQ(ret, E_OK);
326 } catch (...) {
327 EXPECT_TRUE(false);
328 GTEST_LOG_(INFO) << "EnableCloud FAILED";
329 }
330 GTEST_LOG_(INFO) << "EnableCloud end";
331 }
332
333 /**
334 * @tc.name:CleanTest
335 * @tc.desc:Verify the Clean function.
336 * @tc.type:FUNC
337 * @tc.require: I6H5MH
338 */
339 HWTEST_F(CloudSyncServiceTest, CleanTest, TestSize.Level1)
340 {
341 GTEST_LOG_(INFO) << "DisableCloud start";
342 try {
343 std::string accountId = "testId";
344 CleanOptions cleanOptions;
345 int ret = g_servicePtr_->Clean(accountId, cleanOptions);
346 EXPECT_EQ(ret, E_OK);
347 } catch (...) {
348 EXPECT_TRUE(false);
349 GTEST_LOG_(INFO) << "Clean FAILED";
350 }
351 GTEST_LOG_(INFO) << "Clean end";
352 }
353
354 /**
355 * @tc.name:StopDownloadFileTest
356 * @tc.desc:Verify the StopDownloadFile function.
357 * @tc.type:FUNC
358 * @tc.require: I6H5MH
359 */
360 HWTEST_F(CloudSyncServiceTest, StopDownloadFileTest, TestSize.Level1)
361 {
362 GTEST_LOG_(INFO) << "StopDownloadFile start";
363 try {
364 std::string path;
365 bool needClean = false;
366 int ret = g_servicePtr_->StopDownloadFile(path, needClean);
367 EXPECT_EQ(E_OK, ret);
368 } catch (...) {
369 EXPECT_TRUE(false);
370 GTEST_LOG_(INFO) << "StopDownloadFile FAILED";
371 }
372 GTEST_LOG_(INFO) << "StopDownloadFile end";
373 }
374
375 /**
376 * @tc.name:RegisterDownloadFileCallbackTest
377 * @tc.desc:Verify the RegisterDownloadFileCallback function.
378 * @tc.type:FUNC
379 * @tc.require: I6H5MH
380 */
381 HWTEST_F(CloudSyncServiceTest, RegisterDownloadFileCallbackTest, TestSize.Level1)
382 {
383 GTEST_LOG_(INFO) << "RegisterDownloadFileCallback start";
384 try {
385 sptr<CloudDownloadCallbackMock> downloadCallback = sptr(new CloudDownloadCallbackMock());
386 int ret = g_servicePtr_->RegisterDownloadFileCallback(downloadCallback);
387 EXPECT_EQ(ret, E_OK);
388 } catch (...) {
389 EXPECT_TRUE(false);
390 GTEST_LOG_(INFO) << "RegisterDownloadFileCallback FAILED";
391 }
392 GTEST_LOG_(INFO) << "RegisterDownloadFileCallback end";
393 }
394
395 /**
396 * @tc.name:UnregisterDownloadFileCallbackTest
397 * @tc.desc:Verify the UnregisterDownloadFileCallback function.
398 * @tc.type:FUNC
399 * @tc.require: I6H5MH
400 */
401 HWTEST_F(CloudSyncServiceTest, UnregisterDownloadFileCallbackTest, TestSize.Level1)
402 {
403 GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback start";
404 try {
405 int ret = g_servicePtr_->UnregisterDownloadFileCallback();
406 EXPECT_EQ(ret, E_OK);
407 } catch (...) {
408 EXPECT_TRUE(false);
409 GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback FAILED";
410 }
411 GTEST_LOG_(INFO) << "UnregisterDownloadFileCallback end";
412 }
413
414 /**
415 * @tc.name:UploadAssetTest
416 * @tc.desc:Verify the UploadAsset function.
417 * @tc.type:FUNC
418 * @tc.require: I6H5MH
419 */
420 HWTEST_F(CloudSyncServiceTest, UploadAssetTest, TestSize.Level1)
421 {
422 GTEST_LOG_(INFO) << "UploadAsset start";
423 try {
424 int32_t userId = 100;
425 std::string request = "testReq";
426 std::string result = "expRes";
427 int ret = g_servicePtr_->UploadAsset(userId, request, result);
428 EXPECT_EQ(ret, E_NULLPTR);
429 } catch (...) {
430 EXPECT_TRUE(false);
431 GTEST_LOG_(INFO) << "UploadAsset FAILED";
432 }
433 GTEST_LOG_(INFO) << "UploadAsset end";
434 }
435
436 /**
437 * @tc.name:DownloadFileTest001
438 * @tc.desc:Verify the DownloadFile function.
439 * @tc.type:FUNC
440 * @tc.require: I6H5MH
441 */
442 HWTEST_F(CloudSyncServiceTest, DownloadFileTest001, TestSize.Level1)
443 {
444 GTEST_LOG_(INFO) << "DownloadFileTest001 start";
445 try {
446 int32_t userId = 100;
447 std::string bundleName = "com.ohos.photos";
448 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/dir/1.txt";
449 AssetInfoObj assetInfoObj;
450 assetInfoObj.uri = uri;
451 int ret = g_servicePtr_->DownloadFile(userId, bundleName, assetInfoObj);
452 EXPECT_EQ(ret, E_NULLPTR);
453 } catch (...) {
454 EXPECT_TRUE(false);
455 GTEST_LOG_(INFO) << "DownloadFileTest001 FAILED";
456 }
457 GTEST_LOG_(INFO) << "DownloadFileTest001 end";
458 }
459
460 /**
461 * @tc.name:DownloadAssetTest001
462 * @tc.desc:Verify the DownloadAsset function.
463 * @tc.type:FUNC
464 * @tc.require: I6H5MH
465 */
466 HWTEST_F(CloudSyncServiceTest, DownloadAssetTest001, TestSize.Level1)
467 {
468 GTEST_LOG_(INFO) << "DownloadAssetTest001 start";
469 try {
470 uint64_t taskId = 100;
471 int32_t userId = 100;
472 std::string bundleName = "com.ohos.photos";
473 std::string networkId = "0.0.0.0";
474 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/dir/1.txt";
475 AssetInfoObj assetInfoObj;
476 assetInfoObj.uri = uri;
477 int ret = g_servicePtr_->DownloadAsset(taskId, userId, bundleName, networkId, assetInfoObj);
478 EXPECT_EQ(ret, E_SA_LOAD_FAILED);
479 } catch (...) {
480 EXPECT_TRUE(false);
481 GTEST_LOG_(INFO) << "DownloadAssetTest001 FAILED";
482 }
483 GTEST_LOG_(INFO) << "DownloadAssetTest001 end";
484 }
485
486 /**
487 * @tc.name:DownloadAssetTest002
488 * @tc.desc:Verify the DownloadAsset function.
489 * @tc.type:FUNC
490 * @tc.require: I6H5MH
491 */
492 HWTEST_F(CloudSyncServiceTest, DownloadAssetTest002, TestSize.Level1)
493 {
494 GTEST_LOG_(INFO) << "DownloadAssetTest002 start";
495 try {
496 uint64_t taskId = 100;
497 int32_t userId = 100;
498 std::string bundleName = "com.ohos.photos";
499 std::string networkId = "edge2cloud";
500 AssetInfoObj assetInfoObj;
501 int ret = g_servicePtr_->DownloadAsset(taskId, userId, bundleName, networkId, assetInfoObj);
502 EXPECT_EQ(ret, E_INVAL_ARG);
503 } catch (...) {
504 EXPECT_TRUE(false);
505 GTEST_LOG_(INFO) << "DownloadAssetTest002 FAILED";
506 }
507 GTEST_LOG_(INFO) << "DownloadAssetTest002 end";
508 }
509
510 /**
511 * @tc.name:RegisterDownloadAssetCallbackTest
512 * @tc.desc:Verify the RegisterDownloadAssetCallback function.
513 * @tc.type:FUNC
514 * @tc.require: I6H5MH
515 */
516 HWTEST_F(CloudSyncServiceTest, RegisterDownloadAssetCallbackTest, TestSize.Level1)
517 {
518 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback start";
519 try {
520 sptr<CloudSyncCallbackMock> callback = sptr(new CloudSyncCallbackMock());
521 int ret = g_servicePtr_->RegisterDownloadAssetCallback(callback);
522 EXPECT_EQ(ret, E_OK);
523 } catch (...) {
524 EXPECT_TRUE(false);
525 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback FAILED";
526 }
527 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback end";
528 }
529
530 /**
531 * @tc.name:RegisterDownloadAssetCallbackTest002
532 * @tc.desc:Verify theRegisterDownloadAssetCallback function.
533 * @tc.type:FUNC
534 * @tc.require: I6H5MH
535 */
536 HWTEST_F(CloudSyncServiceTest, RegisterDownloadAssetCallbackTest002, TestSize.Level1)
537 {
538 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback error branch start";
539 try {
540 sptr<CloudSyncCallbackMock> callback = nullptr;
541 int ret = g_servicePtr_->RegisterDownloadAssetCallback(callback);
542 EXPECT_EQ(ret, E_INVAL_ARG);
543 } catch (...) {
544 EXPECT_TRUE(false);
545 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback error branch FAILED";
546 }
547 GTEST_LOG_(INFO) << "RegisterDownloadAssetCallback error branch end";
548 }
549
550 /**
551 * @tc.name:DeleteAssetTest001
552 * @tc.desc:Verify the DeleteAsset function.
553 * @tc.type:FUNC
554 * @tc.require: I6H5MH
555 */
556 HWTEST_F(CloudSyncServiceTest, DeleteAssetTest001, TestSize.Level1)
557 {
558 GTEST_LOG_(INFO) << "DeleteAssetTest001 start";
559 try {
560 int32_t userId = 100;
561 std::string uri = "";
562 int ret = g_servicePtr_->DeleteAsset(userId, uri);
563 EXPECT_EQ(ret, E_GET_PHYSICAL_PATH_FAILED);
564 } catch (...) {
565 EXPECT_TRUE(false);
566 GTEST_LOG_(INFO) << "DeleteAssetTest001 FAILED";
567 }
568 GTEST_LOG_(INFO) << "DeleteAssetTest001 end";
569 }
570
571 /**
572 * @tc.name:DeleteAssetTest002
573 * @tc.desc:Verify the DeleteAsset function.
574 * @tc.type:FUNC
575 * @tc.require: I6H5MH
576 */
577 HWTEST_F(CloudSyncServiceTest, DeleteAssetTest002, TestSize.Level1)
578 {
579 GTEST_LOG_(INFO) << "DeleteAssetTest002 start";
580 try {
581 int32_t userId = 100;
582 std::string uri = "file://com.hmos.notepad/data/storage/el2/distributedfiles/dir/1.txt";
583 int ret = g_servicePtr_->DeleteAsset(userId, uri);
584 EXPECT_EQ(ret, E_DELETE_FAILED);
585 } catch (...) {
586 EXPECT_TRUE(false);
587 GTEST_LOG_(INFO) << "DeleteAssetTest002 FAILED";
588 }
589 GTEST_LOG_(INFO) << "DeleteAssetTest002 end";
590 }
591 } // namespace Test
592 } // namespace FileManagement::CloudSync
593 } // namespace OHOS
594