1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 
19 #include "clouddisk_notify.h"
20 #include "clouddisk_notify_utils.h"
21 #include "clouddisk_rdbstore.h"
22 #include "dfs_error.h"
23 #include "ffrt_inner.h"
24 #include "file_column.h"
25 #include "securec.h"
26 #include "uri.h"
27 #include "utils_log.h"
28 
29 namespace OHOS {
30 namespace FileManagement::CloudDisk {
31 namespace Test {
32 using namespace testing::ext;
33 using namespace std;
34 
35 class CloudDiskNotifyTest : public testing::Test {
36 public:
37     static void SetUpTestCase(void);
38     static void TearDownTestCase(void);
39     void SetUp();
40     void TearDown();
41 };
42 
SetUpTestCase(void)43 void CloudDiskNotifyTest::SetUpTestCase(void)
44 {
45     std::cout << "SetUpTestCase" << std::endl;
46 }
47 
TearDownTestCase(void)48 void CloudDiskNotifyTest::TearDownTestCase(void)
49 {
50     std::cout << "TearDownTestCase" << std::endl;
51 }
52 
SetUp(void)53 void CloudDiskNotifyTest::SetUp(void)
54 {
55     std::cout << "SetUp" << std::endl;
56 }
57 
TearDown(void)58 void CloudDiskNotifyTest::TearDown(void)
59 {
60     std::cout << "TearDown" << std::endl;
61 }
62 
63 /**
64  * @tc.name: TryNotifyTest001
65  * @tc.desc: Verify the TryNotify function.
66  * @tc.type: FUNC
67  * @tc.require: I6H5MH
68  */
69 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest001, TestSize.Level1)
70 {
71     GTEST_LOG_(INFO) << "TryNotify Start";
72     CloudDiskNotify CloudDiskNotify;
73     NotifyParamDisk paramDisk;
74     paramDisk.inoPtr = nullptr;
75     paramDisk.data = new CloudDiskFuseData();
76     paramDisk.data->userId = 100;
77     paramDisk.opsType = NotifyOpsType::DAEMON_SETATTR;
78     ParamDiskOthers paramOthers;
79     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
80     delete paramDisk.data;
81     GTEST_LOG_(INFO) << "TryNotify End";
82 }
83 
84 /**
85  * @tc.name: TryNotifyTest002
86  * @tc.desc: Verify the TryNotify function.
87  * @tc.type: FUNC
88  * @tc.require: I6H5MH
89  */
90 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest002, TestSize.Level1)
91 {
92     GTEST_LOG_(INFO) << "TryNotify Start";
93     CloudDiskNotify CloudDiskNotify;
94     NotifyParamDisk paramDisk;
95     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
96     paramDisk.inoPtr = ino;
97     paramDisk.data = new CloudDiskFuseData();
98     paramDisk.data->userId = 10;
99     paramDisk.opsType = NotifyOpsType::DAEMON_SETATTR;
100     ParamDiskOthers paramOthers;
101     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
102     delete paramDisk.data;
103     GTEST_LOG_(INFO) << "TryNotify End";
104 }
105 
106 /**
107  * @tc.name: TryNotifyTest003
108  * @tc.desc: Verify the TryNotify function.
109  * @tc.type: FUNC
110  * @tc.require: I6H5MH
111  */
112 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest003, TestSize.Level1)
113 {
114     GTEST_LOG_(INFO) << "TryNotify Start";
115     CloudDiskNotify CloudDiskNotify;
116     NotifyParamDisk paramDisk;
117     paramDisk.inoPtr = nullptr;
118     paramDisk.data = new CloudDiskFuseData();
119     paramDisk.data->userId = 100;
120     paramDisk.opsType = NotifyOpsType::DAEMON_SETXATTR;
121     ParamDiskOthers paramOthers;
122     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
123     delete paramDisk.data;
124     GTEST_LOG_(INFO) << "TryNotify End";
125 }
126 
127 /**
128  * @tc.name: TryNotifyTest004
129  * @tc.desc: Verify the TryNotify function.
130  * @tc.type: FUNC
131  * @tc.require: I6H5MH
132  */
133 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest004, TestSize.Level1)
134 {
135     GTEST_LOG_(INFO) << "TryNotify Start";
136     CloudDiskNotify CloudDiskNotify;
137     NotifyParamDisk paramDisk;
138     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
139     paramDisk.inoPtr = ino;
140     paramDisk.data = new CloudDiskFuseData();
141     paramDisk.data->userId = 10;
142     paramDisk.opsType = NotifyOpsType::DAEMON_SETXATTR;
143     ParamDiskOthers paramOthers;
144     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
145     delete paramDisk.data;
146     GTEST_LOG_(INFO) << "TryNotify End";
147 }
148 
149 /**
150  * @tc.name: TryNotifyTest005
151  * @tc.desc: Verify the TryNotify function.
152  * @tc.type: FUNC
153  * @tc.require: I6H5MH
154  */
155 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest005, TestSize.Level1)
156 {
157     GTEST_LOG_(INFO) << "TryNotify Start";
158     CloudDiskNotify CloudDiskNotify;
159     NotifyParamDisk paramDisk;
160     paramDisk.inoPtr = nullptr;
161     paramDisk.data = new CloudDiskFuseData();
162     paramDisk.data->userId = 10;
163     paramDisk.opsType = NotifyOpsType::DAEMON_RECYCLE;
164     ParamDiskOthers paramOthers;
165     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
166     delete paramDisk.data;
167     GTEST_LOG_(INFO) << "TryNotify End";
168 }
169 
170 /**
171  * @tc.name: TryNotifyTest006
172  * @tc.desc: Verify the TryNotify function.
173  * @tc.type: FUNC
174  * @tc.require: I6H5MH
175  */
176 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest006, TestSize.Level1)
177 {
178     GTEST_LOG_(INFO) << "TryNotify Start";
179     CloudDiskNotify CloudDiskNotify;
180     NotifyParamDisk paramDisk;
181     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
182     ino->bundleName = "";
183     paramDisk.inoPtr = ino;
184     paramDisk.data = new CloudDiskFuseData();
185     paramDisk.data->userId = 0;
186     paramDisk.opsType = NotifyOpsType::DAEMON_RECYCLE;
187     ParamDiskOthers paramOthers;
188     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
189     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
190     delete paramDisk.data;
191     GTEST_LOG_(INFO) << "TryNotify End";
192 }
193 
194 /**
195  * @tc.name: TryNotifyTest007
196  * @tc.desc: Verify the TryNotify function.
197  * @tc.type: FUNC
198  * @tc.require: I6H5MH
199  */
200 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest007, TestSize.Level1)
201 {
202     GTEST_LOG_(INFO) << "TryNotify Start";
203     CloudDiskNotify CloudDiskNotify;
204     NotifyParamDisk paramDisk;
205     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
206     ino->bundleName = "com.ohos.photos";
207     ino->cloudId = "mock";
208     paramDisk.inoPtr = ino;
209     paramDisk.data = new CloudDiskFuseData();
210     paramDisk.data->userId = 100;
211     paramDisk.opsType = NotifyOpsType::DAEMON_RECYCLE;
212     ParamDiskOthers paramOthers;
213     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
214     delete paramDisk.data;
215     GTEST_LOG_(INFO) << "TryNotify End";
216 }
217 
218 /**
219  * @tc.name: TryNotifyTest008
220  * @tc.desc: Verify the TryNotify function.
221  * @tc.type: FUNC
222  * @tc.require: I6H5MH
223  */
224 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest008, TestSize.Level1)
225 {
226     GTEST_LOG_(INFO) << "TryNotify Start";
227     CloudDiskNotify CloudDiskNotify;
228     NotifyParamDisk paramDisk;
229     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
230     ino->bundleName = "com.ohos.photos";
231     ino->cloudId = "rootId";
232     paramDisk.inoPtr = ino;
233     paramDisk.data = new CloudDiskFuseData();
234     paramDisk.data->userId = 10;
235     paramDisk.opsType = NotifyOpsType::DAEMON_RECYCLE;
236     ParamDiskOthers paramOthers;
237     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
238     delete paramDisk.data;
239     GTEST_LOG_(INFO) << "TryNotify End";
240 }
241 
242 /**
243  * @tc.name: TryNotifyTest009
244  * @tc.desc: Verify the TryNotify function.
245  * @tc.type: FUNC
246  * @tc.require: I6H5MH
247  */
248 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest009, TestSize.Level1)
249 {
250     GTEST_LOG_(INFO) << "TryNotify Start";
251     CloudDiskNotify CloudDiskNotify;
252     NotifyParamDisk paramDisk;
253     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
254     ino->bundleName = "com.ohos.photos";
255     ino->cloudId = "rootId";
256     paramDisk.inoPtr = ino;
257     paramDisk.data = new CloudDiskFuseData();
258     paramDisk.data->userId = 100;
259     paramDisk.opsType = NotifyOpsType::DAEMON_RECYCLE;
260     ParamDiskOthers paramOthers;
261     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
262     delete paramDisk.data;
263     GTEST_LOG_(INFO) << "TryNotify End";
264 }
265 
266 /**
267  * @tc.name: TryNotifyTest010
268  * @tc.desc: Verify the TryNotify function.
269  * @tc.type: FUNC
270  * @tc.require: I6H5MH
271  */
272 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest010, TestSize.Level1)
273 {
274     GTEST_LOG_(INFO) << "TryNotify Start";
275     CloudDiskNotify CloudDiskNotify;
276     NotifyParamDisk paramDisk;
277     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
278     ino->bundleName = "com.ohos.photos";
279     ino->cloudId = "rootId";
280     paramDisk.inoPtr = ino;
281     paramDisk.data = new CloudDiskFuseData();
282     paramDisk.data->userId = 100;
283     paramDisk.opsType = NotifyOpsType::DAEMON_RESTORE;
284     ParamDiskOthers paramOthers;
285     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
286     delete paramDisk.data;
287     GTEST_LOG_(INFO) << "TryNotify End";
288 }
289 
290 /**
291  * @tc.name: TryNotifyTest011
292  * @tc.desc: Verify the TryNotify function.
293  * @tc.type: FUNC
294  * @tc.require: I6H5MH
295  */
296 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest011, TestSize.Level1)
297 {
298     GTEST_LOG_(INFO) << "TryNotify Start";
299     CloudDiskNotify CloudDiskNotify;
300     NotifyParamDisk paramDisk;
301     paramDisk.name = "";
302     paramDisk.opsType = NotifyOpsType::DAEMON_MKDIR;
303     ParamDiskOthers paramOthers;
304     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
305     GTEST_LOG_(INFO) << "TryNotify End";
306 }
307 
308 /**
309  * @tc.name: TryNotifyTest012
310  * @tc.desc: Verify the TryNotify function.
311  * @tc.type: FUNC
312  * @tc.require: I6H5MH
313  */
314 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest012, TestSize.Level1)
315 {
316     GTEST_LOG_(INFO) << "TryNotify Start";
317     CloudDiskNotify CloudDiskNotify;
318     NotifyParamDisk paramDisk;
319     paramDisk.name = "test";
320     paramDisk.inoPtr = nullptr;
321     paramDisk.data = new CloudDiskFuseData();
322     paramDisk.data->userId = 10;
323     paramDisk.opsType = NotifyOpsType::DAEMON_MKDIR;
324     ParamDiskOthers paramOthers;
325     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
326     delete paramDisk.data;
327     GTEST_LOG_(INFO) << "TryNotify End";
328 }
329 
330 /**
331  * @tc.name: TryNotifyTest013
332  * @tc.desc: Verify the TryNotify function.
333  * @tc.type: FUNC
334  * @tc.require: I6H5MH
335  */
336 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest013, TestSize.Level1)
337 {
338     GTEST_LOG_(INFO) << "TryNotify Start";
339     CloudDiskNotify CloudDiskNotify;
340     NotifyParamDisk paramDisk;
341     paramDisk.name = "test";
342     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
343     paramDisk.inoPtr = ino;
344     paramDisk.data = new CloudDiskFuseData();
345     paramDisk.data->userId = 100;
346     paramDisk.opsType = NotifyOpsType::DAEMON_MKDIR;
347     ParamDiskOthers paramOthers;
348     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
349     delete paramDisk.data;
350     GTEST_LOG_(INFO) << "TryNotify End";
351 }
352 
353 /**
354  * @tc.name: TryNotifyTest014
355  * @tc.desc: Verify the TryNotify function.
356  * @tc.type: FUNC
357  * @tc.require: I6H5MH
358  */
359 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest014, TestSize.Level1)
360 {
361     GTEST_LOG_(INFO) << "TryNotify Start";
362     CloudDiskNotify CloudDiskNotify;
363     NotifyParamDisk paramDisk;
364     paramDisk.name = "";
365     paramDisk.opsType = NotifyOpsType::DAEMON_RMDIR;
366     ParamDiskOthers paramOthers;
367     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
368     GTEST_LOG_(INFO) << "TryNotify End";
369 }
370 
371 /**
372  * @tc.name: TryNotifyTest015
373  * @tc.desc: Verify the TryNotify function.
374  * @tc.type: FUNC
375  * @tc.require: I6H5MH
376  */
377 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest015, TestSize.Level1)
378 {
379     GTEST_LOG_(INFO) << "TryNotify Start";
380     CloudDiskNotify CloudDiskNotify;
381     NotifyParamDisk paramDisk;
382     paramDisk.name = "test";
383     paramDisk.inoPtr = nullptr;
384     paramDisk.data = new CloudDiskFuseData();
385     paramDisk.data->userId = 10;
386     paramDisk.opsType = NotifyOpsType::DAEMON_RMDIR;
387     ParamDiskOthers paramOthers;
388     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
389     delete paramDisk.data;
390     GTEST_LOG_(INFO) << "TryNotify End";
391 }
392 
393 /**
394  * @tc.name: TryNotifyTest016
395  * @tc.desc: Verify the TryNotify function.
396  * @tc.type: FUNC
397  * @tc.require: I6H5MH
398  */
399 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest016, TestSize.Level1)
400 {
401     GTEST_LOG_(INFO) << "TryNotify Start";
402     CloudDiskNotify CloudDiskNotify;
403     NotifyParamDisk paramDisk;
404     paramDisk.name = "test";
405     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
406     paramDisk.inoPtr = ino;
407     paramDisk.data = new CloudDiskFuseData();
408     paramDisk.data->userId = 100;
409     paramDisk.opsType = NotifyOpsType::DAEMON_RMDIR;
410     ParamDiskOthers paramOthers;
411     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
412     delete paramDisk.data;
413     GTEST_LOG_(INFO) << "TryNotify End";
414 }
415 
416 /**
417  * @tc.name: TryNotifyTest017
418  * @tc.desc: Verify the TryNotify function.
419  * @tc.type: FUNC
420  * @tc.require: I6H5MH
421  */
422 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest017, TestSize.Level1)
423 {
424     GTEST_LOG_(INFO) << "TryNotify Start";
425     CloudDiskNotify CloudDiskNotify;
426     NotifyParamDisk paramDisk;
427     paramDisk.name = "test";
428     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
429     paramDisk.inoPtr = ino;
430     paramDisk.data = new CloudDiskFuseData();
431     paramDisk.data->userId = 100;
432     paramDisk.opsType = NotifyOpsType::DAEMON_UNLINK;
433     ParamDiskOthers paramOthers;
434     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
435     delete paramDisk.data;
436     GTEST_LOG_(INFO) << "TryNotify End";
437 }
438 
439 /**
440  * @tc.name: TryNotifyTest018
441  * @tc.desc: Verify the TryNotify function.
442  * @tc.type: FUNC
443  * @tc.require: I6H5MH
444  */
445 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest018, TestSize.Level1)
446 {
447     GTEST_LOG_(INFO) << "TryNotify Start";
448     CloudDiskNotify CloudDiskNotify;
449     NotifyParamDisk paramDisk;
450     paramDisk.data = new CloudDiskFuseData();
451     paramDisk.data->userId = 10;
452     paramDisk.opsType = NotifyOpsType::DAEMON_RENAME;
453     ParamDiskOthers paramOthers;
454     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
455     delete paramDisk.data;
456     GTEST_LOG_(INFO) << "TryNotify End";
457 }
458 
459 /**
460  * @tc.name: TryNotifyTest019
461  * @tc.desc: Verify the TryNotify function.
462  * @tc.type: FUNC
463  * @tc.require: I6H5MH
464  */
465 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest019, TestSize.Level1)
466 {
467     GTEST_LOG_(INFO) << "TryNotify Start";
468     CloudDiskNotify CloudDiskNotify;
469     NotifyParamDisk paramDisk;
470     paramDisk.newName = "mock";
471     paramDisk.data = new CloudDiskFuseData();
472     paramDisk.data->userId = 100;
473     paramDisk.opsType = NotifyOpsType::DAEMON_RENAME;
474     ParamDiskOthers paramOthers;
475     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
476     delete paramDisk.data;
477     GTEST_LOG_(INFO) << "TryNotify End";
478 }
479 
480 /**
481  * @tc.name: TryNotifyTest020
482  * @tc.desc: Verify the TryNotify function.
483  * @tc.type: FUNC
484  * @tc.require: I6H5MH
485  */
486 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest020, TestSize.Level1)
487 {
488     GTEST_LOG_(INFO) << "TryNotify Start";
489     CloudDiskNotify CloudDiskNotify;
490     NotifyParamDisk paramDisk;
491     paramDisk.newName = "test";
492     paramDisk.data = new CloudDiskFuseData();
493     paramDisk.data->userId = 100;
494     paramDisk.opsType = NotifyOpsType::DAEMON_RENAME;
495     ParamDiskOthers paramOthers;
496     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
497     delete paramDisk.data;
498     GTEST_LOG_(INFO) << "TryNotify End";
499 }
500 
501 /**
502  * @tc.name: TryNotifyTest021
503  * @tc.desc: Verify the TryNotify function.
504  * @tc.type: FUNC
505  * @tc.require: I6H5MH
506  */
507 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest021, TestSize.Level1)
508 {
509     GTEST_LOG_(INFO) << "TryNotify Start";
510     CloudDiskNotify CloudDiskNotify;
511     NotifyParamDisk paramDisk;
512     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
513     paramDisk.inoPtr = ino;
514     paramDisk.data = new CloudDiskFuseData();
515     paramDisk.data->userId = 10;
516     paramDisk.opsType = NotifyOpsType::DAEMON_WRITE;
517     ParamDiskOthers paramOthers;
518     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
519     delete paramDisk.data;
520     GTEST_LOG_(INFO) << "TryNotify End";
521 }
522 
523 /**
524  * @tc.name: TryNotifyTest022
525  * @tc.desc: Verify the TryNotify function.
526  * @tc.type: FUNC
527  * @tc.require: I6H5MH
528  */
529 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest022, TestSize.Level1)
530 {
531     GTEST_LOG_(INFO) << "TryNotify Start";
532     CloudDiskNotify CloudDiskNotify;
533     NotifyParamDisk paramDisk;
534     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
535     paramDisk.inoPtr = ino;
536     paramDisk.data = new CloudDiskFuseData();
537     paramDisk.data->userId = 100;
538     paramDisk.opsType = NotifyOpsType::DAEMON_WRITE;
539     ParamDiskOthers paramOthers;
540     paramOthers.dirtyType = static_cast<int32_t>(DirtyType::TYPE_NO_NEED_UPLOAD);
541     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
542     delete paramDisk.data;
543     GTEST_LOG_(INFO) << "TryNotify End";
544 }
545 
546 /**
547  * @tc.name: TryNotifyTest023
548  * @tc.desc: Verify the TryNotify function.
549  * @tc.type: FUNC
550  * @tc.require: I6H5MH
551  */
552 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest023, TestSize.Level1)
553 {
554     GTEST_LOG_(INFO) << "TryNotify Start";
555     CloudDiskNotify CloudDiskNotify;
556     NotifyParamDisk paramDisk;
557     shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
558     paramDisk.inoPtr = ino;
559     paramDisk.data = new CloudDiskFuseData();
560     paramDisk.data->userId = 100;
561     paramDisk.opsType = NotifyOpsType::DAEMON_WRITE;
562     ParamDiskOthers paramOthers;
563     paramOthers.dirtyType = static_cast<int32_t>(DirtyType::TYPE_NEW);
564     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
565     delete paramDisk.data;
566     GTEST_LOG_(INFO) << "TryNotify End";
567 }
568 
569 /**
570  * @tc.name: TryNotifyTest024
571  * @tc.desc: Verify the TryNotify function.
572  * @tc.type: FUNC
573  * @tc.require: I6H5MH
574  */
575 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest024, TestSize.Level1)
576 {
577     GTEST_LOG_(INFO) << "TryNotify Start";
578     CloudDiskNotify CloudDiskNotify;
579     NotifyParamDisk paramDisk;
580     ParamDiskOthers paramOthers;
581     paramOthers.dirtyType = static_cast<int32_t>(DirtyType::TYPE_NEW);
582     CloudDiskNotify.TryNotify(paramDisk, paramOthers);
583     GTEST_LOG_(INFO) << "TryNotify End";
584 }
585 
586 /**
587  * @tc.name: TryNotifyServiceTest001
588  * @tc.desc: Verify the TryNotifyService function.
589  * @tc.type: FUNC
590  * @tc.require: I6H5MH
591  */
592 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest001, TestSize.Level1)
593 {
594     GTEST_LOG_(INFO) << "TryNotifyService Start";
595     CloudDiskNotify CloudDiskNotify;
596     NotifyParamService paramService;
597     paramService.node.isRecycled = true;
598     paramService.cloudId = "mock";
599     paramService.opsType = NotifyOpsType::SERVICE_INSERT;
600     ParamServiceOther paramOthers;
601     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
602     GTEST_LOG_(INFO) << "TryNotifyService End";
603 }
604 
605 /**
606  * @tc.name: TryNotifyServiceTest002
607  * @tc.desc: Verify the TryNotifyService function.
608  * @tc.type: FUNC
609  * @tc.require: I6H5MH
610  */
611 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest002, TestSize.Level1)
612 {
613     GTEST_LOG_(INFO) << "TryNotifyService Start";
614     CloudDiskNotify CloudDiskNotify;
615     NotifyParamService paramService;
616     paramService.node.isRecycled = true;
617     paramService.cloudId = "rootId";
618     paramService.opsType = NotifyOpsType::SERVICE_INSERT;
619     ParamServiceOther paramOthers;
620     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
621     GTEST_LOG_(INFO) << "TryNotifyService End";
622 }
623 
624 /**
625  * @tc.name: TryNotifyServiceTest003
626  * @tc.desc: Verify the TryNotifyService function.
627  * @tc.type: FUNC
628  * @tc.require: I6H5MH
629  */
630 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest003, TestSize.Level1)
631 {
632     GTEST_LOG_(INFO) << "TryNotifyService Start";
633     CloudDiskNotify CloudDiskNotify;
634     NotifyParamService paramService;
635     paramService.node.isRecycled = false;
636     paramService.node.cloudId = "mock";
637     paramService.opsType = NotifyOpsType::SERVICE_INSERT;
638     ParamServiceOther paramOthers;
639     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
640     GTEST_LOG_(INFO) << "TryNotifyService End";
641 }
642 
643 /**
644  * @tc.name: TryNotifyServiceTest004
645  * @tc.desc: Verify the TryNotifyService function.
646  * @tc.type: FUNC
647  * @tc.require: I6H5MH
648  */
649 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest004, TestSize.Level1)
650 {
651     GTEST_LOG_(INFO) << "TryNotifyService Start";
652     CloudDiskNotify CloudDiskNotify;
653     NotifyParamService paramService;
654     paramService.cloudId = "mock";
655     paramService.opsType = NotifyOpsType::SERVICE_UPDATE;
656     ParamServiceOther paramOthers;
657     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
658     GTEST_LOG_(INFO) << "TryNotifyService End";
659 }
660 
661 /**
662  * @tc.name: TryNotifyServiceTest005
663  * @tc.desc: Verify the TryNotifyService function.
664  * @tc.type: FUNC
665  * @tc.require: I6H5MH
666  */
667 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest005, TestSize.Level1)
668 {
669     GTEST_LOG_(INFO) << "TryNotifyService Start";
670     CloudDiskNotify CloudDiskNotify;
671     NotifyParamService paramService;
672     paramService.cloudId = "rootId";
673     paramService.node.fileName = "mock";
674     paramService.opsType = NotifyOpsType::SERVICE_UPDATE;
675     ParamServiceOther paramOthers;
676     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
677     GTEST_LOG_(INFO) << "TryNotifyService End";
678 }
679 
680 /**
681  * @tc.name: TryNotifyServiceTest006
682  * @tc.desc: Verify the TryNotifyService function.
683  * @tc.type: FUNC
684  * @tc.require: I6H5MH
685  */
686 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest006, TestSize.Level1)
687 {
688     GTEST_LOG_(INFO) << "TryNotifyService Start";
689     CloudDiskNotify CloudDiskNotify;
690     NotifyParamService paramService;
691     paramService.cloudId = "rootId";
692     paramService.opsType = NotifyOpsType::SERVICE_UPDATE;
693     ParamServiceOther paramOthers;
694     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
695     GTEST_LOG_(INFO) << "TryNotifyService End";
696 }
697 
698 /**
699  * @tc.name: TryNotifyServiceTest007
700  * @tc.desc: Verify the TryNotifyService function.
701  * @tc.type: FUNC
702  * @tc.require: I6H5MH
703  */
704 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest007, TestSize.Level1)
705 {
706     GTEST_LOG_(INFO) << "TryNotifyService Start";
707     CloudDiskNotify CloudDiskNotify;
708     NotifyParamService paramService;
709     paramService.cloudId = "mock";
710     paramService.opsType = NotifyOpsType::SERVICE_UPDATE_RECYCLE;
711     ParamServiceOther paramOthers;
712     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
713     GTEST_LOG_(INFO) << "TryNotifyService End";
714 }
715 
716 /**
717  * @tc.name: TryNotifyServiceTest008
718  * @tc.desc: Verify the TryNotifyService function.
719  * @tc.type: FUNC
720  * @tc.require: I6H5MH
721  */
722 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest008, TestSize.Level1)
723 {
724     GTEST_LOG_(INFO) << "TryNotifyService Start";
725     CloudDiskNotify CloudDiskNotify;
726     NotifyParamService paramService;
727     paramService.cloudId = "rootId";
728     paramService.node.cloudId = "mock";
729     paramService.opsType = NotifyOpsType::SERVICE_UPDATE_RECYCLE;
730     ParamServiceOther paramOthers;
731     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
732     GTEST_LOG_(INFO) << "TryNotifyService End";
733 }
734 
735 /**
736  * @tc.name: TryNotifyServiceTest009
737  * @tc.desc: Verify the TryNotifyService function.
738  * @tc.type: FUNC
739  * @tc.require: I6H5MH
740  */
741 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest009, TestSize.Level1)
742 {
743     GTEST_LOG_(INFO) << "TryNotifyService Start";
744     CloudDiskNotify CloudDiskNotify;
745     NotifyParamService paramService;
746     paramService.cloudId = "rootId";
747     paramService.node.cloudId = "rootId";
748     paramService.node.isRecycled = false;
749     paramService.opsType = NotifyOpsType::SERVICE_UPDATE_RECYCLE;
750     ParamServiceOther paramOthers;
751     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
752     GTEST_LOG_(INFO) << "TryNotifyService End";
753 }
754 
755 /**
756  * @tc.name: TryNotifyServiceTest010
757  * @tc.desc: Verify the TryNotifyService function.
758  * @tc.type: FUNC
759  * @tc.require: I6H5MH
760  */
761 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest010, TestSize.Level1)
762 {
763     GTEST_LOG_(INFO) << "TryNotifyService Start";
764     CloudDiskNotify CloudDiskNotify;
765     NotifyParamService paramService;
766     paramService.cloudId = "rootId";
767     paramService.node.cloudId = "rootId";
768     paramService.node.isRecycled = true;
769     paramService.opsType = NotifyOpsType::SERVICE_UPDATE_RECYCLE;
770     ParamServiceOther paramOthers;
771     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
772     GTEST_LOG_(INFO) << "TryNotifyService End";
773 }
774 
775 /**
776  * @tc.name: TryNotifyServiceTest011
777  * @tc.desc: Verify the TryNotifyService function.
778  * @tc.type: FUNC
779  * @tc.require: I6H5MH
780  */
781 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest011, TestSize.Level1)
782 {
783     GTEST_LOG_(INFO) << "TryNotifyService Start";
784     CloudDiskNotify CloudDiskNotify;
785     NotifyParamService paramService;
786     paramService.cloudId = "";
787     paramService.opsType = NotifyOpsType::SERVICE_DELETE;
788     ParamServiceOther paramOthers;
789     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
790     GTEST_LOG_(INFO) << "TryNotifyService End";
791 }
792 
793 /**
794  * @tc.name: TryNotifyServiceTest012
795  * @tc.desc: Verify the TryNotifyService function.
796  * @tc.type: FUNC
797  * @tc.require: I6H5MH
798  */
799 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest012, TestSize.Level1)
800 {
801     GTEST_LOG_(INFO) << "TryNotifyService Start";
802     CloudDiskNotify CloudDiskNotify;
803     NotifyParamService paramService;
804     paramService.cloudId = "rootId";
805     paramService.opsType = NotifyOpsType::SERVICE_DELETE;
806     ParamServiceOther paramOthers;
807     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
808     GTEST_LOG_(INFO) << "TryNotifyService End";
809 }
810 
811 /**
812  * @tc.name: TryNotifyServiceTest013
813  * @tc.desc: Verify the TryNotifyService function.
814  * @tc.type: FUNC
815  * @tc.require: I6H5MH
816  */
817 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest013, TestSize.Level1)
818 {
819     GTEST_LOG_(INFO) << "TryNotifyService Start";
820     CloudDiskNotify CloudDiskNotify;
821     NotifyParamService paramService;
822     paramService.cloudId = "rootId";
823     paramService.opsType = NotifyOpsType::SERVICE_DELETE_BATCH;
824     ParamServiceOther paramOthers;
825     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
826     GTEST_LOG_(INFO) << "TryNotifyService End";
827 }
828 
829 /**
830  * @tc.name: TryNotifyServiceTest014
831  * @tc.desc: Verify the TryNotifyService function.
832  * @tc.type: FUNC
833  * @tc.require: I6H5MH
834  */
835 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest014, TestSize.Level1)
836 {
837     GTEST_LOG_(INFO) << "TryNotifyService Start";
838     CloudDiskNotify CloudDiskNotify;
839     NotifyParamService paramService;
840     paramService.opsType = NotifyOpsType::OPS_NONE;
841     ParamServiceOther paramOthers;
842     CloudDiskNotify.TryNotifyService(paramService, paramOthers);
843     GTEST_LOG_(INFO) << "TryNotifyService End";
844 }
845 
846 /**
847  * @tc.name: GetDeleteNotifyDataTest001
848  * @tc.desc: Verify the GetDeleteNotifyData function.
849  * @tc.type: FUNC
850  * @tc.require: I6H5MH
851  */
852 HWTEST_F(CloudDiskNotifyTest, GetDeleteNotifyDataTest001, TestSize.Level1)
853 {
854     GTEST_LOG_(INFO) << "GetDeleteNotifyData Start";
855     CloudDiskNotify CloudDiskNotify;
856     vector<NativeRdb::ValueObject> deleteIds;
857     NativeRdb::ValueObject mock0;
858     NativeRdb::ValueObject mock1;
859     deleteIds.push_back(mock0);
860     deleteIds.push_back(mock1);
861     vector<NotifyData> notifyDataList;
862     ParamServiceOther paramOthers;
863     paramOthers.bundleName = "com.ohos.photos";
864     paramOthers.userId = 100;
865     int32_t ret = CloudDiskNotify.GetDeleteNotifyData(deleteIds, notifyDataList, paramOthers);
866     EXPECT_EQ(ret, E_OK);
867     GTEST_LOG_(INFO) << "GetDeleteNotifyData End";
868 }
869 
870 /**
871  * @tc.name: AddNotifyTest001
872  * @tc.desc: Verify the AddNotify function.
873  * @tc.type: FUNC
874  * @tc.require: I6H5MH
875  */
876 HWTEST_F(CloudDiskNotifyTest, AddNotifyTest001, TestSize.Level1)
877 {
878     GTEST_LOG_(INFO) << "AddNotify Start";
879     CloudDiskNotify CloudDiskNotify;
880     NotifyData notifyData;
881     notifyData.type == NotifyType::NOTIFY_NONE;
882     CloudDiskNotify.AddNotify(notifyData);
883     GTEST_LOG_(INFO) << "AddNotify End";
884 }
885 
886 /**
887  * @tc.name: AddNotifyTest002
888  * @tc.desc: Verify the AddNotify function.
889  * @tc.type: FUNC
890  * @tc.require: I6H5MH
891  */
892 HWTEST_F(CloudDiskNotifyTest, AddNotifyTest002, TestSize.Level1)
893 {
894     GTEST_LOG_(INFO) << "AddNotify Start";
895     CloudDiskNotify CloudDiskNotify;
896     NotifyData notifyData;
897     notifyData.type == NotifyType::NOTIFY_ADDED;
898     CloudDiskNotify.AddNotify(notifyData);
899     GTEST_LOG_(INFO) << "AddNotify End";
900 }
901 
902 /**
903  * @tc.name: NotifyChangeOuterTest001
904  * @tc.desc: Verify the AddNotify function.
905  * @tc.type: FUNC
906  * @tc.require: I6H5MH
907  */
908 HWTEST_F(CloudDiskNotifyTest, NotifyChangeOuterTest001, TestSize.Level1)
909 {
910     GTEST_LOG_(INFO) << "NotifyChangeOuter Start";
911     CloudDiskNotify CloudDiskNotify;
912     CloudDiskNotify.NotifyChangeOuter();
913     GTEST_LOG_(INFO) << "NotifyChangeOuter End";
914 }
915 
916 /**
917  * @tc.name: NotifyChangeOuterTest002
918  * @tc.desc: Verify the AddNotify function.
919  * @tc.type: FUNC
920  * @tc.require: I6H5MH
921  */
922 HWTEST_F(CloudDiskNotifyTest, NotifyChangeOuterTest002, TestSize.Level1)
923 {
924     GTEST_LOG_(INFO) << "NotifyChangeOuter Start";
925     CacheNotifyInfo nf;
926     CloudDiskNotify CloudDiskNotify;
927     CloudDiskNotify.nfList_.push_back(nf);
928     CloudDiskNotify.NotifyChangeOuter();
929     GTEST_LOG_(INFO) << "NotifyChangeOuter End";
930 }
931 } // namespace Test
932 } // namespace FileManagement::CloudSync
933 } // namespace OHOS