1 /*
2 * Copyright (c) 2024-2025 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 */
574 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest024, TestSize.Level1)
575 {
576 GTEST_LOG_(INFO) << "TryNotify Start";
577 CloudDiskNotify CloudDiskNotify;
578 NotifyParamDisk paramDisk;
579 shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
580 paramDisk.inoPtr = ino;
581 paramDisk.data = new CloudDiskFuseData();
582 paramDisk.data->userId = 100;
583 paramDisk.opsType = NotifyOpsType::DAEMON_WRITE;
584 ParamDiskOthers paramOthers;
585 paramOthers.isWrite = false;
586 CloudDiskNotify.TryNotify(paramDisk, paramOthers);
587 delete paramDisk.data;
588 GTEST_LOG_(INFO) << "TryNotify End";
589 }
590
591 /**
592 * @tc.name: TryNotifyTest025
593 * @tc.desc: Verify the TryNotify function.
594 * @tc.type: FUNC
595 */
596 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest025, TestSize.Level1)
597 {
598 GTEST_LOG_(INFO) << "TryNotify Start";
599 CloudDiskNotify CloudDiskNotify;
600 NotifyParamDisk paramDisk;
601 shared_ptr<CloudDiskInode> ino = make_shared<CloudDiskInode>();
602 paramDisk.inoPtr = ino;
603 paramDisk.data = new CloudDiskFuseData();
604 paramDisk.data->userId = 100;
605 paramDisk.opsType = NotifyOpsType::DAEMON_WRITE;
606 ParamDiskOthers paramOthers;
607 paramOthers.isWrite = true;
608 CloudDiskNotify.TryNotify(paramDisk, paramOthers);
609 delete paramDisk.data;
610 GTEST_LOG_(INFO) << "TryNotify End";
611 }
612
613 /**
614 * @tc.name: TryNotifyTest026
615 * @tc.desc: Verify the TryNotify function.
616 * @tc.type: FUNC
617 * @tc.require: I6H5MH
618 */
619 HWTEST_F(CloudDiskNotifyTest, TryNotifyTest026, TestSize.Level1)
620 {
621 GTEST_LOG_(INFO) << "TryNotify Start";
622 CloudDiskNotify CloudDiskNotify;
623 NotifyParamDisk paramDisk;
624 ParamDiskOthers paramOthers;
625 paramOthers.dirtyType = static_cast<int32_t>(DirtyType::TYPE_NEW);
626 CloudDiskNotify.TryNotify(paramDisk, paramOthers);
627 GTEST_LOG_(INFO) << "TryNotify End";
628 }
629
630 /**
631 * @tc.name: TryNotifyServiceTest001
632 * @tc.desc: Verify the TryNotifyService function.
633 * @tc.type: FUNC
634 * @tc.require: I6H5MH
635 */
636 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest001, TestSize.Level1)
637 {
638 GTEST_LOG_(INFO) << "TryNotifyService Start";
639 CloudDiskNotify CloudDiskNotify;
640 NotifyParamService paramService;
641 paramService.node.isRecycled = true;
642 paramService.cloudId = "mock";
643 paramService.opsType = NotifyOpsType::SERVICE_INSERT;
644 ParamServiceOther paramOthers;
645 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
646 GTEST_LOG_(INFO) << "TryNotifyService End";
647 }
648
649 /**
650 * @tc.name: TryNotifyServiceTest002
651 * @tc.desc: Verify the TryNotifyService function.
652 * @tc.type: FUNC
653 * @tc.require: I6H5MH
654 */
655 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest002, TestSize.Level1)
656 {
657 GTEST_LOG_(INFO) << "TryNotifyService Start";
658 CloudDiskNotify CloudDiskNotify;
659 NotifyParamService paramService;
660 paramService.node.isRecycled = true;
661 paramService.cloudId = "rootId";
662 paramService.opsType = NotifyOpsType::SERVICE_INSERT;
663 ParamServiceOther paramOthers;
664 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
665 GTEST_LOG_(INFO) << "TryNotifyService End";
666 }
667
668 /**
669 * @tc.name: TryNotifyServiceTest003
670 * @tc.desc: Verify the TryNotifyService function.
671 * @tc.type: FUNC
672 * @tc.require: I6H5MH
673 */
674 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest003, TestSize.Level1)
675 {
676 GTEST_LOG_(INFO) << "TryNotifyService Start";
677 CloudDiskNotify CloudDiskNotify;
678 NotifyParamService paramService;
679 paramService.node.isRecycled = false;
680 paramService.node.cloudId = "mock";
681 paramService.opsType = NotifyOpsType::SERVICE_INSERT;
682 ParamServiceOther paramOthers;
683 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
684 GTEST_LOG_(INFO) << "TryNotifyService End";
685 }
686
687 /**
688 * @tc.name: TryNotifyServiceTest004
689 * @tc.desc: Verify the TryNotifyService function.
690 * @tc.type: FUNC
691 * @tc.require: I6H5MH
692 */
693 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest004, TestSize.Level1)
694 {
695 GTEST_LOG_(INFO) << "TryNotifyService Start";
696 CloudDiskNotify CloudDiskNotify;
697 NotifyParamService paramService;
698 paramService.cloudId = "mock";
699 paramService.opsType = NotifyOpsType::SERVICE_UPDATE;
700 ParamServiceOther paramOthers;
701 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
702 GTEST_LOG_(INFO) << "TryNotifyService End";
703 }
704
705 /**
706 * @tc.name: TryNotifyServiceTest005
707 * @tc.desc: Verify the TryNotifyService function.
708 * @tc.type: FUNC
709 * @tc.require: I6H5MH
710 */
711 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest005, TestSize.Level1)
712 {
713 GTEST_LOG_(INFO) << "TryNotifyService Start";
714 CloudDiskNotify CloudDiskNotify;
715 NotifyParamService paramService;
716 paramService.cloudId = "rootId";
717 paramService.node.fileName = "mock";
718 paramService.opsType = NotifyOpsType::SERVICE_UPDATE;
719 ParamServiceOther paramOthers;
720 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
721 GTEST_LOG_(INFO) << "TryNotifyService End";
722 }
723
724 /**
725 * @tc.name: TryNotifyServiceTest006
726 * @tc.desc: Verify the TryNotifyService function.
727 * @tc.type: FUNC
728 * @tc.require: I6H5MH
729 */
730 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest006, TestSize.Level1)
731 {
732 GTEST_LOG_(INFO) << "TryNotifyService Start";
733 CloudDiskNotify CloudDiskNotify;
734 NotifyParamService paramService;
735 paramService.cloudId = "rootId";
736 paramService.opsType = NotifyOpsType::SERVICE_UPDATE;
737 ParamServiceOther paramOthers;
738 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
739 GTEST_LOG_(INFO) << "TryNotifyService End";
740 }
741
742 /**
743 * @tc.name: TryNotifyServiceTest007
744 * @tc.desc: Verify the TryNotifyService function.
745 * @tc.type: FUNC
746 * @tc.require: I6H5MH
747 */
748 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest007, TestSize.Level1)
749 {
750 GTEST_LOG_(INFO) << "TryNotifyService Start";
751 CloudDiskNotify CloudDiskNotify;
752 NotifyParamService paramService;
753 paramService.cloudId = "mock";
754 paramService.opsType = NotifyOpsType::SERVICE_UPDATE_RECYCLE;
755 ParamServiceOther paramOthers;
756 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
757 GTEST_LOG_(INFO) << "TryNotifyService End";
758 }
759
760 /**
761 * @tc.name: TryNotifyServiceTest008
762 * @tc.desc: Verify the TryNotifyService function.
763 * @tc.type: FUNC
764 * @tc.require: I6H5MH
765 */
766 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest008, TestSize.Level1)
767 {
768 GTEST_LOG_(INFO) << "TryNotifyService Start";
769 CloudDiskNotify CloudDiskNotify;
770 NotifyParamService paramService;
771 paramService.cloudId = "rootId";
772 paramService.node.cloudId = "mock";
773 paramService.opsType = NotifyOpsType::SERVICE_UPDATE_RECYCLE;
774 ParamServiceOther paramOthers;
775 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
776 GTEST_LOG_(INFO) << "TryNotifyService End";
777 }
778
779 /**
780 * @tc.name: TryNotifyServiceTest009
781 * @tc.desc: Verify the TryNotifyService function.
782 * @tc.type: FUNC
783 * @tc.require: I6H5MH
784 */
785 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest009, TestSize.Level1)
786 {
787 GTEST_LOG_(INFO) << "TryNotifyService Start";
788 CloudDiskNotify CloudDiskNotify;
789 NotifyParamService paramService;
790 paramService.cloudId = "rootId";
791 paramService.node.cloudId = "rootId";
792 paramService.node.isRecycled = false;
793 paramService.opsType = NotifyOpsType::SERVICE_UPDATE_RECYCLE;
794 ParamServiceOther paramOthers;
795 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
796 GTEST_LOG_(INFO) << "TryNotifyService End";
797 }
798
799 /**
800 * @tc.name: TryNotifyServiceTest010
801 * @tc.desc: Verify the TryNotifyService function.
802 * @tc.type: FUNC
803 * @tc.require: I6H5MH
804 */
805 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest010, TestSize.Level1)
806 {
807 GTEST_LOG_(INFO) << "TryNotifyService Start";
808 CloudDiskNotify CloudDiskNotify;
809 NotifyParamService paramService;
810 paramService.cloudId = "rootId";
811 paramService.node.cloudId = "rootId";
812 paramService.node.isRecycled = true;
813 paramService.opsType = NotifyOpsType::SERVICE_UPDATE_RECYCLE;
814 ParamServiceOther paramOthers;
815 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
816 GTEST_LOG_(INFO) << "TryNotifyService End";
817 }
818
819 /**
820 * @tc.name: TryNotifyServiceTest011
821 * @tc.desc: Verify the TryNotifyService function.
822 * @tc.type: FUNC
823 * @tc.require: I6H5MH
824 */
825 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest011, TestSize.Level1)
826 {
827 GTEST_LOG_(INFO) << "TryNotifyService Start";
828 CloudDiskNotify CloudDiskNotify;
829 NotifyParamService paramService;
830 paramService.cloudId = "";
831 paramService.opsType = NotifyOpsType::SERVICE_DELETE;
832 ParamServiceOther paramOthers;
833 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
834 GTEST_LOG_(INFO) << "TryNotifyService End";
835 }
836
837 /**
838 * @tc.name: TryNotifyServiceTest012
839 * @tc.desc: Verify the TryNotifyService function.
840 * @tc.type: FUNC
841 * @tc.require: I6H5MH
842 */
843 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest012, TestSize.Level1)
844 {
845 GTEST_LOG_(INFO) << "TryNotifyService Start";
846 CloudDiskNotify CloudDiskNotify;
847 NotifyParamService paramService;
848 paramService.cloudId = "rootId";
849 paramService.opsType = NotifyOpsType::SERVICE_DELETE;
850 ParamServiceOther paramOthers;
851 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
852 GTEST_LOG_(INFO) << "TryNotifyService End";
853 }
854
855 /**
856 * @tc.name: TryNotifyServiceTest013
857 * @tc.desc: Verify the TryNotifyService function.
858 * @tc.type: FUNC
859 * @tc.require: I6H5MH
860 */
861 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest013, TestSize.Level1)
862 {
863 GTEST_LOG_(INFO) << "TryNotifyService Start";
864 CloudDiskNotify CloudDiskNotify;
865 NotifyParamService paramService;
866 paramService.cloudId = "rootId";
867 paramService.opsType = NotifyOpsType::SERVICE_DELETE_BATCH;
868 ParamServiceOther paramOthers;
869 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
870 GTEST_LOG_(INFO) << "TryNotifyService End";
871 }
872
873 /**
874 * @tc.name: TryNotifyServiceTest014
875 * @tc.desc: Verify the TryNotifyService function.
876 * @tc.type: FUNC
877 * @tc.require: I6H5MH
878 */
879 HWTEST_F(CloudDiskNotifyTest, TryNotifyServiceTest014, TestSize.Level1)
880 {
881 GTEST_LOG_(INFO) << "TryNotifyService Start";
882 CloudDiskNotify CloudDiskNotify;
883 NotifyParamService paramService;
884 paramService.opsType = NotifyOpsType::OPS_NONE;
885 ParamServiceOther paramOthers;
886 CloudDiskNotify.TryNotifyService(paramService, paramOthers);
887 GTEST_LOG_(INFO) << "TryNotifyService End";
888 }
889
890 /**
891 * @tc.name: GetDeleteNotifyDataTest001
892 * @tc.desc: Verify the GetDeleteNotifyData function.
893 * @tc.type: FUNC
894 * @tc.require: I6H5MH
895 */
896 HWTEST_F(CloudDiskNotifyTest, GetDeleteNotifyDataTest001, TestSize.Level1)
897 {
898 GTEST_LOG_(INFO) << "GetDeleteNotifyData Start";
899 CloudDiskNotify CloudDiskNotify;
900 vector<NativeRdb::ValueObject> deleteIds;
901 NativeRdb::ValueObject mock0;
902 NativeRdb::ValueObject mock1;
903 deleteIds.push_back(mock0);
904 deleteIds.push_back(mock1);
905 vector<NotifyData> notifyDataList;
906 ParamServiceOther paramOthers;
907 paramOthers.bundleName = "com.ohos.photos";
908 paramOthers.userId = 100;
909 int32_t ret = CloudDiskNotify.GetDeleteNotifyData(deleteIds, notifyDataList, paramOthers);
910 EXPECT_EQ(ret, E_OK);
911 GTEST_LOG_(INFO) << "GetDeleteNotifyData End";
912 }
913
914 /**
915 * @tc.name: AddNotifyTest001
916 * @tc.desc: Verify the AddNotify function.
917 * @tc.type: FUNC
918 * @tc.require: I6H5MH
919 */
920 HWTEST_F(CloudDiskNotifyTest, AddNotifyTest001, TestSize.Level1)
921 {
922 GTEST_LOG_(INFO) << "AddNotify Start";
923 CloudDiskNotify CloudDiskNotify;
924 NotifyData notifyData;
925 notifyData.type == NotifyType::NOTIFY_NONE;
926 CloudDiskNotify.AddNotify(notifyData);
927 GTEST_LOG_(INFO) << "AddNotify End";
928 }
929
930 /**
931 * @tc.name: AddNotifyTest002
932 * @tc.desc: Verify the AddNotify function.
933 * @tc.type: FUNC
934 * @tc.require: I6H5MH
935 */
936 HWTEST_F(CloudDiskNotifyTest, AddNotifyTest002, TestSize.Level1)
937 {
938 GTEST_LOG_(INFO) << "AddNotify Start";
939 CloudDiskNotify CloudDiskNotify;
940 NotifyData notifyData;
941 notifyData.type == NotifyType::NOTIFY_ADDED;
942 CloudDiskNotify.AddNotify(notifyData);
943 GTEST_LOG_(INFO) << "AddNotify End";
944 }
945
946 /**
947 * @tc.name: NotifyChangeOuterTest001
948 * @tc.desc: Verify the AddNotify function.
949 * @tc.type: FUNC
950 * @tc.require: I6H5MH
951 */
952 HWTEST_F(CloudDiskNotifyTest, NotifyChangeOuterTest001, TestSize.Level1)
953 {
954 GTEST_LOG_(INFO) << "NotifyChangeOuter Start";
955 CloudDiskNotify CloudDiskNotify;
956 CloudDiskNotify.NotifyChangeOuter();
957 GTEST_LOG_(INFO) << "NotifyChangeOuter End";
958 }
959
960 /**
961 * @tc.name: NotifyChangeOuterTest002
962 * @tc.desc: Verify the AddNotify function.
963 * @tc.type: FUNC
964 * @tc.require: I6H5MH
965 */
966 HWTEST_F(CloudDiskNotifyTest, NotifyChangeOuterTest002, TestSize.Level1)
967 {
968 GTEST_LOG_(INFO) << "NotifyChangeOuter Start";
969 CacheNotifyInfo nf;
970 CloudDiskNotify CloudDiskNotify;
971 CloudDiskNotify.nfList_.push_back(nf);
972 CloudDiskNotify.NotifyChangeOuter();
973 GTEST_LOG_(INFO) << "NotifyChangeOuter End";
974 }
975 } // namespace Test
976 } // namespace FileManagement::CloudSync
977 } // namespace OHOS