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 #include <gmock/gmock.h>
16 #include <gtest/gtest.h>
17 #include <memory>
18
19 #include "cloud_file_utils.h"
20 #include "cloud_status.h"
21 #include "clouddisk_notify_utils_mock.h"
22 #include "clouddisk_rdb_utils.h"
23 #include "clouddisk_rdbstore.h"
24 #include "dfs_error.h"
25 #include "rdb_assistant.h"
26 #include "result_set_mock.h"
27 #include "transaction_mock.cpp"
28
29 namespace OHOS::FileManagement::CloudDisk::Test {
30 using namespace testing;
31 using namespace testing::ext;
32 using namespace std;
33 using namespace NativeRdb;
34
35 static const string BUNDLE_NAME = "com.ohos.photos";
36 static const int32_t USER_ID = 100;
37 class CloudDiskRdbStoreTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 static inline shared_ptr<CloudDiskRdbStore> clouddiskrdbStore_ = nullptr;
44 static inline shared_ptr<AssistantMock> insMock = nullptr;
45 };
46
SetUpTestCase(void)47 void CloudDiskRdbStoreTest::SetUpTestCase(void)
48 {
49 GTEST_LOG_(INFO) << "SetUpTestCase";
50 insMock = make_shared<AssistantMock>();
51 Assistant::ins = insMock;
52 clouddiskrdbStore_ = make_shared<CloudDiskRdbStore>(BUNDLE_NAME, USER_ID);
53 }
54
TearDownTestCase(void)55 void CloudDiskRdbStoreTest::TearDownTestCase(void)
56 {
57 Assistant::ins = nullptr;
58 insMock = nullptr;
59 clouddiskrdbStore_ = nullptr;
60 GTEST_LOG_(INFO) << "TearDownTestCase";
61 }
62
SetUp(void)63 void CloudDiskRdbStoreTest::SetUp(void)
64 {
65 GTEST_LOG_(INFO) << "SetUp";
66 }
67
TearDown(void)68 void CloudDiskRdbStoreTest::TearDown(void)
69 {
70 GTEST_LOG_(INFO) << "TearDown";
71 }
72
73 /**
74 * @tc.name: ReBuildDatabase
75 * @tc.desc: Verify the CloudDiskRdbStore::ReBuildDatabase function
76 * @tc.type: FUNC
77 */
78 HWTEST_F(CloudDiskRdbStoreTest, ReBuildDatabaseTest1, TestSize.Level1)
79 {
80 string databasePath = "/data";
81 auto rdb = make_shared<RdbStoreMock>();
82 clouddiskrdbStore_->rdbStore_ = rdb;
83 EXPECT_CALL(*insMock, DeleteRdbStore(_)).WillOnce(Return(E_RDB));
84
85 int32_t ret = clouddiskrdbStore_->ReBuildDatabase(databasePath);
86 EXPECT_EQ(ret, E_RDB);
87 }
88
89 /**
90 * @tc.name: ReBuildDatabase
91 * @tc.desc: Verify the CloudDiskRdbStore::ReBuildDatabase function
92 * @tc.type: FUNC
93 */
94 HWTEST_F(CloudDiskRdbStoreTest, ReBuildDatabaseTest2, TestSize.Level1)
95 {
96 string databasePath = "/data";
97 auto rdb = make_shared<RdbStoreMock>();
98 clouddiskrdbStore_->rdbStore_ = rdb;
99 EXPECT_CALL(*insMock, DeleteRdbStore(_)).WillOnce(Return(E_OK));
100 EXPECT_CALL(*insMock, GetRdbStore(_, _, _, _)).WillOnce(Return(nullptr));
101
102 int32_t ret = clouddiskrdbStore_->ReBuildDatabase(databasePath);
103 EXPECT_EQ(ret, E_OK);
104 }
105
106 /**
107 * @tc.name: ReBuildDatabase
108 * @tc.desc: Verify the CloudDiskRdbStore::ReBuildDatabase function
109 * @tc.type: FUNC
110 */
111 HWTEST_F(CloudDiskRdbStoreTest, ReBuildDatabaseTest3, TestSize.Level1)
112 {
113 string databasePath = "/data";
114 auto rdb = make_shared<RdbStoreMock>();
115 clouddiskrdbStore_->rdbStore_ = rdb;
116 EXPECT_CALL(*insMock, DeleteRdbStore(_)).WillOnce(Return(E_OK));
117 EXPECT_CALL(*insMock, GetRdbStore(_, _, _, _)).WillOnce(Return(rdb));
118
119 int32_t ret = clouddiskrdbStore_->ReBuildDatabase(databasePath);
120 EXPECT_EQ(ret, E_OK);
121 }
122
123 /**
124 * @tc.name: RdbInit
125 * @tc.desc: Verify the CloudDiskRdbStore::RdbInit function
126 * @tc.type: FUNC
127 */
128 HWTEST_F(CloudDiskRdbStoreTest, RdbInitTest1, TestSize.Level1)
129 {
130 auto rdb = make_shared<RdbStoreMock>();
131 clouddiskrdbStore_->rdbStore_ = rdb;
132 EXPECT_CALL(*insMock, GetRdbStore(_, _, _, _)).WillOnce(Return(nullptr));
133
134 int32_t ret = clouddiskrdbStore_->RdbInit();
135 EXPECT_EQ(ret, E_OK);
136 }
137
138 /**
139 * @tc.name: RdbInit
140 * @tc.desc: Verify the CloudDiskRdbStore::RdbInit function
141 * @tc.type: FUNC
142 */
143 HWTEST_F(CloudDiskRdbStoreTest, RdbInitTest2, TestSize.Level1)
144 {
145 auto rdb = make_shared<RdbStoreMock>();
146 clouddiskrdbStore_->rdbStore_ = rdb;
147 EXPECT_CALL(*insMock, GetRdbStore(_, _, _, _)).WillOnce(Return(rdb));
148
149 int32_t ret = clouddiskrdbStore_->RdbInit();
150 EXPECT_EQ(ret, E_OK);
151 }
152
153 /**
154 * @tc.name: LookUp
155 * @tc.desc: Verify the CloudDiskRdbStore::LookUp function
156 * @tc.type: FUNC
157 */
158 HWTEST_F(CloudDiskRdbStoreTest, LookUpTest1, TestSize.Level1)
159 {
160 const std::string parentCloudId = "";
161 const std::string fileName = "test";
162 CloudDiskFileInfo info;
163 auto rdb = make_shared<RdbStoreMock>();
164 clouddiskrdbStore_->rdbStore_ = rdb;
165
166 int32_t ret = clouddiskrdbStore_->LookUp(parentCloudId, fileName, info);
167 EXPECT_EQ(ret, E_INVAL_ARG);
168 }
169
170 /**
171 * @tc.name: LookUp
172 * @tc.desc: Verify the CloudDiskRdbStore::LookUp function
173 * @tc.type: FUNC
174 */
175 HWTEST_F(CloudDiskRdbStoreTest, LookUpTest2, TestSize.Level1)
176 {
177 const std::string parentCloudId = "100";
178 const std::string fileName = "";
179 CloudDiskFileInfo info;
180 info.name = "mock";
181 auto rdb = make_shared<RdbStoreMock>();
182 clouddiskrdbStore_->rdbStore_ = rdb;
183
184 int32_t ret = clouddiskrdbStore_->LookUp(parentCloudId, fileName, info);
185 EXPECT_EQ(ret, E_INVAL_ARG);
186 }
187
188 /**
189 * @tc.name: LookUp
190 * @tc.desc: Verify the CloudDiskRdbStore::LookUp function
191 * @tc.type: FUNC
192 */
193 HWTEST_F(CloudDiskRdbStoreTest, LookUpTest3, TestSize.Level1)
194 {
195 const std::string parentCloudId = "rootId";
196 const std::string fileName = "test";
197 CloudDiskFileInfo info;
198 bool preCount = true;
199 auto rdb = make_shared<RdbStoreMock>();
200 clouddiskrdbStore_->rdbStore_ = rdb;
201 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
202 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
203 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
204 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
205
206 int32_t ret = clouddiskrdbStore_->LookUp(parentCloudId, fileName, info);
207 EXPECT_EQ(ret, E_RDB);
208 }
209
210 /**
211 * @tc.name: LookUp
212 * @tc.desc: Verify the CloudDiskRdbStore::LookUp function
213 * @tc.type: FUNC
214 */
215 HWTEST_F(CloudDiskRdbStoreTest, LookUpTest4, TestSize.Level1)
216 {
217 const std::string parentCloudId = "rootId";
218 const std::string fileName = "test";
219 CloudDiskFileInfo info;
220 bool preCount = true;
221 auto rdb = make_shared<RdbStoreMock>();
222 clouddiskrdbStore_->rdbStore_ = rdb;
223 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
224 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
225 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
226 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
227 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
228
229 int32_t ret = clouddiskrdbStore_->LookUp(parentCloudId, fileName, info);
230 EXPECT_EQ(ret, E_OK);
231 }
232
233 /**
234 * @tc.name: GetAttr
235 * @tc.desc: Verify the CloudDiskRdbStore::GetAttr function
236 * @tc.type: FUNC
237 */
238 HWTEST_F(CloudDiskRdbStoreTest, GetAttrTest1, TestSize.Level1)
239 {
240 const std::string cloudId = "";
241 CloudDiskFileInfo info;
242 auto rdb = make_shared<RdbStoreMock>();
243 clouddiskrdbStore_->rdbStore_ = rdb;
244
245 int32_t ret = clouddiskrdbStore_->GetAttr(cloudId, info);
246 EXPECT_EQ(ret, E_INVAL_ARG);
247 }
248
249 /**
250 * @tc.name: GetAttr
251 * @tc.desc: Verify the CloudDiskRdbStore::GetAttr function
252 * @tc.type: FUNC
253 */
254 HWTEST_F(CloudDiskRdbStoreTest, GetAttrTest2, TestSize.Level1)
255 {
256 const std::string cloudId = "rootId";
257 CloudDiskFileInfo info;
258 auto rdb = make_shared<RdbStoreMock>();
259 clouddiskrdbStore_->rdbStore_ = rdb;
260
261 int32_t ret = clouddiskrdbStore_->GetAttr(cloudId, info);
262 EXPECT_EQ(ret, E_INVAL_ARG);
263 }
264
265 /**
266 * @tc.name: GetAttr
267 * @tc.desc: Verify the CloudDiskRdbStore::GetAttr function
268 * @tc.type: FUNC
269 */
270 HWTEST_F(CloudDiskRdbStoreTest, GetAttrTest3, TestSize.Level1)
271 {
272 const std::string cloudId = "100";
273 CloudDiskFileInfo info;
274 bool preCount = true;
275 auto rdb = make_shared<RdbStoreMock>();
276 clouddiskrdbStore_->rdbStore_ = rdb;
277 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
278 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
279 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
280 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
281
282 int32_t ret = clouddiskrdbStore_->GetAttr(cloudId, info);
283 EXPECT_EQ(ret, E_RDB);
284 }
285
286 /**
287 * @tc.name: GetAttr
288 * @tc.desc: Verify the CloudDiskRdbStore::GetAttr function
289 * @tc.type: FUNC
290 */
291 HWTEST_F(CloudDiskRdbStoreTest, GetAttrTest4, TestSize.Level1)
292 {
293 const std::string cloudId = "100";
294 CloudDiskFileInfo info;
295 bool preCount = true;
296 auto rdb = make_shared<RdbStoreMock>();
297 clouddiskrdbStore_->rdbStore_ = rdb;
298 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
299 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
300 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
301 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
302 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
303
304 int32_t ret = clouddiskrdbStore_->GetAttr(cloudId, info);
305 EXPECT_EQ(ret, E_OK);
306 }
307
308 /**
309 * @tc.name: SetAttr
310 * @tc.desc: Verify the CloudDiskRdbStore::SetAttr function
311 * @tc.type: FUNC
312 */
313 HWTEST_F(CloudDiskRdbStoreTest, SetAttrTest1, TestSize.Level1)
314 {
315 const std::string fileName = "Test";
316 const std::string parentCloudId = "100";
317 const std::string cloudId = "";
318 const unsigned long long size = 0;
319 auto rdb = make_shared<RdbStoreMock>();
320 clouddiskrdbStore_->rdbStore_ = rdb;
321 int32_t ret = clouddiskrdbStore_->SetAttr(fileName, parentCloudId, cloudId, size);
322 EXPECT_EQ(ret, E_INVAL_ARG);
323 }
324
325 /**
326 * @tc.name: SetAttr
327 * @tc.desc: Verify the CloudDiskRdbStore::SetAttr function
328 * @tc.type: FUNC
329 */
330 HWTEST_F(CloudDiskRdbStoreTest, SetAttrTest2, TestSize.Level1)
331 {
332 const std::string fileName = "Test";
333 const std::string parentCloudId = "100";
334 const std::string cloudId = "rootId";
335 const unsigned long long size = 0;
336 auto rdb = make_shared<RdbStoreMock>();
337 clouddiskrdbStore_->rdbStore_ = rdb;
338 int32_t ret = clouddiskrdbStore_->SetAttr(fileName, parentCloudId, cloudId, size);
339 EXPECT_EQ(ret, E_INVAL_ARG);
340 }
341
342 /**
343 * @tc.name: SetAttr
344 * @tc.desc: Verify the CloudDiskRdbStore::SetAttr function
345 * @tc.type: FUNC
346 */
347 HWTEST_F(CloudDiskRdbStoreTest, SetAttrTest3, TestSize.Level1)
348 {
349 const std::string fileName = "mock";
350 const std::string parentCloudId = "100";
351 const std::string cloudId = "100";
352 const unsigned long long size = 0;
353 auto rdb = make_shared<RdbStoreMock>();
354 clouddiskrdbStore_->rdbStore_ = rdb;
355
356 auto transaction = make_shared<TransactionMock>();
357 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
358 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
359
360 int32_t ret = clouddiskrdbStore_->SetAttr(fileName, parentCloudId, cloudId, size);
361 EXPECT_EQ(ret, E_RDB);
362 }
363
364 /**
365 * @tc.name: SetAttr
366 * @tc.desc: Verify the CloudDiskRdbStore::SetAttr function
367 * @tc.type: FUNC
368 */
369 HWTEST_F(CloudDiskRdbStoreTest, SetAttrTest4, TestSize.Level1)
370 {
371 const std::string fileName = "mock";
372 const std::string parentCloudId = "100";
373 const std::string cloudId = "100";
374 const unsigned long long size = 0;
375 auto rdb = make_shared<RdbStoreMock>();
376 clouddiskrdbStore_->rdbStore_ = rdb;
377
378 auto transaction = make_shared<TransactionMock>();
379 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
380 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
381
382 int32_t ret = clouddiskrdbStore_->SetAttr(fileName, parentCloudId, cloudId, size);
383 EXPECT_EQ(ret, E_RDB);
384 }
385
386 /**
387 * @tc.name: SetAttr
388 * @tc.desc: Verify the CloudDiskRdbStore::SetAttr function
389 * @tc.type: FUNC
390 */
391 HWTEST_F(CloudDiskRdbStoreTest, SetAttrTest5, TestSize.Level1)
392 {
393 const std::string fileName = "test";
394 const std::string parentCloudId = "100";
395 const std::string cloudId = "100";
396 const unsigned long long size = 0;
397 auto rdb = make_shared<RdbStoreMock>();
398 clouddiskrdbStore_->rdbStore_ = rdb;
399
400 auto transaction = make_shared<TransactionMock>();
401 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
402 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
403
404 int32_t ret = clouddiskrdbStore_->SetAttr(fileName, parentCloudId, cloudId, size);
405 EXPECT_EQ(ret, E_OK);
406 }
407
408 /**
409 * @tc.name: ReadDir
410 * @tc.desc: Verify the CloudDiskRdbStore::ReadDir function
411 * @tc.type: FUNC
412 */
413 HWTEST_F(CloudDiskRdbStoreTest, ReadDirTest1, TestSize.Level1)
414 {
415 const std::string cloudId = "rootId";
416 vector<CloudDiskFileInfo> infos;
417 bool preCount = true;
418 auto rdb = make_shared<RdbStoreMock>();
419 clouddiskrdbStore_->rdbStore_ = rdb;
420 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
421 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
422 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
423
424 int32_t ret = clouddiskrdbStore_->ReadDir(cloudId, infos);
425 EXPECT_EQ(ret, E_RDB);
426 }
427
428 /**
429 * @tc.name: Create
430 * @tc.desc: Verify the CloudDiskRdbStore::Create function
431 * @tc.type: FUNC
432 */
433 HWTEST_F(CloudDiskRdbStoreTest, CreateTest1, TestSize.Level1)
434 {
435 const std::string cloudId = "rootId";
436 const std::string parentCloudId = "100";
437 const std::string fileName = "";
438 bool noNeedUpload = false;
439 auto rdb = make_shared<RdbStoreMock>();
440 clouddiskrdbStore_->rdbStore_ = rdb;
441 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
442 EXPECT_EQ(ret, EINVAL);
443 }
444
445 /**
446 * @tc.name: Create
447 * @tc.desc: Verify the CloudDiskRdbStore::Create function
448 * @tc.type: FUNC
449 */
450 HWTEST_F(CloudDiskRdbStoreTest, CreateTest2, TestSize.Level1)
451 {
452 const std::string cloudId = "rootId";
453 const std::string parentCloudId = "100";
454 const std::string fileName = "<|>";
455 bool noNeedUpload = false;
456 auto rdb = make_shared<RdbStoreMock>();
457 clouddiskrdbStore_->rdbStore_ = rdb;
458 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
459 EXPECT_EQ(ret, EINVAL);
460 }
461
462 /**
463 * @tc.name: Create
464 * @tc.desc: Verify the CloudDiskRdbStore::Create function
465 * @tc.type: FUNC
466 */
467 HWTEST_F(CloudDiskRdbStoreTest, CreateTest3, TestSize.Level1)
468 {
469 const std::string cloudId = "rootId";
470 const std::string parentCloudId = "100";
471 const std::string fileName = " test";
472 bool noNeedUpload = false;
473 auto rdb = make_shared<RdbStoreMock>();
474 clouddiskrdbStore_->rdbStore_ = rdb;
475 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
476 EXPECT_EQ(ret, EINVAL);
477 }
478
479 /**
480 * @tc.name: Create
481 * @tc.desc: Verify the CloudDiskRdbStore::Create function
482 * @tc.type: FUNC
483 */
484 HWTEST_F(CloudDiskRdbStoreTest, CreateTest4, TestSize.Level1)
485 {
486 const std::string cloudId = "";
487 const std::string parentCloudId = "";
488 const std::string fileName = "test";
489 bool noNeedUpload = false;
490 auto rdb = make_shared<RdbStoreMock>();
491 clouddiskrdbStore_->rdbStore_ = rdb;
492 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
493 EXPECT_EQ(ret, E_INVAL_ARG);
494 }
495
496 /**
497 * @tc.name: Create
498 * @tc.desc: Verify the CloudDiskRdbStore::Create function
499 * @tc.type: FUNC
500 */
501 HWTEST_F(CloudDiskRdbStoreTest, CreateTest5, TestSize.Level1)
502 {
503 const std::string cloudId = "rootId";
504 const std::string parentCloudId = "100";
505 const std::string fileName = "test";
506 bool noNeedUpload = false;
507 clouddiskrdbStore_->userId_ = 0;
508 auto rdb = make_shared<RdbStoreMock>();
509 clouddiskrdbStore_->rdbStore_ = rdb;
510 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
511 EXPECT_EQ(ret, E_PATH);
512 }
513
514 /**
515 * @tc.name: Create
516 * @tc.desc: Verify the CloudDiskRdbStore::Create function
517 * @tc.type: FUNC
518 */
519 HWTEST_F(CloudDiskRdbStoreTest, CreateTest6, TestSize.Level1)
520 {
521 const std::string cloudId = "rootId";
522 const std::string parentCloudId = "100";
523 const std::string fileName = "test";
524 bool noNeedUpload = true;
525 clouddiskrdbStore_->userId_ = 1;
526 auto rdb = make_shared<RdbStoreMock>();
527 clouddiskrdbStore_->rdbStore_ = rdb;
528
529 auto transaction = make_shared<TransactionMock>();
530 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
531 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
532
533 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
534 EXPECT_EQ(ret, E_RDB);
535 }
536
537 /**
538 * @tc.name: Create
539 * @tc.desc: Verify the CloudDiskRdbStore::Create function
540 * @tc.type: FUNC
541 */
542 HWTEST_F(CloudDiskRdbStoreTest, CreateTest7, TestSize.Level1)
543 {
544 const std::string cloudId = "rootId";
545 const std::string parentCloudId = "100";
546 const std::string fileName = "mock";
547 bool noNeedUpload = true;
548 clouddiskrdbStore_->userId_ = 1;
549 auto rdb = make_shared<RdbStoreMock>();
550 clouddiskrdbStore_->rdbStore_ = rdb;
551
552 auto transaction = make_shared<TransactionMock>();
553 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
554 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
555
556 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
557 EXPECT_EQ(ret, E_RDB);
558 }
559
560 /**
561 * @tc.name: Create
562 * @tc.desc: Verify the CloudDiskRdbStore::Create function
563 * @tc.type: FUNC
564 */
565 HWTEST_F(CloudDiskRdbStoreTest, CreateTest8, TestSize.Level1)
566 {
567 const std::string cloudId = "rootId";
568 const std::string parentCloudId = "100";
569 const std::string fileName = "test";
570 bool noNeedUpload = true;
571 clouddiskrdbStore_->userId_ = 1;
572 auto rdb = make_shared<RdbStoreMock>();
573 clouddiskrdbStore_->rdbStore_ = rdb;
574
575 auto transaction = make_shared<TransactionMock>();
576 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
577 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
578
579 int32_t ret = clouddiskrdbStore_->Create(cloudId, parentCloudId, fileName, noNeedUpload);
580 EXPECT_EQ(ret, E_RDB);
581 }
582
583 /**
584 * @tc.name: MkDir
585 * @tc.desc: Verify the CloudDiskRdbStore::MkDir function
586 * @tc.type: FUNC
587 */
588 HWTEST_F(CloudDiskRdbStoreTest, MkDirTest1, TestSize.Level1)
589 {
590 const std::string cloudId = "100";
591 const std::string parentCloudId = "100";
592 const std::string directoryName = "";
593 bool noNeedUpload = false;
594 auto rdb = make_shared<RdbStoreMock>();
595 clouddiskrdbStore_->rdbStore_ = rdb;
596 int32_t ret = clouddiskrdbStore_->MkDir(cloudId, parentCloudId, directoryName, noNeedUpload);
597 EXPECT_EQ(ret, EINVAL);
598 }
599
600 /**
601 * @tc.name: MkDir
602 * @tc.desc: Verify the CloudDiskRdbStore::MkDir function
603 * @tc.type: FUNC
604 */
605 HWTEST_F(CloudDiskRdbStoreTest, MkDirTest2, TestSize.Level1)
606 {
607 const std::string cloudId = "100";
608 const std::string parentCloudId = "100";
609 const std::string directoryName = ".trash";
610 bool noNeedUpload = false;
611 auto rdb = make_shared<RdbStoreMock>();
612 clouddiskrdbStore_->rdbStore_ = rdb;
613 int32_t ret = clouddiskrdbStore_->MkDir(cloudId, parentCloudId, directoryName, noNeedUpload);
614 EXPECT_EQ(ret, EINVAL);
615 }
616
617 /**
618 * @tc.name: MkDir
619 * @tc.desc: Verify the CloudDiskRdbStore::MkDir function
620 * @tc.type: FUNC
621 */
622 HWTEST_F(CloudDiskRdbStoreTest, MkDirTest3, TestSize.Level1)
623 {
624 const std::string cloudId = "";
625 const std::string parentCloudId = "";
626 const std::string directoryName = "test";
627 bool noNeedUpload = false;
628 auto rdb = make_shared<RdbStoreMock>();
629 clouddiskrdbStore_->rdbStore_ = rdb;
630 int32_t ret = clouddiskrdbStore_->MkDir(cloudId, parentCloudId, directoryName, noNeedUpload);
631 EXPECT_EQ(ret, E_INVAL_ARG);
632 }
633
634 /**
635 * @tc.name: MkDir
636 * @tc.desc: Verify the CloudDiskRdbStore::MkDir function
637 * @tc.type: FUNC
638 */
639 HWTEST_F(CloudDiskRdbStoreTest, MkDirTest4, TestSize.Level1)
640 {
641 const std::string cloudId = "100";
642 const std::string parentCloudId = "100";
643 const std::string directoryName = "mock";
644 bool noNeedUpload = false;
645 auto rdb = make_shared<RdbStoreMock>();
646 clouddiskrdbStore_->rdbStore_ = rdb;
647
648 auto transaction = make_shared<TransactionMock>();
649 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
650 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
651
652 int32_t ret = clouddiskrdbStore_->MkDir(cloudId, parentCloudId, directoryName, noNeedUpload);
653 EXPECT_EQ(ret, E_RDB);
654 }
655
656 /**
657 * @tc.name: MkDir
658 * @tc.desc: Verify the CloudDiskRdbStore::MkDir function
659 * @tc.type: FUNC
660 */
661 HWTEST_F(CloudDiskRdbStoreTest, MkDirTest5, TestSize.Level1)
662 {
663 const std::string cloudId = "100";
664 const std::string parentCloudId = "100";
665 const std::string directoryName = "mock";
666 bool noNeedUpload = true;
667 auto rdb = make_shared<RdbStoreMock>();
668 clouddiskrdbStore_->rdbStore_ = rdb;
669
670 auto transaction = make_shared<TransactionMock>();
671 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
672 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
673
674 int32_t ret = clouddiskrdbStore_->MkDir(cloudId, parentCloudId, directoryName, noNeedUpload);
675 EXPECT_EQ(ret, E_RDB);
676 }
677
678 /**
679 * @tc.name: MkDir
680 * @tc.desc: Verify the CloudDiskRdbStore::MkDir function
681 * @tc.type: FUNC
682 */
683 HWTEST_F(CloudDiskRdbStoreTest, MkDirTest6, TestSize.Level1)
684 {
685 const std::string cloudId = "100";
686 const std::string parentCloudId = "100";
687 const std::string directoryName = "test";
688 bool noNeedUpload = true;
689 auto rdb = make_shared<RdbStoreMock>();
690 clouddiskrdbStore_->rdbStore_ = rdb;
691
692 auto transaction = make_shared<TransactionMock>();
693 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
694 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
695
696 int32_t ret = clouddiskrdbStore_->MkDir(cloudId, parentCloudId, directoryName, noNeedUpload);
697 EXPECT_EQ(ret, E_RDB);
698 }
699
700 /**
701 * @tc.name: Write
702 * @tc.desc: Verify the CloudDiskRdbStore::Write function
703 * @tc.type: FUNC
704 */
705 HWTEST_F(CloudDiskRdbStoreTest, WriteTest1, TestSize.Level1)
706 {
707 const std::string cloudId = "";
708 const std::string parentCloudId = "100";
709 const std::string fileName = "file";
710 auto rdb = make_shared<RdbStoreMock>();
711 clouddiskrdbStore_->rdbStore_ = rdb;
712
713 int32_t ret = clouddiskrdbStore_->Write(fileName, parentCloudId, cloudId);
714 EXPECT_EQ(ret, E_INVAL_ARG);
715 }
716
717 /**
718 * @tc.name: Write
719 * @tc.desc: Verify the CloudDiskRdbStore::Write function
720 * @tc.type: FUNC
721 */
722 HWTEST_F(CloudDiskRdbStoreTest, WriteTest2, TestSize.Level1)
723 {
724 const std::string cloudId = "rootId";
725 const std::string fileName = "file";
726 const std::string parentCloudId = "rootId";
727 auto rdb = make_shared<RdbStoreMock>();
728 clouddiskrdbStore_->rdbStore_ = rdb;
729
730 int32_t ret = clouddiskrdbStore_->Write(fileName, parentCloudId, cloudId);
731 EXPECT_EQ(ret, E_INVAL_ARG);
732 }
733
734 /**
735 * @tc.name: Write
736 * @tc.desc: Verify the CloudDiskRdbStore::Write function
737 * @tc.type: FUNC
738 */
739 HWTEST_F(CloudDiskRdbStoreTest, WriteTest3, TestSize.Level1)
740 {
741 const std::string cloudId = "100";
742 const std::string fileName = "file";
743 const std::string parentCloudId = "rootId";
744 auto rdb = make_shared<RdbStoreMock>();
745 clouddiskrdbStore_->rdbStore_ = rdb;
746 clouddiskrdbStore_->userId_ = 0;
747
748 int32_t ret = clouddiskrdbStore_->Write(fileName, parentCloudId, cloudId);
749 EXPECT_EQ(ret, E_PATH);
750 }
751
752 /**
753 * @tc.name: Write
754 * @tc.desc: Verify the CloudDiskRdbStore::Write function
755 * @tc.type: FUNC
756 */
757 HWTEST_F(CloudDiskRdbStoreTest, WriteTest4, TestSize.Level1)
758 {
759 const std::string cloudId = "100";
760 const std::string fileName = "mock";
761 const std::string parentCloudId = "rootId";
762 bool preCount = true;
763 auto rdb = make_shared<RdbStoreMock>();
764 clouddiskrdbStore_->rdbStore_ = rdb;
765 clouddiskrdbStore_->userId_ = 1;
766 auto transaction = make_shared<TransactionMock>();
767 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
768 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
769 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
770 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
771 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
772
773 int32_t ret = clouddiskrdbStore_->Write(fileName, parentCloudId, cloudId);
774 EXPECT_EQ(ret, E_RDB);
775 }
776
777 /**
778 * @tc.name: Write
779 * @tc.desc: Verify the CloudDiskRdbStore::Write function
780 * @tc.type: FUNC
781 */
782 HWTEST_F(CloudDiskRdbStoreTest, WriteTest5, TestSize.Level1)
783 {
784 const std::string cloudId = "100";
785 const std::string fileName = "mock";
786 const std::string parentCloudId = "rootId";
787 bool preCount = true;
788 auto rdb = make_shared<RdbStoreMock>();
789 clouddiskrdbStore_->rdbStore_ = rdb;
790 clouddiskrdbStore_->userId_ = 1;
791 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
792 auto transaction = make_shared<TransactionMock>();
793 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
794 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
795 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
796 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
797 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
798
799 int32_t ret = clouddiskrdbStore_->Write(fileName, parentCloudId, cloudId);
800 EXPECT_EQ(ret, E_RDB);
801 }
802
803 /**
804 * @tc.name: Write
805 * @tc.desc: Verify the CloudDiskRdbStore::Write function
806 * @tc.type: FUNC
807 */
808 HWTEST_F(CloudDiskRdbStoreTest, WriteTest6, TestSize.Level1)
809 {
810 const std::string cloudId = "100";
811 const std::string fileName = "mock";
812 const std::string parentCloudId = "rootId";
813 bool preCount = true;
814 auto rdb = make_shared<RdbStoreMock>();
815 clouddiskrdbStore_->rdbStore_ = rdb;
816 clouddiskrdbStore_->userId_ = 1;
817 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
818 auto transaction = make_shared<TransactionMock>();
819 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
820 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
821 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
822 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
823 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
824
825 int32_t ret = clouddiskrdbStore_->Write(fileName, parentCloudId, cloudId);
826 EXPECT_EQ(ret, E_RDB);
827 }
828
829 /**
830 * @tc.name: LocationSetXattr
831 * @tc.desc: Verify the CloudDiskRdbStore::LocationSetXattr function
832 * @tc.type: FUNC
833 */
834 HWTEST_F(CloudDiskRdbStoreTest, LocationSetXattrTest1, TestSize.Level1)
835 {
836 const std::string name = "test";
837 const std::string parentCloudId = "100";
838 const std::string cloudId = "100";
839 const std::string value = "4";
840 auto rdb = make_shared<RdbStoreMock>();
841 clouddiskrdbStore_->rdbStore_ = rdb;
842 int32_t ret = clouddiskrdbStore_->LocationSetXattr(name, parentCloudId, cloudId, value);
843 EXPECT_EQ(ret, E_INVAL_ARG);
844 }
845
846 /**
847 * @tc.name: LocationSetXattr
848 * @tc.desc: Verify the CloudDiskRdbStore::LocationSetXattr function
849 * @tc.type: FUNC
850 */
851 HWTEST_F(CloudDiskRdbStoreTest, LocationSetXattrTest2, TestSize.Level1)
852 {
853 const std::string name = "mock";
854 const std::string parentCloudId = "100";
855 const std::string cloudId = "100";
856 const std::string value = "1";
857 auto rdb = make_shared<RdbStoreMock>();
858 clouddiskrdbStore_->rdbStore_ = rdb;
859 auto transaction = make_shared<TransactionMock>();
860 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
861 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
862
863 int32_t ret = clouddiskrdbStore_->LocationSetXattr(name, parentCloudId, cloudId, value);
864 EXPECT_EQ(ret, E_RDB);
865 }
866
867 /**
868 * @tc.name: LocationSetXattr
869 * @tc.desc: Verify the CloudDiskRdbStore::LocationSetXattr function
870 * @tc.type: FUNC
871 */
872 HWTEST_F(CloudDiskRdbStoreTest, LocationSetXattrTest3, TestSize.Level1)
873 {
874 const std::string name = "mock";
875 const std::string parentCloudId = "100";
876 const std::string cloudId = "100";
877 const std::string value = "1";
878 auto rdb = make_shared<RdbStoreMock>();
879 clouddiskrdbStore_->rdbStore_ = rdb;
880 auto transaction = make_shared<TransactionMock>();
881 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
882 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
883
884 int32_t ret = clouddiskrdbStore_->LocationSetXattr(name, parentCloudId, cloudId, value);
885 EXPECT_EQ(ret, E_RDB);
886 }
887
888 /**
889 * @tc.name: LocationSetXattr
890 * @tc.desc: Verify the CloudDiskRdbStore::LocationSetXattr function
891 * @tc.type: FUNC
892 */
893 HWTEST_F(CloudDiskRdbStoreTest, LocationSetXattrTest4, TestSize.Level1)
894 {
895 const std::string name = "test";
896 const std::string parentCloudId = "100";
897 const std::string cloudId = "100";
898 const std::string value = "1";
899 auto rdb = make_shared<RdbStoreMock>();
900 clouddiskrdbStore_->rdbStore_ = rdb;
901 auto transaction = make_shared<TransactionMock>();
902 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
903 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
904
905 int32_t ret = clouddiskrdbStore_->LocationSetXattr(name, parentCloudId, cloudId, value);
906 EXPECT_EQ(ret, E_RDB);
907 }
908
909 /**
910 * @tc.name: HasTHMSetXattr
911 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
912 * @tc.type: FUNC
913 */
914 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest1, TestSize.Level1)
915 {
916 const std::string name = "test";
917 const std::string key = "100";
918 const std::string cloudId = "100";
919 const std::string value = "test";
920 auto rdb = make_shared<RdbStoreMock>();
921 clouddiskrdbStore_->rdbStore_ = rdb;
922
923 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
924 EXPECT_EQ(ret, E_INVAL_ARG);
925 }
926
927 /**
928 * @tc.name: HasTHMSetXattr
929 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
930 * @tc.type: FUNC
931 */
932 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest2, TestSize.Level1)
933 {
934 const std::string name = "test";
935 const std::string key = "100";
936 const std::string cloudId = "100";
937 const std::string value = "2";
938 auto rdb = make_shared<RdbStoreMock>();
939 clouddiskrdbStore_->rdbStore_ = rdb;
940
941 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
942 EXPECT_EQ(ret, E_INVAL_ARG);
943 }
944
945 /**
946 * @tc.name: HasTHMSetXattr
947 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
948 * @tc.type: FUNC
949 */
950 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest3, TestSize.Level1)
951 {
952 const std::string name = "test";
953 const std::string key = CLOUD_HAS_LCD;
954 const std::string cloudId = "100";
955 const std::string value = "0";
956 bool preCount = true;
957 auto rdb = make_shared<RdbStoreMock>();
958 clouddiskrdbStore_->rdbStore_ = rdb;
959 auto transaction = make_shared<TransactionMock>();
960 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
961 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
962 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
963 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
964 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
965 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
966
967 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
968 EXPECT_EQ(ret, E_OK);
969 }
970
971 /**
972 * @tc.name: HasTHMSetXattr
973 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
974 * @tc.type: FUNC
975 */
976 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest4, TestSize.Level1)
977 {
978 const std::string name = "test";
979 const std::string key = CLOUD_HAS_THM;
980 const std::string cloudId = "100";
981 const std::string value = "0";
982 bool preCount = true;
983 auto rdb = make_shared<RdbStoreMock>();
984 clouddiskrdbStore_->rdbStore_ = rdb;
985 auto transaction = make_shared<TransactionMock>();
986 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
987 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
988 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
989 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
990 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
991 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
992
993 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
994 EXPECT_EQ(ret, E_OK);
995 }
996
997 /**
998 * @tc.name: HasTHMSetXattr
999 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
1000 * @tc.type: FUNC
1001 */
1002 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest5, TestSize.Level1)
1003 {
1004 const std::string name = "test";
1005 const std::string key = CLOUD_HAS_LCD;
1006 const std::string cloudId = "100";
1007 const std::string value = "1";
1008 bool preCount = true;
1009 auto rdb = make_shared<RdbStoreMock>();
1010 clouddiskrdbStore_->rdbStore_ = rdb;
1011 auto transaction = make_shared<TransactionMock>();
1012 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1013 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1014 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1015 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1016 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1017 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
1018
1019 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
1020 EXPECT_EQ(ret, E_OK);
1021 }
1022
1023 /**
1024 * @tc.name: HasTHMSetXattr
1025 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
1026 * @tc.type: FUNC
1027 */
1028 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest6, TestSize.Level1)
1029 {
1030 const std::string name = "test";
1031 const std::string key = CLOUD_HAS_THM;
1032 const std::string cloudId = "100";
1033 const std::string value = "1";
1034 bool preCount = true;
1035 auto rdb = make_shared<RdbStoreMock>();
1036 clouddiskrdbStore_->rdbStore_ = rdb;
1037 auto transaction = make_shared<TransactionMock>();
1038 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1039 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1040 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1041 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1042 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1043 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
1044
1045 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
1046 EXPECT_EQ(ret, E_OK);
1047 }
1048
1049 /**
1050 * @tc.name: HasTHMSetXattr
1051 * @tc.desc: Verify the CloudDiskRdbStore::HasTHMSetXattr function
1052 * @tc.type: FUNC
1053 */
1054 HWTEST_F(CloudDiskRdbStoreTest, HasTHMSetXattrTest7, TestSize.Level1)
1055 {
1056 const std::string name = "test";
1057 const std::string key = CLOUD_HAS_THM;
1058 const std::string cloudId = "100";
1059 const std::string value = "1";
1060 bool preCount = true;
1061 auto rdb = make_shared<RdbStoreMock>();
1062 clouddiskrdbStore_->rdbStore_ = rdb;
1063 auto transaction = make_shared<TransactionMock>();
1064 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1065 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1066 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1067 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1068 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1069 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
1070
1071 int32_t ret = clouddiskrdbStore_->HasTHMSetXattr(name, key, cloudId, value);
1072 EXPECT_EQ(ret, E_RDB);
1073 }
1074
1075 /**
1076 * @tc.name: GetRowId
1077 * @tc.desc: Verify the CloudDiskRdbStore::GetRowId function
1078 * @tc.type: FUNC
1079 */
1080 HWTEST_F(CloudDiskRdbStoreTest, GetRowIdTest1, TestSize.Level1)
1081 {
1082 const std::string cloudId = "100";
1083 int64_t rowId = 100;
1084 bool preCount = true;
1085 auto rdb = make_shared<RdbStoreMock>();
1086 clouddiskrdbStore_->rdbStore_ = rdb;
1087 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1088 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1089
1090 int32_t ret = clouddiskrdbStore_->GetRowId(cloudId, rowId);
1091 EXPECT_EQ(ret, E_RDB);
1092 }
1093
1094 /**
1095 * @tc.name: GetRowId
1096 * @tc.desc: Verify the CloudDiskRdbStore::GetRowId function
1097 * @tc.type: FUNC
1098 */
1099 HWTEST_F(CloudDiskRdbStoreTest, GetRowIdTest2, TestSize.Level1)
1100 {
1101 const std::string cloudId = "100";
1102 int64_t rowId = 100;
1103 bool preCount = true;
1104 auto rdb = make_shared<RdbStoreMock>();
1105 clouddiskrdbStore_->rdbStore_ = rdb;
1106 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1107 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1108 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1109 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
1110
1111 int32_t ret = clouddiskrdbStore_->GetRowId(cloudId, rowId);
1112 EXPECT_EQ(ret, E_RDB);
1113 }
1114
1115 /**
1116 * @tc.name: GetRowId
1117 * @tc.desc: Verify the CloudDiskRdbStore::GetRowId function
1118 * @tc.type: FUNC
1119 */
1120 HWTEST_F(CloudDiskRdbStoreTest, GetRowIdTest3, TestSize.Level1)
1121 {
1122 const std::string cloudId = "100";
1123 int64_t rowId = 100;
1124 bool preCount = true;
1125 auto rdb = make_shared<RdbStoreMock>();
1126 clouddiskrdbStore_->rdbStore_ = rdb;
1127 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1128 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1129 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1130 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1131 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
1132
1133 int32_t ret = clouddiskrdbStore_->GetRowId(cloudId, rowId);
1134 EXPECT_EQ(ret, E_OK);
1135 }
1136
1137 /**
1138 * @tc.name: GetParentCloudIdTest
1139 * @tc.desc: Verify the CloudDiskRdbStore::GetParentCloudIdTest function
1140 * @tc.type: FUNC
1141 */
1142 HWTEST_F(CloudDiskRdbStoreTest, GetParentCloudIdTestTest1, TestSize.Level1)
1143 {
1144 const std::string cloudId = "100";
1145 std::string parentCloudId = "mock";
1146 bool preCount = true;
1147 auto rdb = make_shared<RdbStoreMock>();
1148 clouddiskrdbStore_->rdbStore_ = rdb;
1149 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1150 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1151
1152 int32_t ret = clouddiskrdbStore_->GetParentCloudId(cloudId, parentCloudId);
1153 EXPECT_EQ(ret, E_RDB);
1154 }
1155
1156 /**
1157 * @tc.name: GetParentCloudIdTest
1158 * @tc.desc: Verify the CloudDiskRdbStore::GetParentCloudIdTest function
1159 * @tc.type: FUNC
1160 */
1161 HWTEST_F(CloudDiskRdbStoreTest, GetParentCloudIdTestTest2, TestSize.Level1)
1162 {
1163 const std::string cloudId = "100";
1164 std::string parentCloudId = "mock";
1165 bool preCount = true;
1166 auto rdb = make_shared<RdbStoreMock>();
1167 clouddiskrdbStore_->rdbStore_ = rdb;
1168 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1169 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1170 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1171 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
1172
1173 int32_t ret = clouddiskrdbStore_->GetParentCloudId(cloudId, parentCloudId);
1174 EXPECT_EQ(ret, E_RDB);
1175 }
1176
1177 /**
1178 * @tc.name: GetParentCloudIdTest
1179 * @tc.desc: Verify the CloudDiskRdbStore::GetParentCloudIdTest function
1180 * @tc.type: FUNC
1181 */
1182 HWTEST_F(CloudDiskRdbStoreTest, GetParentCloudIdTestTest3, TestSize.Level1)
1183 {
1184 const std::string cloudId = "100";
1185 std::string parentCloudId = "mock";
1186 bool preCount = true;
1187 auto rdb = make_shared<RdbStoreMock>();
1188 clouddiskrdbStore_->rdbStore_ = rdb;
1189 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1190 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1191 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1192 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1193 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_RDB));
1194
1195 int32_t ret = clouddiskrdbStore_->GetParentCloudId(cloudId, parentCloudId);
1196 EXPECT_EQ(ret, E_RDB);
1197 }
1198
1199 /**
1200 * @tc.name: GetParentCloudIdTest
1201 * @tc.desc: Verify the CloudDiskRdbStore::GetParentCloudIdTest function
1202 * @tc.type: FUNC
1203 */
1204 HWTEST_F(CloudDiskRdbStoreTest, GetParentCloudIdTestTest4, TestSize.Level1)
1205 {
1206 const std::string cloudId = "100";
1207 std::string parentCloudId = "test";
1208 bool preCount = true;
1209 auto rdb = make_shared<RdbStoreMock>();
1210 clouddiskrdbStore_->rdbStore_ = rdb;
1211 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1212 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
1213 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1214 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1215 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
1216
1217 int32_t ret = clouddiskrdbStore_->GetParentCloudId(cloudId, parentCloudId);
1218 EXPECT_EQ(ret, E_OK);
1219 }
1220
1221 /**
1222 * @tc.name: GetSourcePath
1223 * @tc.desc: Verify the CloudDiskRdbStore::GetSourcePath function
1224 * @tc.type: FUNC
1225 */
1226 HWTEST_F(CloudDiskRdbStoreTest, GetSourcePathTest1, TestSize.Level1)
1227 {
1228 const std::string attr = R"({"srcPath": "/data/service"})";
1229 const std::string parentCloudId = "100";
1230 std::string sourcePath = "/data";
1231 auto rdb = make_shared<RdbStoreMock>();
1232 clouddiskrdbStore_->rdbStore_ = rdb;
1233
1234 int32_t ret = clouddiskrdbStore_->GetSourcePath(attr, parentCloudId, sourcePath);
1235 EXPECT_EQ(ret, E_OK);
1236 }
1237
1238 /**
1239 * @tc.name: GetSourcePath
1240 * @tc.desc: Verify the CloudDiskRdbStore::GetSourcePath function
1241 * @tc.type: FUNC
1242 */
1243 HWTEST_F(CloudDiskRdbStoreTest, GetSourcePathTest2, TestSize.Level1)
1244 {
1245 const std::string attr = R"({"srcPath": 100})";
1246 const std::string parentCloudId = "100";
1247 std::string sourcePath = "/data";
1248 auto rdb = make_shared<RdbStoreMock>();
1249 clouddiskrdbStore_->rdbStore_ = rdb;
1250
1251 int32_t ret = clouddiskrdbStore_->GetSourcePath(attr, parentCloudId, sourcePath);
1252 EXPECT_EQ(ret, E_OK);
1253 }
1254
1255 /**
1256 * @tc.name: GetSourcePath
1257 * @tc.desc: Verify the CloudDiskRdbStore::GetSourcePath function
1258 * @tc.type: FUNC
1259 */
1260 HWTEST_F(CloudDiskRdbStoreTest, GetSourcePathTest3, TestSize.Level1)
1261 {
1262 const std::string attr = "";
1263 const std::string parentCloudId = "100";
1264 std::string sourcePath = "/data";
1265 auto rdb = make_shared<RdbStoreMock>();
1266 clouddiskrdbStore_->rdbStore_ = rdb;
1267
1268 int32_t ret = clouddiskrdbStore_->GetSourcePath(attr, parentCloudId, sourcePath);
1269 EXPECT_EQ(ret, E_OK);
1270 }
1271
1272 /**
1273 * @tc.name: GetSourcePath
1274 * @tc.desc: Verify the CloudDiskRdbStore::GetSourcePath function
1275 * @tc.type: FUNC
1276 */
1277 HWTEST_F(CloudDiskRdbStoreTest, GetSourcePathTest4, TestSize.Level1)
1278 {
1279 const std::string attr = "";
1280 const std::string parentCloudId = "";
1281 std::string sourcePath = "/data";
1282 auto rdb = make_shared<RdbStoreMock>();
1283 clouddiskrdbStore_->rdbStore_ = rdb;
1284
1285 int32_t ret = clouddiskrdbStore_->GetSourcePath(attr, parentCloudId, sourcePath);
1286 EXPECT_EQ(ret, E_OK);
1287 }
1288
1289 /**
1290 * @tc.name: GetSourcePath
1291 * @tc.desc: Verify the CloudDiskRdbStore::GetSourcePath function
1292 * @tc.type: FUNC
1293 */
1294 HWTEST_F(CloudDiskRdbStoreTest, GetSourcePathTest5, TestSize.Level1)
1295 {
1296 const std::string attr = "";
1297 const std::string parentCloudId = "100";
1298 std::string sourcePath = "/data";
1299 auto rdb = make_shared<RdbStoreMock>();
1300 clouddiskrdbStore_->rdbStore_ = rdb;
1301
1302 int32_t ret = clouddiskrdbStore_->GetSourcePath(attr, parentCloudId, sourcePath);
1303 EXPECT_EQ(ret, E_OK);
1304 }
1305
1306 /**
1307 * @tc.name: SourcePathSetValue
1308 * @tc.desc: Verify the CloudDiskRdbStore::SourcePathSetValue function
1309 * @tc.type: FUNC
1310 */
1311 HWTEST_F(CloudDiskRdbStoreTest, SourcePathSetValueTest1, TestSize.Level1)
1312 {
1313 const std::string cloudId = "";
1314 const std::string attr = "";
1315 ValuesBucket setXattr;
1316 auto rdb = make_shared<RdbStoreMock>();
1317 clouddiskrdbStore_->rdbStore_ = rdb;
1318
1319 int32_t ret = clouddiskrdbStore_->SourcePathSetValue(cloudId, attr, setXattr);
1320 EXPECT_EQ(ret, E_INVAL_ARG);
1321 }
1322
1323 /**
1324 * @tc.name: SourcePathSetValue
1325 * @tc.desc: Verify the CloudDiskRdbStore::SourcePathSetValue function
1326 * @tc.type: FUNC
1327 */
1328 HWTEST_F(CloudDiskRdbStoreTest, SourcePathSetValueTest2, TestSize.Level1)
1329 {
1330 const std::string cloudId = "rootId";
1331 const std::string attr = "";
1332 ValuesBucket setXattr;
1333 auto rdb = make_shared<RdbStoreMock>();
1334 clouddiskrdbStore_->rdbStore_ = rdb;
1335
1336 int32_t ret = clouddiskrdbStore_->SourcePathSetValue(cloudId, attr, setXattr);
1337 EXPECT_EQ(ret, E_INVAL_ARG);
1338 }
1339
1340 /**
1341 * @tc.name: SourcePathSetValue
1342 * @tc.desc: Verify the CloudDiskRdbStore::SourcePathSetValue function
1343 * @tc.type: FUNC
1344 */
1345 HWTEST_F(CloudDiskRdbStoreTest, SourcePathSetValueTest3, TestSize.Level1)
1346 {
1347 const std::string cloudId = "test";
1348 const std::string attr = "";
1349 ValuesBucket setXattr;
1350 bool preCount = true;
1351 auto rdb = make_shared<RdbStoreMock>();
1352 clouddiskrdbStore_->rdbStore_ = rdb;
1353 auto transaction = make_shared<TransactionMock>();
1354 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1355
1356 // GetCurNode return E_OK
1357 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
1358 .WillOnce(Return(ByMove(rset)));
1359 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1360 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
1361
1362 // GetNotifyUri return E_INVAL_ARG
1363 int32_t ret = clouddiskrdbStore_->SourcePathSetValue(cloudId, attr, setXattr);
1364 EXPECT_EQ(ret, E_INVAL_ARG);
1365 }
1366
1367 /**
1368 * @tc.name: SourcePathSetValue
1369 * @tc.desc: Verify the CloudDiskRdbStore::SourcePathSetValue function
1370 * @tc.type: FUNC
1371 */
1372 HWTEST_F(CloudDiskRdbStoreTest, SourcePathSetValueTest4, TestSize.Level1)
1373 {
1374 bool preCount = true;
1375 auto rdb = make_shared<RdbStoreMock>();
1376 clouddiskrdbStore_->rdbStore_ = rdb;
1377 auto transaction = make_shared<TransactionMock>();
1378 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1379
1380 // GetCurNode return E_OK
1381 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
1382 .WillOnce(Return(ByMove(rset)));
1383 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1384 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
1385
1386 // GetNotifyUri return E_OK
1387 clouddiskrdbStore_->rootId_ = "rootId";
1388
1389 // jsonObject parse faild + jsonObject dump success
1390 const std::string cloudId = "test";
1391 const std::string attr = "";
1392 ValuesBucket setXattr;
1393
1394 int32_t ret = clouddiskrdbStore_->SourcePathSetValue(cloudId, attr, setXattr);
1395 EXPECT_EQ(ret, E_OK);
1396 }
1397
1398 /**
1399 * @tc.name: SourcePathSetValue
1400 * @tc.desc: Verify the CloudDiskRdbStore::SourcePathSetValue function
1401 * @tc.type: FUNC
1402 */
1403 HWTEST_F(CloudDiskRdbStoreTest, SourcePathSetValueTest5, TestSize.Level1)
1404 {
1405 bool preCount = true;
1406 auto rdb = make_shared<RdbStoreMock>();
1407 clouddiskrdbStore_->rdbStore_ = rdb;
1408 auto transaction = make_shared<TransactionMock>();
1409 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1410
1411 // GetCurNode return E_OK
1412 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
1413 .WillOnce(Return(ByMove(rset)));
1414 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1415 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
1416
1417 // GetNotifyUri return E_OK
1418 clouddiskrdbStore_->rootId_ = "rootId";
1419
1420 // jsonObject parse success + jsonObject dump success
1421 const std::string cloudId = "test";
1422 const std::string attr = "{\"key\":\"value\"}";
1423 ValuesBucket setXattr;
1424
1425 int32_t ret = clouddiskrdbStore_->SourcePathSetValue(cloudId, attr, setXattr);
1426 EXPECT_EQ(ret, E_OK);
1427 }
1428
1429 /**
1430 * @tc.name: SourcePathSetValue
1431 * @tc.desc: Verify the CloudDiskRdbStore::SourcePathSetValue function
1432 * @tc.type: FUNC
1433 */
1434 HWTEST_F(CloudDiskRdbStoreTest, SourcePathSetValueTest6, TestSize.Level1)
1435 {
1436 bool preCount = true;
1437 auto rdb = make_shared<RdbStoreMock>();
1438 clouddiskrdbStore_->rdbStore_ = rdb;
1439 auto transaction = make_shared<TransactionMock>();
1440 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1441
1442 // GetCurNode return E_OK
1443 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
1444 .WillOnce(Return(ByMove(rset)));
1445 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1446 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
1447
1448 // GetNotifyUri return E_OK
1449 clouddiskrdbStore_->rootId_ = "rootId";
1450
1451 // jsonObject parse success + jsonObject dump failed
1452 const std::string cloudId = "test";
1453 const std::string attr = "{\"srcPath\":\"test\"}";
1454 ValuesBucket setXattr;
1455 shared_ptr<CloudDiskNotifyUtilsMock> utilsMock = make_shared<CloudDiskNotifyUtilsMock>();
1456 ICloudDiskNotifyUtils::ins = utilsMock;
1457 EXPECT_CALL(*utilsMock, GetUriFromCache())
1458 .WillOnce(Return("file://com.test.hap/data/storage/el2/cloud/\xD6\xF8\xD0\xA1/text.txt"));
1459
1460 int32_t ret = clouddiskrdbStore_->SourcePathSetValue(cloudId, attr, setXattr);
1461 EXPECT_EQ(ret, E_INVAL_ARG);
1462
1463 ICloudDiskNotifyUtils::ins = nullptr;
1464 }
1465
1466 /**
1467 * @tc.name: RecycleSetXattr
1468 * @tc.desc: Verify the CloudDiskRdbStore::RecycleSetXattr function
1469 * @tc.type: FUNC
1470 */
1471 HWTEST_F(CloudDiskRdbStoreTest, RecycleSetXattrTest1, TestSize.Level1)
1472 {
1473 const std::string name = "test";
1474 const std::string parentCloudId = "100";
1475 const std::string cloudId = "100";
1476 const std::string value = "notnum";
1477 auto rdb = make_shared<RdbStoreMock>();
1478 clouddiskrdbStore_->rdbStore_ = rdb;
1479 int32_t ret = clouddiskrdbStore_->RecycleSetXattr(name, parentCloudId, cloudId, value);
1480 EXPECT_EQ(ret, EINVAL);
1481 }
1482
1483 /**
1484 * @tc.name: RecycleSetXattr
1485 * @tc.desc: Verify the CloudDiskRdbStore::RecycleSetXattr function
1486 * @tc.type: FUNC
1487 */
1488 HWTEST_F(CloudDiskRdbStoreTest, RecycleSetXattrTest2, TestSize.Level1)
1489 {
1490 const std::string name = "test";
1491 const std::string parentCloudId = "100";
1492 const std::string cloudId = "100";
1493 const std::string value = "0";
1494 bool preCount = true;
1495 auto rdb = make_shared<RdbStoreMock>();
1496 clouddiskrdbStore_->rdbStore_ = rdb;
1497 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1498 auto transaction = make_shared<TransactionMock>();
1499 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1500 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1501 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1502
1503 int32_t ret = clouddiskrdbStore_->RecycleSetXattr(name, parentCloudId, cloudId, value);
1504 EXPECT_EQ(ret, E_RDB);
1505 }
1506
1507 /**
1508 * @tc.name: RecycleSetXattr
1509 * @tc.desc: Verify the CloudDiskRdbStore::RecycleSetXattr function
1510 * @tc.type: FUNC
1511 */
1512 HWTEST_F(CloudDiskRdbStoreTest, RecycleSetXattrTest3, TestSize.Level1)
1513 {
1514 const std::string name = "test";
1515 const std::string parentCloudId = "100";
1516 const std::string cloudId = "100";
1517 const std::string value = "1";
1518 bool preCount = true;
1519 auto rdb = make_shared<RdbStoreMock>();
1520 clouddiskrdbStore_->rdbStore_ = rdb;
1521 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1522 auto transaction = make_shared<TransactionMock>();
1523 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1524 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1525 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1526
1527 int32_t ret = clouddiskrdbStore_->RecycleSetXattr(name, parentCloudId, cloudId, value);
1528 EXPECT_EQ(ret, E_RDB);
1529 }
1530
1531 /**
1532 * @tc.name: RecycleSetXattr
1533 * @tc.desc: Verify the CloudDiskRdbStore::RecycleSetXattr function
1534 * @tc.type: FUNC
1535 */
1536 HWTEST_F(CloudDiskRdbStoreTest, RecycleSetXattrTest4, TestSize.Level1)
1537 {
1538 const std::string name = "test";
1539 const std::string parentCloudId = "100";
1540 const std::string cloudId = "100";
1541 const std::string value = "-1";
1542 bool preCount = true;
1543 auto rdb = make_shared<RdbStoreMock>();
1544 clouddiskrdbStore_->rdbStore_ = rdb;
1545
1546 int32_t ret = clouddiskrdbStore_->RecycleSetXattr(name, parentCloudId, cloudId, value);
1547 EXPECT_EQ(ret, EINVAL);
1548 }
1549
1550 /**
1551 * @tc.name: CheckIsConflict
1552 * @tc.desc: Verify the CloudDiskRdbStore::CheckIsConflict function
1553 * @tc.type: FUNC
1554 */
1555 HWTEST_F(CloudDiskRdbStoreTest, CheckIsConflictTest1, TestSize.Level1)
1556 {
1557 const std::string name = "mock";
1558 const std::string parentCloudId = "100";
1559 std::string newName = "test1";
1560 auto rdb = make_shared<RdbStoreMock>();
1561 clouddiskrdbStore_->rdbStore_ = rdb;
1562
1563 int32_t ret = clouddiskrdbStore_->CheckIsConflict(name, parentCloudId, newName);
1564 EXPECT_EQ(ret, E_RDB);
1565 }
1566
1567 /**
1568 * @tc.name: CheckIsConflict
1569 * @tc.desc: Verify the CloudDiskRdbStore::CheckIsConflict function
1570 * @tc.type: FUNC
1571 */
1572 HWTEST_F(CloudDiskRdbStoreTest, CheckIsConflictTest2, TestSize.Level1)
1573 {
1574 const std::string name = "test";
1575 const std::string parentCloudId = "100";
1576 std::string newName = "test1";
1577 auto rdb = make_shared<RdbStoreMock>();
1578 clouddiskrdbStore_->rdbStore_ = rdb;
1579
1580 int32_t ret = clouddiskrdbStore_->CheckIsConflict(name, parentCloudId, newName);
1581 EXPECT_EQ(ret, E_OK);
1582 }
1583
1584 /**
1585 * @tc.name: RestoreUpdateRdb
1586 * @tc.desc: Verify the CloudDiskRdbStore::RestoreUpdateRdb function
1587 * @tc.type: FUNC
1588 */
1589 HWTEST_F(CloudDiskRdbStoreTest, RestoreUpdateRdbTest1, TestSize.Level1)
1590 {
1591 const std::string cloudId = "100";
1592 const struct RestoreInfo restoreInfo;
1593 ValuesBucket setXattr;
1594 auto rdb = make_shared<RdbStoreMock>();
1595 clouddiskrdbStore_->rdbStore_ = rdb;
1596 auto transaction = make_shared<TransactionMock>();
1597 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1598 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
1599
1600 int32_t ret = clouddiskrdbStore_->RestoreUpdateRdb(cloudId, restoreInfo, setXattr);
1601 EXPECT_EQ(ret, E_RDB);
1602 }
1603
1604 /**
1605 * @tc.name: RestoreUpdateRdb
1606 * @tc.desc: Verify the CloudDiskRdbStore::RestoreUpdateRdb function
1607 * @tc.type: FUNC
1608 */
1609 HWTEST_F(CloudDiskRdbStoreTest, RestoreUpdateRdbTest2, TestSize.Level1)
1610 {
1611 const std::string cloudId = "100";
1612 const struct RestoreInfo restoreInfo;
1613 ValuesBucket setXattr;
1614 auto rdb = make_shared<RdbStoreMock>();
1615 clouddiskrdbStore_->rdbStore_ = rdb;
1616 auto transaction = make_shared<TransactionMock>();
1617 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1618 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
1619
1620 int32_t ret = clouddiskrdbStore_->RestoreUpdateRdb(cloudId, restoreInfo, setXattr);
1621 EXPECT_EQ(ret, E_OK);
1622 }
1623
1624 /**
1625 * @tc.name: RestoreUpdateRdb
1626 * @tc.desc: Verify the CloudDiskRdbStore::RestoreUpdateRdb function
1627 * @tc.type: FUNC
1628 */
1629 HWTEST_F(CloudDiskRdbStoreTest, RestoreUpdateRdbTest3, TestSize.Level1)
1630 {
1631 const std::string cloudId = "100";
1632 const struct RestoreInfo restoreInfo;
1633 ValuesBucket setXattr;
1634 restoreInfo.parentCloudId == "mock";
1635 auto rdb = make_shared<RdbStoreMock>();
1636 clouddiskrdbStore_->rdbStore_ = rdb;
1637 auto transaction = make_shared<TransactionMock>();
1638 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1639 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
1640
1641 int32_t ret = clouddiskrdbStore_->RestoreUpdateRdb(cloudId, restoreInfo, setXattr);
1642 EXPECT_EQ(ret, E_OK);
1643 }
1644
1645 /**
1646 * @tc.name: HandleRestoreXattr
1647 * @tc.desc: Verify the CloudDiskRdbStore::HandleRestoreXattr function
1648 * @tc.type: FUNC
1649 */
1650 HWTEST_F(CloudDiskRdbStoreTest, HandleRestoreXattrTest1, TestSize.Level1)
1651 {
1652 const std::string name = "";
1653 const std::string parentCloudId = "";
1654 const std::string cloudId = "100";
1655 bool preCount = true;
1656 auto rdb = make_shared<RdbStoreMock>();
1657 clouddiskrdbStore_->rdbStore_ = rdb;
1658 auto transaction = make_shared<TransactionMock>();
1659 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1660 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1661 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1662
1663 int32_t ret = clouddiskrdbStore_->HandleRestoreXattr(name, parentCloudId, cloudId);
1664 EXPECT_EQ(ret, E_RDB);
1665 }
1666
1667 /**
1668 * @tc.name: HandleRestoreXattr
1669 * @tc.desc: Verify the CloudDiskRdbStore::HandleRestoreXattr function
1670 * @tc.type: FUNC
1671 */
1672 HWTEST_F(CloudDiskRdbStoreTest, HandleRestoreXattrTest2, TestSize.Level1)
1673 {
1674 const std::string name = "";
1675 const std::string parentCloudId = "";
1676 const std::string cloudId = "100";
1677 bool preCount = true;
1678 auto rdb = make_shared<RdbStoreMock>();
1679 clouddiskrdbStore_->rdbStore_ = rdb;
1680 auto transaction = make_shared<TransactionMock>();
1681 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1682 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)))
1683 .WillOnce(Return(std::make_pair(E_OK, transaction)));
1684 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1685 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1686 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1687 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
1688 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
1689 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
1690 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
1691
1692 int32_t ret = clouddiskrdbStore_->HandleRestoreXattr(name, parentCloudId, cloudId);
1693 EXPECT_EQ(ret, E_RDB);
1694 }
1695
1696 /**
1697 * @tc.name: HandleRestoreXattr
1698 * @tc.desc: Verify the CloudDiskRdbStore::HandleRestoreXattr function
1699 * @tc.type: FUNC
1700 */
1701 HWTEST_F(CloudDiskRdbStoreTest, HandleRestoreXattrTest3, TestSize.Level1)
1702 {
1703 const std::string name = "";
1704 const std::string parentCloudId = "";
1705 const std::string cloudId = "100";
1706 bool preCount = true;
1707 auto rdb = make_shared<RdbStoreMock>();
1708 clouddiskrdbStore_->rdbStore_ = rdb;
1709 auto transaction = make_shared<TransactionMock>();
1710 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1711 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)))
1712 .WillOnce(Return(std::make_pair(E_OK, transaction)));
1713 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1714 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1715 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1716 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
1717 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
1718 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
1719 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
1720
1721 int32_t ret = clouddiskrdbStore_->HandleRestoreXattr(name, parentCloudId, cloudId);
1722 EXPECT_EQ(ret, E_OK);
1723 }
1724
1725 /**
1726 * @tc.name: HandleRecycleXattr
1727 * @tc.desc: Verify the CloudDiskRdbStore::HandleRecycleXattr function
1728 * @tc.type: FUNC
1729 */
1730 HWTEST_F(CloudDiskRdbStoreTest, HandleRecycleXattrTest1, TestSize.Level1)
1731 {
1732 const std::string name = "";
1733 const std::string parentCloudId = "";
1734 const std::string cloudId = "100";
1735 bool preCount = true;
1736 auto rdb = make_shared<RdbStoreMock>();
1737 clouddiskrdbStore_->rdbStore_ = rdb;
1738 auto transaction = make_shared<TransactionMock>();
1739 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1740 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1741 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1742 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1743
1744 int32_t ret = clouddiskrdbStore_->HandleRecycleXattr(name, parentCloudId, cloudId);
1745 EXPECT_EQ(ret, E_RDB);
1746 }
1747
1748 /**
1749 * @tc.name: HandleRecycleXattr
1750 * @tc.desc: Verify the CloudDiskRdbStore::HandleRecycleXattr function
1751 * @tc.type: FUNC
1752 */
1753 HWTEST_F(CloudDiskRdbStoreTest, HandleRecycleXattrTest2, TestSize.Level1)
1754 {
1755 const std::string name = "";
1756 const std::string parentCloudId = "";
1757 const std::string cloudId = "100";
1758 bool preCount = true;
1759 auto rdb = make_shared<RdbStoreMock>();
1760 clouddiskrdbStore_->rdbStore_ = rdb;
1761 clouddiskrdbStore_->rootId_ = "rootId";
1762 auto transaction = make_shared<TransactionMock>();
1763 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1764 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1765 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1766 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1767 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1768 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
1769 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(1), Return(E_OK)));
1770 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
1771 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
1772
1773 int32_t ret = clouddiskrdbStore_->HandleRecycleXattr(name, parentCloudId, cloudId);
1774 EXPECT_EQ(ret, E_RDB);
1775 }
1776
1777 /**
1778 * @tc.name: HandleRecycleXattr
1779 * @tc.desc: Verify the CloudDiskRdbStore::HandleRecycleXattr function
1780 * @tc.type: FUNC
1781 */
1782 HWTEST_F(CloudDiskRdbStoreTest, HandleRecycleXattrTest3, TestSize.Level1)
1783 {
1784 const std::string name = "";
1785 const std::string parentCloudId = "mock";
1786 const std::string cloudId = "100";
1787 bool preCount = true;
1788 auto rdb = make_shared<RdbStoreMock>();
1789 clouddiskrdbStore_->rdbStore_ = rdb;
1790 clouddiskrdbStore_->rootId_ = "rootId";
1791 auto transaction = make_shared<TransactionMock>();
1792 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1793 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1794 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1795 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1796 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1797 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
1798 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(0), Return(E_OK)));
1799 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
1800 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
1801
1802 int32_t ret = clouddiskrdbStore_->HandleRecycleXattr(name, parentCloudId, cloudId);
1803 EXPECT_EQ(ret, E_RDB);
1804 }
1805
1806 /**
1807 * @tc.name: HandleRecycleXattr
1808 * @tc.desc: Verify the CloudDiskRdbStore::HandleRecycleXattr function
1809 * @tc.type: FUNC
1810 */
1811 HWTEST_F(CloudDiskRdbStoreTest, HandleRecycleXattrTest4, TestSize.Level1)
1812 {
1813 const std::string name = "";
1814 const std::string parentCloudId = "";
1815 const std::string cloudId = "100";
1816 bool preCount = true;
1817 auto rdb = make_shared<RdbStoreMock>();
1818 clouddiskrdbStore_->rdbStore_ = rdb;
1819 clouddiskrdbStore_->rootId_ = "rootId";
1820 auto transaction = make_shared<TransactionMock>();
1821 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1822 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
1823 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1824 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1825 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1826 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
1827 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(1), Return(E_OK)));
1828 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
1829 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
1830
1831 int32_t ret = clouddiskrdbStore_->HandleRecycleXattr(name, parentCloudId, cloudId);
1832 EXPECT_EQ(ret, E_OK);
1833 }
1834
1835 /**
1836 * @tc.name: GetRecycleInfoTest001
1837 * @tc.desc: Verify the CloudDiskRdbStore::GetRecycleInfo function
1838 * @tc.type: FUNC
1839 */
1840 HWTEST_F(CloudDiskRdbStoreTest, GetRecycleInfoTest1, TestSize.Level1)
1841 {
1842 const std::string cloudId = "100";
1843 int64_t rowId;
1844 int32_t position;
1845 std::string attr;
1846 bool preCount = true;
1847 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
1848 auto rdb = make_shared<RdbStoreMock>();
1849 clouddiskrdbStore_->rdbStore_ = rdb;
1850 auto transaction = make_shared<TransactionMock>();
1851 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1852 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1853 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
1854
1855 int32_t ret = clouddiskrdbStore_->GetRecycleInfo(transaction, cloudId, rowId, position, attr, dirtyType);
1856 EXPECT_EQ(ret, E_RDB);
1857 }
1858
1859 /**
1860 * @tc.name: GetRecycleInfoTest002
1861 * @tc.desc: Verify the CloudDiskRdbStore::GetRecycleInfo function
1862 * @tc.type: FUNC
1863 */
1864 HWTEST_F(CloudDiskRdbStoreTest, GetRecycleInfoTest2, TestSize.Level1)
1865 {
1866 const std::string cloudId = "100";
1867 int64_t rowId;
1868 int32_t position;
1869 std::string attr;
1870 bool preCount = true;
1871 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
1872 auto rdb = make_shared<RdbStoreMock>();
1873 clouddiskrdbStore_->rdbStore_ = rdb;
1874 auto transaction = make_shared<TransactionMock>();
1875 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1876 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1877 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1878 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
1879
1880 int32_t ret = clouddiskrdbStore_->GetRecycleInfo(transaction, cloudId, rowId, position, attr, dirtyType);
1881 EXPECT_EQ(ret, E_RDB);
1882 }
1883
1884 /**
1885 * @tc.name: GetRecycleInfoTest003
1886 * @tc.desc: Verify the CloudDiskRdbStore::GetRecycleInfo function
1887 * @tc.type: FUNC
1888 */
1889 HWTEST_F(CloudDiskRdbStoreTest, GetRecycleInfoTest3, TestSize.Level1)
1890 {
1891 const std::string cloudId = "100";
1892 int64_t rowId;
1893 int32_t position;
1894 std::string attr;
1895 bool preCount = true;
1896 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
1897 auto rdb = make_shared<RdbStoreMock>();
1898 clouddiskrdbStore_->rdbStore_ = rdb;
1899 auto transaction = make_shared<TransactionMock>();
1900 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1901 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1902 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1903 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1904 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_RDB));
1905
1906 int32_t ret = clouddiskrdbStore_->GetRecycleInfo(transaction, cloudId, rowId, position, attr, dirtyType);
1907 EXPECT_EQ(ret, E_RDB);
1908 }
1909
1910 /**
1911 * @tc.name: GetRecycleInfoTest004
1912 * @tc.desc: Verify the CloudDiskRdbStore::GetRecycleInfo function
1913 * @tc.type: FUNC
1914 */
1915 HWTEST_F(CloudDiskRdbStoreTest, GetRecycleInfoTest4, TestSize.Level1)
1916 {
1917 const std::string cloudId = "100";
1918 int64_t rowId;
1919 int32_t position;
1920 std::string attr;
1921 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
1922 bool preCount = true;
1923 auto rdb = make_shared<RdbStoreMock>();
1924 clouddiskrdbStore_->rdbStore_ = rdb;
1925 auto transaction = make_shared<TransactionMock>();
1926 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1927 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1928 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1929 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1930 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
1931 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_RDB));
1932
1933 int32_t ret = clouddiskrdbStore_->GetRecycleInfo(transaction, cloudId, rowId, position, attr, dirtyType);
1934 EXPECT_EQ(ret, E_RDB);
1935 }
1936
1937 /**
1938 * @tc.name: GetRecycleInfoTest005
1939 * @tc.desc: Verify the CloudDiskRdbStore::GetRecycleInfo function
1940 * @tc.type: FUNC
1941 */
1942 HWTEST_F(CloudDiskRdbStoreTest, GetRecycleInfoTest5, TestSize.Level1)
1943 {
1944 const std::string cloudId = "100";
1945 int64_t rowId;
1946 int32_t position;
1947 std::string attr;
1948 bool preCount = true;
1949 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
1950 auto rdb = make_shared<RdbStoreMock>();
1951 clouddiskrdbStore_->rdbStore_ = rdb;
1952 auto transaction = make_shared<TransactionMock>();
1953 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1954 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1955 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1956 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1957 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
1958 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
1959 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_RDB));
1960
1961 int32_t ret = clouddiskrdbStore_->GetRecycleInfo(transaction, cloudId, rowId, position, attr, dirtyType);
1962 EXPECT_EQ(ret, E_RDB);
1963 }
1964
1965 /**
1966 * @tc.name: GetRecycleInfoTest006
1967 * @tc.desc: Verify the CloudDiskRdbStore::GetRecycleInfo function
1968 * @tc.type: FUNC
1969 */
1970 HWTEST_F(CloudDiskRdbStoreTest, GetRecycleInfoTest6, TestSize.Level1)
1971 {
1972 const std::string cloudId = "100";
1973 int64_t rowId;
1974 int32_t position;
1975 std::string attr;
1976 bool preCount = true;
1977 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
1978 auto rdb = make_shared<RdbStoreMock>();
1979 clouddiskrdbStore_->rdbStore_ = rdb;
1980 auto transaction = make_shared<TransactionMock>();
1981 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
1982 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
1983 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
1984 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
1985 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
1986 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
1987 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
1988
1989 int32_t ret = clouddiskrdbStore_->GetRecycleInfo(transaction, cloudId, rowId, position, attr, dirtyType);
1990 EXPECT_EQ(ret, E_OK);
1991 }
1992
1993 /**
1994 * @tc.name: GetRecycleInfoTest007
1995 * @tc.desc: Verify the CloudDiskRdbStore::GetRecycleInfo function
1996 * @tc.type: FUNC
1997 */
1998 HWTEST_F(CloudDiskRdbStoreTest, GetRecycleInfoTest7, TestSize.Level1)
1999 {
2000 const std::string cloudId = "100";
2001 int64_t rowId;
2002 int32_t position;
2003 std::string attr;
2004 bool preCount = true;
2005 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
2006 auto rdb = make_shared<RdbStoreMock>();
2007 clouddiskrdbStore_->rdbStore_ = rdb;
2008 auto transaction = make_shared<TransactionMock>();
2009 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2010 EXPECT_CALL(*transaction, QueryByStep(An<const AbsRdbPredicates &>(),
2011 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2012 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2013 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
2014 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
2015 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
2016 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_RDB));
2017
2018 int32_t ret = clouddiskrdbStore_->GetRecycleInfo(transaction, cloudId, rowId, position, attr, dirtyType);
2019 EXPECT_EQ(ret, E_RDB);
2020 }
2021
2022 /**
2023 * @tc.name: FavoriteSetXattr
2024 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteSetXattr function
2025 * @tc.type: FUNC
2026 */
2027 HWTEST_F(CloudDiskRdbStoreTest, FavoriteSetXattrTest1, TestSize.Level1)
2028 {
2029 const std::string cloudId = "rootId";
2030 const std::string value = "notnum";
2031 auto rdb = make_shared<RdbStoreMock>();
2032 clouddiskrdbStore_->rdbStore_ = rdb;
2033 int32_t ret = clouddiskrdbStore_->FavoriteSetXattr(cloudId, value);
2034 EXPECT_EQ(ret, EINVAL);
2035 }
2036
2037 /**
2038 * @tc.name: FavoriteSetXattr
2039 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteSetXattr function
2040 * @tc.type: FUNC
2041 */
2042 HWTEST_F(CloudDiskRdbStoreTest, FavoriteSetXattrTest2, TestSize.Level1)
2043 {
2044 const std::string cloudId = "root";
2045 const std::string value = "2";
2046 auto rdb = make_shared<RdbStoreMock>();
2047 clouddiskrdbStore_->rdbStore_ = rdb;
2048 int32_t ret = clouddiskrdbStore_->FavoriteSetXattr(cloudId, value);
2049 EXPECT_EQ(ret, E_RDB);
2050 }
2051
2052 /**
2053 * @tc.name: FavoriteSetXattr
2054 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteSetXattr function
2055 * @tc.type: FUNC
2056 */
2057 HWTEST_F(CloudDiskRdbStoreTest, FavoriteSetXattrTest3, TestSize.Level1)
2058 {
2059 const std::string cloudId = "root";
2060 const std::string value = "0";
2061 auto rdb = make_shared<RdbStoreMock>();
2062 clouddiskrdbStore_->rdbStore_ = rdb;
2063 EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_RDB));
2064
2065 int32_t ret = clouddiskrdbStore_->FavoriteSetXattr(cloudId, value);
2066 EXPECT_EQ(ret, E_RDB);
2067 }
2068
2069 /**
2070 * @tc.name: FavoriteSetXattr
2071 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteSetXattr function
2072 * @tc.type: FUNC
2073 */
2074 HWTEST_F(CloudDiskRdbStoreTest, FavoriteSetXattrTest4, TestSize.Level1)
2075 {
2076 const std::string cloudId = "root";
2077 const std::string value = "1";
2078 auto rdb = make_shared<RdbStoreMock>();
2079 clouddiskrdbStore_->rdbStore_ = rdb;
2080 EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<ValueObject> &>())).WillOnce(Return(E_OK));
2081
2082 int32_t ret = clouddiskrdbStore_->FavoriteSetXattr(cloudId, value);
2083 EXPECT_EQ(ret, E_OK);
2084 }
2085
2086 /**
2087 * @tc.name: LocationGetXattr
2088 * @tc.desc: Verify the CloudDiskRdbStore::LocationGetXattr function
2089 * @tc.type: FUNC
2090 */
2091 HWTEST_F(CloudDiskRdbStoreTest, LocationGetXattrTest1, TestSize.Level1)
2092 {
2093 const std::string cloudId = "";
2094 const std::string key = IS_FAVORITE_XATTR;
2095 std::string value = "";
2096 const std::string name = "test";
2097 const std::string parentCloudId = "rootId";
2098 auto rdb = make_shared<RdbStoreMock>();
2099 clouddiskrdbStore_->rdbStore_ = rdb;
2100 int32_t ret = clouddiskrdbStore_->LocationGetXattr(name, key, value, parentCloudId);
2101 EXPECT_EQ(ret, E_INVAL_ARG);
2102 }
2103
2104 /**
2105 * @tc.name: LocationGetXattr
2106 * @tc.desc: Verify the CloudDiskRdbStore::LocationGetXattr function
2107 * @tc.type: FUNC
2108 */
2109 HWTEST_F(CloudDiskRdbStoreTest, LocationGetXattrTest2, TestSize.Level1)
2110 {
2111 const std::string cloudId = "";
2112 const std::string key = CLOUD_FILE_LOCATION;
2113 std::string value = "";
2114 const std::string name = "mock";
2115 const std::string parentCloudId = "rootId";
2116 auto rdb = make_shared<RdbStoreMock>();
2117 clouddiskrdbStore_->rdbStore_ = rdb;
2118 int32_t ret = clouddiskrdbStore_->LocationGetXattr(name, key, value, parentCloudId);
2119 EXPECT_EQ(ret, ENOENT);
2120 }
2121
2122 /**
2123 * @tc.name: LocationGetXattr
2124 * @tc.desc: Verify the CloudDiskRdbStore::LocationGetXattr function
2125 * @tc.type: FUNC
2126 */
2127 HWTEST_F(CloudDiskRdbStoreTest, LocationGetXattrTest3, TestSize.Level1)
2128 {
2129 const std::string cloudId = "";
2130 const std::string key = CLOUD_FILE_LOCATION;
2131 std::string value = "";
2132 const std::string name = "test";
2133 const std::string parentCloudId = "rootId";
2134 auto rdb = make_shared<RdbStoreMock>();
2135 clouddiskrdbStore_->rdbStore_ = rdb;
2136 int32_t ret = clouddiskrdbStore_->LocationGetXattr(name, key, value, parentCloudId);
2137 EXPECT_EQ(ret, E_OK);
2138 }
2139
2140 /**
2141 * @tc.name: FavoriteGetXattr
2142 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteGetXattr function
2143 * @tc.type: FUNC
2144 */
2145 HWTEST_F(CloudDiskRdbStoreTest, FavoriteGetXattrTest1, TestSize.Level1)
2146 {
2147 const std::string cloudId = "";
2148 const std::string key = IS_FAVORITE_XATTR;
2149 std::string value = "";
2150 auto rdb = make_shared<RdbStoreMock>();
2151 clouddiskrdbStore_->rdbStore_ = rdb;
2152
2153 int32_t ret = clouddiskrdbStore_->FavoriteGetXattr(cloudId, key, value);
2154 EXPECT_EQ(ret, E_INVAL_ARG);
2155 }
2156
2157 /**
2158 * @tc.name: FavoriteGetXattr
2159 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteGetXattr function
2160 * @tc.type: FUNC
2161 */
2162 HWTEST_F(CloudDiskRdbStoreTest, FavoriteGetXattrTest2, TestSize.Level1)
2163 {
2164 const std::string cloudId = "rootId";
2165 const std::string key = IS_FAVORITE_XATTR;
2166 std::string value = "";
2167 auto rdb = make_shared<RdbStoreMock>();
2168 clouddiskrdbStore_->rdbStore_ = rdb;
2169
2170 int32_t ret = clouddiskrdbStore_->FavoriteGetXattr(cloudId, key, value);
2171 EXPECT_EQ(ret, E_INVAL_ARG);
2172 }
2173
2174 /**
2175 * @tc.name: FavoriteGetXattr
2176 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteGetXattr function
2177 * @tc.type: FUNC
2178 */
2179 HWTEST_F(CloudDiskRdbStoreTest, FavoriteGetXattrTest3, TestSize.Level1)
2180 {
2181 const std::string cloudId = "100";
2182 const std::string key = IS_FILE_STATUS_XATTR;
2183 std::string value = "";
2184 auto rdb = make_shared<RdbStoreMock>();
2185 clouddiskrdbStore_->rdbStore_ = rdb;
2186
2187 int32_t ret = clouddiskrdbStore_->FavoriteGetXattr(cloudId, key, value);
2188 EXPECT_EQ(ret, E_INVAL_ARG);
2189 }
2190
2191 /**
2192 * @tc.name: FavoriteGetXattr
2193 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteGetXattr function
2194 * @tc.type: FUNC
2195 */
2196 HWTEST_F(CloudDiskRdbStoreTest, FavoriteGetXattrTest4, TestSize.Level1)
2197 {
2198 const std::string cloudId = "100";
2199 const std::string key = IS_FAVORITE_XATTR;
2200 std::string value = "";
2201 bool preCount = true;
2202 auto rdb = make_shared<RdbStoreMock>();
2203 clouddiskrdbStore_->rdbStore_ = rdb;
2204 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2205 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
2206
2207 int32_t ret = clouddiskrdbStore_->FavoriteGetXattr(cloudId, key, value);
2208 EXPECT_EQ(ret, E_RDB);
2209 }
2210
2211 /**
2212 * @tc.name: FavoriteGetXattr
2213 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteGetXattr function
2214 * @tc.type: FUNC
2215 */
2216 HWTEST_F(CloudDiskRdbStoreTest, FavoriteGetXattrTest5, TestSize.Level1)
2217 {
2218 const std::string cloudId = "100";
2219 const std::string key = IS_FAVORITE_XATTR;
2220 std::string value = "";
2221 bool preCount = true;
2222 auto rdb = make_shared<RdbStoreMock>();
2223 clouddiskrdbStore_->rdbStore_ = rdb;
2224 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2225 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2226 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2227 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
2228
2229 int32_t ret = clouddiskrdbStore_->FavoriteGetXattr(cloudId, key, value);
2230 EXPECT_EQ(ret, E_RDB);
2231 }
2232
2233 /**
2234 * @tc.name: FavoriteGetXattr
2235 * @tc.desc: Verify the CloudDiskRdbStore::FavoriteGetXattr function
2236 * @tc.type: FUNC
2237 */
2238 HWTEST_F(CloudDiskRdbStoreTest, FavoriteGetXattrTest6, TestSize.Level1)
2239 {
2240 const std::string cloudId = "100";
2241 const std::string key = IS_FAVORITE_XATTR;
2242 std::string value = "";
2243 bool preCount = true;
2244 auto rdb = make_shared<RdbStoreMock>();
2245 clouddiskrdbStore_->rdbStore_ = rdb;
2246 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2247 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2248 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2249 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2250 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
2251
2252 int32_t ret = clouddiskrdbStore_->FavoriteGetXattr(cloudId, key, value);
2253 EXPECT_EQ(ret, E_OK);
2254 }
2255
2256 /**
2257 * @tc.name: FileStatusGetXattr
2258 * @tc.desc: Verify the CloudDiskRdbStore::FileStatusGetXattr function
2259 * @tc.type: FUNC
2260 */
2261 HWTEST_F(CloudDiskRdbStoreTest, FileStatusGetXattrTest1, TestSize.Level1)
2262 {
2263 const std::string cloudId = "";
2264 const std::string key = IS_FILE_STATUS_XATTR;
2265 std::string value = "";
2266 auto rdb = make_shared<RdbStoreMock>();
2267 clouddiskrdbStore_->rdbStore_ = rdb;
2268
2269 int32_t ret = clouddiskrdbStore_->FileStatusGetXattr(cloudId, key, value);
2270 EXPECT_EQ(ret, E_INVAL_ARG);
2271 }
2272
2273 /**
2274 * @tc.name: FileStatusGetXattr
2275 * @tc.desc: Verify the CloudDiskRdbStore::FileStatusGetXattr function
2276 * @tc.type: FUNC
2277 */
2278 HWTEST_F(CloudDiskRdbStoreTest, FileStatusGetXattrTest2, TestSize.Level1)
2279 {
2280 const std::string cloudId = "rootId";
2281 const std::string key = IS_FILE_STATUS_XATTR;
2282 std::string value = "";
2283 auto rdb = make_shared<RdbStoreMock>();
2284 clouddiskrdbStore_->rdbStore_ = rdb;
2285
2286 int32_t ret = clouddiskrdbStore_->FileStatusGetXattr(cloudId, key, value);
2287 EXPECT_EQ(ret, E_INVAL_ARG);
2288 }
2289
2290 /**
2291 * @tc.name: FileStatusGetXattr
2292 * @tc.desc: Verify the CloudDiskRdbStore::FileStatusGetXattr function
2293 * @tc.type: FUNC
2294 */
2295 HWTEST_F(CloudDiskRdbStoreTest, FileStatusGetXattrTest3, TestSize.Level1)
2296 {
2297 const std::string cloudId = "100";
2298 const std::string key = IS_FAVORITE_XATTR;
2299 std::string value = "";
2300 auto rdb = make_shared<RdbStoreMock>();
2301 clouddiskrdbStore_->rdbStore_ = rdb;
2302
2303 int32_t ret = clouddiskrdbStore_->FileStatusGetXattr(cloudId, key, value);
2304 EXPECT_EQ(ret, E_INVAL_ARG);
2305 }
2306
2307 /**
2308 * @tc.name: FileStatusGetXattr
2309 * @tc.desc: Verify the CloudDiskRdbStore::FileStatusGetXattr function
2310 * @tc.type: FUNC
2311 */
2312 HWTEST_F(CloudDiskRdbStoreTest, FileStatusGetXattrTest4, TestSize.Level1)
2313 {
2314 const std::string cloudId = "100";
2315 const std::string key = IS_FILE_STATUS_XATTR;
2316 std::string value = "";
2317 bool preCount = true;
2318 auto rdb = make_shared<RdbStoreMock>();
2319 clouddiskrdbStore_->rdbStore_ = rdb;
2320 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2321 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
2322
2323 int32_t ret = clouddiskrdbStore_->FileStatusGetXattr(cloudId, key, value);
2324 EXPECT_EQ(ret, E_RDB);
2325 }
2326
2327 /**
2328 * @tc.name: FileStatusGetXattr
2329 * @tc.desc: Verify the CloudDiskRdbStore::FileStatusGetXattr function
2330 * @tc.type: FUNC
2331 */
2332 HWTEST_F(CloudDiskRdbStoreTest, FileStatusGetXattrTest5, TestSize.Level1)
2333 {
2334 const std::string cloudId = "100";
2335 const std::string key = IS_FILE_STATUS_XATTR;
2336 std::string value = "";
2337 bool preCount = true;
2338 auto rdb = make_shared<RdbStoreMock>();
2339 clouddiskrdbStore_->rdbStore_ = rdb;
2340 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2341 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2342 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2343 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
2344
2345 int32_t ret = clouddiskrdbStore_->FileStatusGetXattr(cloudId, key, value);
2346 EXPECT_EQ(ret, E_RDB);
2347 }
2348
2349 /**
2350 * @tc.name: FileStatusGetXattr
2351 * @tc.desc: Verify the CloudDiskRdbStore::FileStatusGetXattr function
2352 * @tc.type: FUNC
2353 */
2354 HWTEST_F(CloudDiskRdbStoreTest, FileStatusGetXattrTest6, TestSize.Level1)
2355 {
2356 const std::string cloudId = "100";
2357 const std::string key = IS_FILE_STATUS_XATTR;
2358 std::string value = "";
2359 bool preCount = true;
2360 auto rdb = make_shared<RdbStoreMock>();
2361 clouddiskrdbStore_->rdbStore_ = rdb;
2362 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2363 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2364 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2365 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2366 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_RDB));
2367
2368 int32_t ret = clouddiskrdbStore_->FileStatusGetXattr(cloudId, key, value);
2369 EXPECT_EQ(ret, E_RDB);
2370 }
2371
2372 /**
2373 * @tc.name: FileStatusGetXattr
2374 * @tc.desc: Verify the CloudDiskRdbStore::FileStatusGetXattr function
2375 * @tc.type: FUNC
2376 */
2377 HWTEST_F(CloudDiskRdbStoreTest, FileStatusGetXattrTest7, TestSize.Level1)
2378 {
2379 const std::string cloudId = "100";
2380 const std::string key = IS_FILE_STATUS_XATTR;
2381 std::string value = "";
2382 bool preCount = true;
2383 auto rdb = make_shared<RdbStoreMock>();
2384 clouddiskrdbStore_->rdbStore_ = rdb;
2385 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2386 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2387 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2388 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2389 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
2390
2391 int32_t ret = clouddiskrdbStore_->FileStatusGetXattr(cloudId, key, value);
2392 EXPECT_EQ(ret, E_OK);
2393 }
2394
2395 /**
2396 * @tc.name: TimeRecycledGetXattr
2397 * @tc.desc: Verify the CloudDiskRdbStore::TimeRecycledGetXattr function
2398 * @tc.type: FUNC
2399 */
2400 HWTEST_F(CloudDiskRdbStoreTest, TimeRecycledGetXattrTest1, TestSize.Level1)
2401 {
2402 const std::string cloudId = "";
2403 const std::string key = CLOUD_TIME_RECYCLED;
2404 std::string value = "";
2405 auto rdb = make_shared<RdbStoreMock>();
2406 clouddiskrdbStore_->rdbStore_ = rdb;
2407
2408 int32_t ret = clouddiskrdbStore_->TimeRecycledGetXattr(cloudId, key, value);
2409 EXPECT_EQ(ret, E_INVAL_ARG);
2410 }
2411
2412 /**
2413 * @tc.name: TimeRecycledGetXattr
2414 * @tc.desc: Verify the CloudDiskRdbStore::TimeRecycledGetXattr function
2415 * @tc.type: FUNC
2416 */
2417 HWTEST_F(CloudDiskRdbStoreTest, TimeRecycledGetXattrTest2, TestSize.Level1)
2418 {
2419 const std::string cloudId = "rootId";
2420 const std::string key = CLOUD_TIME_RECYCLED;
2421 std::string value = "";
2422 auto rdb = make_shared<RdbStoreMock>();
2423 clouddiskrdbStore_->rdbStore_ = rdb;
2424
2425 int32_t ret = clouddiskrdbStore_->TimeRecycledGetXattr(cloudId, key, value);
2426 EXPECT_EQ(ret, E_INVAL_ARG);
2427 }
2428
2429 /**
2430 * @tc.name: TimeRecycledGetXattr
2431 * @tc.desc: Verify the CloudDiskRdbStore::TimeRecycledGetXattr function
2432 * @tc.type: FUNC
2433 */
2434 HWTEST_F(CloudDiskRdbStoreTest, TimeRecycledGetXattrTest3, TestSize.Level1)
2435 {
2436 const std::string cloudId = "100";
2437 const std::string key = IS_FAVORITE_XATTR;
2438 std::string value = "";
2439 auto rdb = make_shared<RdbStoreMock>();
2440 clouddiskrdbStore_->rdbStore_ = rdb;
2441
2442 int32_t ret = clouddiskrdbStore_->TimeRecycledGetXattr(cloudId, key, value);
2443 EXPECT_EQ(ret, E_INVAL_ARG);
2444 }
2445
2446 /**
2447 * @tc.name: TimeRecycledGetXattr
2448 * @tc.desc: Verify the CloudDiskRdbStore::TimeRecycledGetXattr function
2449 * @tc.type: FUNC
2450 */
2451 HWTEST_F(CloudDiskRdbStoreTest, TimeRecycledGetXattrTest4, TestSize.Level1)
2452 {
2453 const std::string cloudId = "100";
2454 const std::string key = CLOUD_TIME_RECYCLED;
2455 std::string value = "";
2456 bool preCount = true;
2457 auto rdb = make_shared<RdbStoreMock>();
2458 clouddiskrdbStore_->rdbStore_ = rdb;
2459 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2460 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
2461
2462 int32_t ret = clouddiskrdbStore_->TimeRecycledGetXattr(cloudId, key, value);
2463 EXPECT_EQ(ret, E_RDB);
2464 }
2465
2466 /**
2467 * @tc.name: TimeRecycledGetXattr
2468 * @tc.desc: Verify the CloudDiskRdbStore::TimeRecycledGetXattr function
2469 * @tc.type: FUNC
2470 */
2471 HWTEST_F(CloudDiskRdbStoreTest, TimeRecycledGetXattrTest5, TestSize.Level1)
2472 {
2473 const std::string cloudId = "100";
2474 const std::string key = CLOUD_TIME_RECYCLED;
2475 std::string value = "";
2476 bool preCount = true;
2477 auto rdb = make_shared<RdbStoreMock>();
2478 clouddiskrdbStore_->rdbStore_ = rdb;
2479 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2480 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2481 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2482 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
2483
2484 int32_t ret = clouddiskrdbStore_->TimeRecycledGetXattr(cloudId, key, value);
2485 EXPECT_EQ(ret, E_RDB);
2486 }
2487
2488 /**
2489 * @tc.name: TimeRecycledGetXattr
2490 * @tc.desc: Verify the CloudDiskRdbStore::TimeRecycledGetXattr function
2491 * @tc.type: FUNC
2492 */
2493 HWTEST_F(CloudDiskRdbStoreTest, TimeRecycledGetXattrTest6, TestSize.Level1)
2494 {
2495 const std::string cloudId = "100";
2496 const std::string key = CLOUD_TIME_RECYCLED;
2497 std::string value = "";
2498 bool preCount = true;
2499 auto rdb = make_shared<RdbStoreMock>();
2500 clouddiskrdbStore_->rdbStore_ = rdb;
2501 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2502 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2503 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2504 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2505 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
2506
2507 int32_t ret = clouddiskrdbStore_->TimeRecycledGetXattr(cloudId, key, value);
2508 EXPECT_EQ(ret, E_OK);
2509 }
2510
2511 /**
2512 * @tc.name: GetExtAttrValue
2513 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2514 * @tc.type: FUNC
2515 */
2516 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrValueTest1, TestSize.Level1)
2517 {
2518 const std::string cloudId = "";
2519 const std::string key = "100";
2520 std::string value = "";
2521 auto rdb = make_shared<RdbStoreMock>();
2522 clouddiskrdbStore_->rdbStore_ = rdb;
2523
2524 int32_t ret = clouddiskrdbStore_->GetExtAttrValue(cloudId, key, value);
2525 EXPECT_EQ(ret, E_INVAL_ARG);
2526 }
2527
2528 /**
2529 * @tc.name: GetExtAttrValue
2530 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2531 * @tc.type: FUNC
2532 */
2533 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrValueTest2, TestSize.Level1)
2534 {
2535 const std::string cloudId = "rootId";
2536 const std::string key = "100";
2537 std::string value = "100";
2538 bool preCount = true;
2539 auto rdb = make_shared<RdbStoreMock>();
2540 clouddiskrdbStore_->rdbStore_ = rdb;
2541
2542 int32_t ret = clouddiskrdbStore_->GetExtAttrValue(cloudId, key, value);
2543 EXPECT_EQ(ret, E_INVAL_ARG);
2544 }
2545
2546 /**
2547 * @tc.name: GetExtAttrValue
2548 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2549 * @tc.type: FUNC
2550 */
2551 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrValueTest3, TestSize.Level1)
2552 {
2553 const std::string cloudId = "100";
2554 const std::string key = "";
2555 std::string value = "100";
2556 bool preCount = true;
2557 auto rdb = make_shared<RdbStoreMock>();
2558 clouddiskrdbStore_->rdbStore_ = rdb;
2559
2560 int32_t ret = clouddiskrdbStore_->GetExtAttrValue(cloudId, key, value);
2561 EXPECT_EQ(ret, E_INVAL_ARG);
2562 }
2563
2564 /**
2565 * @tc.name: GetExtAttrValue
2566 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2567 * @tc.type: FUNC
2568 */
2569 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrValueTest4, TestSize.Level1)
2570 {
2571 const std::string cloudId = "100";
2572 const std::string key = "100";
2573 std::string value = "100";
2574 bool preCount = true;
2575 auto rdb = make_shared<RdbStoreMock>();
2576 clouddiskrdbStore_->rdbStore_ = rdb;
2577 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2578 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
2579
2580 int32_t ret = clouddiskrdbStore_->GetExtAttrValue(cloudId, key, value);
2581 EXPECT_EQ(ret, E_RDB);
2582 }
2583
2584 /**
2585 * @tc.name: GetExtAttrValue
2586 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2587 * @tc.type: FUNC
2588 */
2589 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrValueTest5, TestSize.Level1)
2590 {
2591 const std::string cloudId = "100";
2592 const std::string key = "100";
2593 std::string value = "100";
2594 std::string mockValue = "";
2595 bool preCount = true;
2596 auto rdb = make_shared<RdbStoreMock>();
2597 clouddiskrdbStore_->rdbStore_ = rdb;
2598 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2599 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2600 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2601 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2602 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(mockValue), Return(E_OK)));
2603 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
2604
2605 int32_t ret = clouddiskrdbStore_->GetExtAttrValue(cloudId, key, value);
2606 EXPECT_EQ(ret, E_RDB);
2607 }
2608
2609 /**
2610 * @tc.name: GetExtAttrValue
2611 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2612 * @tc.type: FUNC
2613 */
2614 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrValueTest6, TestSize.Level1)
2615 {
2616 const std::string cloudId = "100";
2617 const std::string key = "100";
2618 std::string value = "100";
2619 std::string mockValue = "invalid";
2620 bool preCount = true;
2621 auto rdb = make_shared<RdbStoreMock>();
2622 clouddiskrdbStore_->rdbStore_ = rdb;
2623 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2624 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2625 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2626 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2627 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(mockValue), Return(E_OK)));
2628 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
2629
2630 int32_t ret = clouddiskrdbStore_->GetExtAttrValue(cloudId, key, value);
2631 EXPECT_EQ(ret, E_RDB);
2632 }
2633
2634 /**
2635 * @tc.name: GetExtAttrValue
2636 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2637 * @tc.type: FUNC
2638 */
2639 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrValueTest7, TestSize.Level1)
2640 {
2641 const std::string cloudId = "100";
2642 const std::string key = "test";
2643 std::string value = "100";
2644 std::string mockValue = R"({"key": "/data/service"})";
2645 bool preCount = true;
2646 auto rdb = make_shared<RdbStoreMock>();
2647 clouddiskrdbStore_->rdbStore_ = rdb;
2648 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2649 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2650 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2651 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2652 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(mockValue), Return(E_OK)));
2653 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
2654
2655 int32_t ret = clouddiskrdbStore_->GetExtAttrValue(cloudId, key, value);
2656 EXPECT_EQ(ret, E_RDB);
2657 }
2658
2659 /**
2660 * @tc.name: GetExtAttrValue
2661 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2662 * @tc.type: FUNC
2663 */
2664 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrValueTest8, TestSize.Level1)
2665 {
2666 const std::string cloudId = "100";
2667 const std::string key = "key";
2668 std::string value = "100";
2669 std::string mockValue = R"({"key": 123})";
2670 bool preCount = true;
2671 auto rdb = make_shared<RdbStoreMock>();
2672 clouddiskrdbStore_->rdbStore_ = rdb;
2673 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2674 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2675 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2676 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2677 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(mockValue), Return(E_OK)));
2678 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
2679
2680 int32_t ret = clouddiskrdbStore_->GetExtAttrValue(cloudId, key, value);
2681 EXPECT_EQ(ret, E_RDB);
2682 }
2683
2684 /**
2685 * @tc.name: GetExtAttrValue
2686 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2687 * @tc.type: FUNC
2688 */
2689 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrValueTest9, TestSize.Level1)
2690 {
2691 const std::string cloudId = "100";
2692 const std::string key = "key";
2693 std::string value = "100";
2694 std::string mockValue = R"({"key": "/data/service"})";
2695 bool preCount = true;
2696 auto rdb = make_shared<RdbStoreMock>();
2697 clouddiskrdbStore_->rdbStore_ = rdb;
2698 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2699 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2700 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2701 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2702 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(mockValue), Return(E_OK)));
2703 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
2704
2705 int32_t ret = clouddiskrdbStore_->GetExtAttrValue(cloudId, key, value);
2706 EXPECT_EQ(ret, E_OK);
2707 }
2708
2709 /**
2710 * @tc.name: GetExtAttr
2711 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2712 * @tc.type: FUNC
2713 */
2714 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest1, TestSize.Level1)
2715 {
2716 const std::string cloudId = "";
2717 std::string value = "";
2718 int32_t pos = 0;
2719 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
2720 auto rdb = make_shared<RdbStoreMock>();
2721 clouddiskrdbStore_->rdbStore_ = rdb;
2722 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos, dirtyType);
2723 EXPECT_EQ(ret, E_INVAL_ARG);
2724 }
2725
2726 /**
2727 * @tc.name: GetExtAttr
2728 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2729 * @tc.type: FUNC
2730 */
2731 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest2, TestSize.Level1)
2732 {
2733 const std::string cloudId = "rootId";
2734 std::string value = "";
2735 int32_t pos = 0;
2736 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
2737 auto rdb = make_shared<RdbStoreMock>();
2738 clouddiskrdbStore_->rdbStore_ = rdb;
2739 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos, dirtyType);
2740 EXPECT_EQ(ret, E_INVAL_ARG);
2741 }
2742
2743 /**
2744 * @tc.name: GetExtAttr
2745 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2746 * @tc.type: FUNC
2747 */
2748 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest3, TestSize.Level1)
2749 {
2750 const std::string cloudId = "100";
2751 std::string value = "mock";
2752 int32_t pos = 0;
2753 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
2754 bool preCount = true;
2755 auto rdb = make_shared<RdbStoreMock>();
2756 clouddiskrdbStore_->rdbStore_ = rdb;
2757 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2758 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
2759
2760 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos, dirtyType);
2761 EXPECT_EQ(ret, E_RDB);
2762 }
2763
2764 /**
2765 * @tc.name: GetExtAttr
2766 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2767 * @tc.type: FUNC
2768 */
2769 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest4, TestSize.Level1)
2770 {
2771 const std::string cloudId = "100";
2772 std::string value = "";
2773 int32_t pos = 0;
2774 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
2775 bool preCount = true;
2776 auto rdb = make_shared<RdbStoreMock>();
2777 clouddiskrdbStore_->rdbStore_ = rdb;
2778 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2779 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2780 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2781 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
2782
2783 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos, dirtyType);
2784 EXPECT_EQ(ret, E_RDB);
2785 }
2786
2787 /**
2788 * @tc.name: GetExtAttr
2789 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2790 * @tc.type: FUNC
2791 */
2792 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest5, TestSize.Level1)
2793 {
2794 const std::string cloudId = "100";
2795 std::string value = "mock";
2796 int32_t pos = 0;
2797 bool preCount = true;
2798 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
2799 auto rdb = make_shared<RdbStoreMock>();
2800 clouddiskrdbStore_->rdbStore_ = rdb;
2801 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2802 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2803 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2804 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2805 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_RDB));
2806
2807 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos, dirtyType);
2808 EXPECT_EQ(ret, E_RDB);
2809 }
2810
2811 /**
2812 * @tc.name: GetExtAttr
2813 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2814 * @tc.type: FUNC
2815 */
2816 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest6, TestSize.Level1)
2817 {
2818 const std::string cloudId = "100";
2819 std::string value = "";
2820 int32_t pos = -1;
2821 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
2822 bool preCount = true;
2823 auto rdb = make_shared<RdbStoreMock>();
2824 clouddiskrdbStore_->rdbStore_ = rdb;
2825 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2826 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2827 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2828 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2829 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
2830 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_RDB));
2831
2832 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos, dirtyType);
2833 EXPECT_EQ(ret, E_RDB);
2834 }
2835
2836 /**
2837 * @tc.name: GetExtAttr
2838 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2839 * @tc.type: FUNC
2840 */
2841 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest7, TestSize.Level1)
2842 {
2843 const std::string cloudId = "100";
2844 std::string value = "";
2845 int32_t pos = -1;
2846 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
2847 bool preCount = true;
2848 auto rdb = make_shared<RdbStoreMock>();
2849 clouddiskrdbStore_->rdbStore_ = rdb;
2850 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2851 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2852 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2853 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2854 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
2855 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
2856
2857 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos, dirtyType);
2858 EXPECT_EQ(ret, E_OK);
2859 }
2860
2861 /**
2862 * @tc.name: GetExtAttr
2863 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2864 * @tc.type: FUNC
2865 */
2866 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest8, TestSize.Level1)
2867 {
2868 const std::string cloudId = "100";
2869 std::string value = "";
2870 int32_t pos = 1;
2871 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
2872 bool preCount = true;
2873 auto rdb = make_shared<RdbStoreMock>();
2874 clouddiskrdbStore_->rdbStore_ = rdb;
2875 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2876 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2877 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2878 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2879
2880 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos, dirtyType);
2881 EXPECT_EQ(ret, E_OK);
2882 }
2883
2884 /**
2885 * @tc.name: GetExtAttr
2886 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
2887 * @tc.type: FUNC
2888 */
2889 HWTEST_F(CloudDiskRdbStoreTest, GetExtAttrTest9, TestSize.Level1)
2890 {
2891 const std::string cloudId = "100";
2892 std::string value = "";
2893 int32_t pos = 1;
2894 int32_t dirtyType = static_cast<int32_t>(DirtyType::TYPE_SYNCED);
2895 bool preCount = true;
2896 auto rdb = make_shared<RdbStoreMock>();
2897 clouddiskrdbStore_->rdbStore_ = rdb;
2898 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
2899 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
2900 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
2901 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
2902 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
2903 EXPECT_CALL(*rset, GetInt(_, _)).WillOnce(Return(E_OK)).WillOnce(Return(E_RDB));
2904
2905 int32_t ret = clouddiskrdbStore_->GetExtAttr(cloudId, value, pos, dirtyType);
2906 EXPECT_EQ(ret, E_RDB);
2907 }
2908
2909 /**
2910 * @tc.name: GetXAttr
2911 * @tc.desc: Verify the CloudDiskRdbStore::GetXAttr function
2912 * @tc.type: FUNC
2913 */
2914 HWTEST_F(CloudDiskRdbStoreTest, GetXAttrTest1, TestSize.Level1)
2915 {
2916 const std::string cloudId = "";
2917 const std::string key = CLOUD_FILE_LOCATION;
2918 std::string value = "";
2919 CacheNode node;
2920 node.fileName = "test";
2921 node.parentCloudId = "100";
2922 auto rdb = make_shared<RdbStoreMock>();
2923 clouddiskrdbStore_->rdbStore_ = rdb;
2924 int32_t ret = clouddiskrdbStore_->GetXAttr(cloudId, key, value);
2925 EXPECT_EQ(ret, E_OK);
2926 }
2927
2928 /**
2929 * @tc.name: GetXAttr
2930 * @tc.desc: Verify the CloudDiskRdbStore::GetXAttr function
2931 * @tc.type: FUNC
2932 */
2933 HWTEST_F(CloudDiskRdbStoreTest, GetXAttrTest2, TestSize.Level1)
2934 {
2935 const std::string cloudId = "";
2936 const std::string key = IS_FAVORITE_XATTR;
2937 std::string value = "";
2938 auto rdb = make_shared<RdbStoreMock>();
2939 clouddiskrdbStore_->rdbStore_ = rdb;
2940 int32_t ret = clouddiskrdbStore_->GetXAttr(cloudId, key, value);
2941 EXPECT_EQ(ret, E_INVAL_ARG);
2942 }
2943
2944 /**
2945 * @tc.name: GetXAttr
2946 * @tc.desc: Verify the CloudDiskRdbStore::GetXAttr function
2947 * @tc.type: FUNC
2948 */
2949 HWTEST_F(CloudDiskRdbStoreTest, GetXAttrTest3, TestSize.Level1)
2950 {
2951 const std::string cloudId = "";
2952 const std::string key = IS_FILE_STATUS_XATTR;
2953 std::string value = "";
2954 auto rdb = make_shared<RdbStoreMock>();
2955 clouddiskrdbStore_->rdbStore_ = rdb;
2956 int32_t ret = clouddiskrdbStore_->GetXAttr(cloudId, key, value);
2957 EXPECT_EQ(ret, E_INVAL_ARG);
2958 }
2959
2960 /**
2961 * @tc.name: GetXAttr
2962 * @tc.desc: Verify the CloudDiskRdbStore::GetXAttr function
2963 * @tc.type: FUNC
2964 */
2965 HWTEST_F(CloudDiskRdbStoreTest, GetXAttrTest4, TestSize.Level1)
2966 {
2967 const std::string cloudId = "";
2968 const std::string key = CLOUD_EXT_ATTR;
2969 std::string value = "";
2970 auto rdb = make_shared<RdbStoreMock>();
2971 clouddiskrdbStore_->rdbStore_ = rdb;
2972 int32_t ret = clouddiskrdbStore_->GetXAttr(cloudId, key, value);
2973 EXPECT_EQ(ret, E_INVAL_ARG);
2974 }
2975
2976 /**
2977 * @tc.name: GetXAttr
2978 * @tc.desc: Verify the CloudDiskRdbStore::GetXAttr function
2979 * @tc.type: FUNC
2980 */
2981 HWTEST_F(CloudDiskRdbStoreTest, GetXAttrTest5, TestSize.Level1)
2982 {
2983 const std::string cloudId = "";
2984 const std::string key = CLOUD_TIME_RECYCLED;
2985 std::string value = "";
2986 auto rdb = make_shared<RdbStoreMock>();
2987 clouddiskrdbStore_->rdbStore_ = rdb;
2988 int32_t ret = clouddiskrdbStore_->GetXAttr(cloudId, key, value);
2989 EXPECT_EQ(ret, E_INVAL_ARG);
2990 }
2991
2992 /**
2993 * @tc.name: GetXAttr
2994 * @tc.desc: Verify the CloudDiskRdbStore::GetXAttr function
2995 * @tc.type: FUNC
2996 */
2997 HWTEST_F(CloudDiskRdbStoreTest, GetXAttrTest6, TestSize.Level1)
2998 {
2999 const std::string cloudId = "";
3000 const std::string key = CLOUD_HAS_THM;
3001 std::string value = "";
3002 auto rdb = make_shared<RdbStoreMock>();
3003 clouddiskrdbStore_->rdbStore_ = rdb;
3004 int32_t ret = clouddiskrdbStore_->GetXAttr(cloudId, key, value);
3005 EXPECT_EQ(ret, ENOSYS);
3006 }
3007
3008 /**
3009 * @tc.name: ExtAttributeSetXattr
3010 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
3011 * @tc.type: FUNC
3012 */
3013 HWTEST_F(CloudDiskRdbStoreTest, ExtAttributeSetXattrTest1, TestSize.Level1)
3014 {
3015 const std::string cloudId = "cloudId";
3016 const std::string key = "key1";
3017 const std::string value = "value1";
3018 std::string xattrList = "";
3019 int32_t pos = 0;
3020 bool preCount = true;
3021 auto rdb = make_shared<RdbStoreMock>();
3022 clouddiskrdbStore_->rdbStore_ = rdb;
3023 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3024 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3025 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3026 auto transaction = make_shared<TransactionMock>();
3027 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
3028 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
3029 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
3030 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(xattrList), Return(E_OK)));
3031 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(pos), Return(E_OK)));
3032
3033 int32_t ret = clouddiskrdbStore_->ExtAttributeSetXattr(cloudId, value, key);
3034 EXPECT_EQ(ret, E_RDB);
3035 }
3036
3037 /**
3038 * @tc.name: ExtAttributeSetXattr
3039 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
3040 * @tc.type: FUNC
3041 */
3042 HWTEST_F(CloudDiskRdbStoreTest, ExtAttributeSetXattrTest2, TestSize.Level1)
3043 {
3044 const std::string cloudId = "cloudId";
3045 const std::string key = "key1";
3046 const std::string value = "value1";
3047 std::string xattrList = "{\"key2\":\"value2\"}";;
3048 int32_t pos = 0;
3049 bool preCount = true;
3050 auto rdb = make_shared<RdbStoreMock>();
3051 clouddiskrdbStore_->rdbStore_ = rdb;
3052 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3053 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3054 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3055 auto transaction = make_shared<TransactionMock>();
3056 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
3057 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
3058 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
3059 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(xattrList), Return(E_OK)));
3060 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(pos), Return(E_OK)));
3061
3062 int32_t ret = clouddiskrdbStore_->ExtAttributeSetXattr(cloudId, value, key);
3063 EXPECT_EQ(ret, E_RDB);
3064 }
3065
3066 /**
3067 * @tc.name: ExtAttributeSetXattr
3068 * @tc.desc: Verify the CloudDiskRdbStore::ExtAttributeSetXattr function
3069 * @tc.type: FUNC
3070 */
3071 HWTEST_F(CloudDiskRdbStoreTest, ExtAttributeSetXattrTest3, TestSize.Level1)
3072 {
3073 const std::string cloudId = "cloudId";
3074 const std::string key = "key1";
3075 const std::string value = "value1";
3076 std::string xattrList = "{\"key1\":\"value1\"}";;
3077 int32_t pos = 1;
3078 bool preCount = true;
3079 auto rdb = make_shared<RdbStoreMock>();
3080 clouddiskrdbStore_->rdbStore_ = rdb;
3081 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3082 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3083 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3084 auto transaction = make_shared<TransactionMock>();
3085 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
3086 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
3087 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
3088 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(xattrList), Return(E_OK)));
3089 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(pos), Return(E_OK)));
3090
3091 int32_t ret = clouddiskrdbStore_->ExtAttributeSetXattr(cloudId, value, key);
3092 EXPECT_EQ(ret, E_OK);
3093 }
3094
3095 /**
3096 * @tc.name: SetXAttr
3097 * @tc.desc: Verify the CloudDiskRdbStore::SetXAttr function
3098 * @tc.type: FUNC
3099 */
3100 HWTEST_F(CloudDiskRdbStoreTest, SetXAttrTest1, TestSize.Level1)
3101 {
3102 const std::string cloudId = "100";
3103 const std::string key = CLOUD_FILE_LOCATION;
3104 const std::string value = "notnum";
3105 const std::string name = "test";
3106 const std::string parentCloudId = "100";
3107 auto rdb = make_shared<RdbStoreMock>();
3108 clouddiskrdbStore_->rdbStore_ = rdb;
3109 int32_t ret = clouddiskrdbStore_->SetXAttr(cloudId, key, value, name, parentCloudId);
3110 EXPECT_EQ(ret, E_INVAL_ARG);
3111 }
3112
3113 /**
3114 * @tc.name: SetXAttr
3115 * @tc.desc: Verify the CloudDiskRdbStore::SetXAttr function
3116 * @tc.type: FUNC
3117 */
3118 HWTEST_F(CloudDiskRdbStoreTest, SetXAttrTest2, TestSize.Level1)
3119 {
3120 const std::string cloudId = "100";
3121 const std::string key = CLOUD_CLOUD_RECYCLE_XATTR;
3122 const std::string value = "notnum";
3123 const std::string name = "test";
3124 const std::string parentCloudId = "100";
3125 auto rdb = make_shared<RdbStoreMock>();
3126 clouddiskrdbStore_->rdbStore_ = rdb;
3127 int32_t ret = clouddiskrdbStore_->SetXAttr(cloudId, key, value, name, parentCloudId);
3128 EXPECT_EQ(ret, EINVAL);
3129 }
3130
3131 /**
3132 * @tc.name: SetXAttr
3133 * @tc.desc: Verify the CloudDiskRdbStore::SetXAttr function
3134 * @tc.type: FUNC
3135 */
3136 HWTEST_F(CloudDiskRdbStoreTest, SetXAttrTest3, TestSize.Level1)
3137 {
3138 const std::string cloudId = "100";
3139 const std::string key = IS_FAVORITE_XATTR;
3140 const std::string value = "notnum";
3141 const std::string name = "test";
3142 const std::string parentCloudId = "100";
3143 auto rdb = make_shared<RdbStoreMock>();
3144 clouddiskrdbStore_->rdbStore_ = rdb;
3145 int32_t ret = clouddiskrdbStore_->SetXAttr(cloudId, key, value, name, parentCloudId);
3146 EXPECT_EQ(ret, EINVAL);
3147 }
3148
3149 /**
3150 * @tc.name: SetXAttr
3151 * @tc.desc: Verify the CloudDiskRdbStore::SetXAttr function
3152 * @tc.type: FUNC
3153 */
3154 HWTEST_F(CloudDiskRdbStoreTest, SetXAttrTest4, TestSize.Level1)
3155 {
3156 const std::string cloudId = "100";
3157 const std::string key = CLOUD_EXT_ATTR;
3158 const std::string value = "notnum";
3159 const std::string name = "test";
3160 const std::string parentCloudId = "100";
3161 auto rdb = make_shared<RdbStoreMock>();
3162 clouddiskrdbStore_->rdbStore_ = rdb;
3163 int32_t ret = clouddiskrdbStore_->SetXAttr(cloudId, key, value, name, parentCloudId);
3164 EXPECT_EQ(ret, E_RDB);
3165 }
3166
3167 /**
3168 * @tc.name: SetXAttr
3169 * @tc.desc: Verify the CloudDiskRdbStore::SetXAttr function
3170 * @tc.type: FUNC
3171 */
3172 HWTEST_F(CloudDiskRdbStoreTest, SetXAttrTest5, TestSize.Level1)
3173 {
3174 const std::string cloudId = "100";
3175 const std::string key = CLOUD_HAS_THM;
3176 const std::string value = "notnum";
3177 const std::string name = "test";
3178 const std::string parentCloudId = "100";
3179 auto rdb = make_shared<RdbStoreMock>();
3180 clouddiskrdbStore_->rdbStore_ = rdb;
3181
3182 int32_t ret = clouddiskrdbStore_->SetXAttr(cloudId, key, value, name, parentCloudId);
3183 EXPECT_EQ(ret, E_INVAL_ARG);
3184 }
3185
3186 /**
3187 * @tc.name: SetXAttr
3188 * @tc.desc: Verify the CloudDiskRdbStore::SetXAttr function
3189 * @tc.type: FUNC
3190 */
3191 HWTEST_F(CloudDiskRdbStoreTest, SetXAttrTest6, TestSize.Level1)
3192 {
3193 const std::string cloudId = "100";
3194 const std::string key = CLOUD_CLOUD_ID_XATTR;
3195 const std::string value = "notnum";
3196 const std::string name = "test";
3197 const std::string parentCloudId = "100";
3198 auto rdb = make_shared<RdbStoreMock>();
3199 clouddiskrdbStore_->rdbStore_ = rdb;
3200
3201 int32_t ret = clouddiskrdbStore_->SetXAttr(cloudId, key, value, name, parentCloudId);
3202 EXPECT_EQ(ret, ENOSYS);
3203 }
3204
3205 /**
3206 * @tc.name: Rename
3207 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
3208 * @tc.type: FUNC
3209 */
3210 HWTEST_F(CloudDiskRdbStoreTest, RenameTest1, TestSize.Level1)
3211 {
3212 const std::string oldParentCloudId = "100";
3213 const std::string oldFileName = "test";
3214 const std::string newParentCloudId = "100";
3215 const std::string newFileName = "";
3216 const bool newFileNoNeedUpload = false;
3217 auto rdb = make_shared<RdbStoreMock>();
3218 clouddiskrdbStore_->rdbStore_ = rdb;
3219
3220 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName,
3221 newFileNoNeedUpload);
3222 EXPECT_EQ(ret, EINVAL);
3223 }
3224
3225 /**
3226 * @tc.name: Rename
3227 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
3228 * @tc.type: FUNC
3229 */
3230 HWTEST_F(CloudDiskRdbStoreTest, RenameTest2, TestSize.Level1)
3231 {
3232 const std::string oldParentCloudId = "";
3233 const std::string oldFileName = "test";
3234 const std::string newParentCloudId = "100";
3235 const std::string newFileName = "newFileName";
3236 const bool newFileNoNeedUpload = false;
3237 auto rdb = make_shared<RdbStoreMock>();
3238 clouddiskrdbStore_->rdbStore_ = rdb;
3239
3240 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName,
3241 newFileNoNeedUpload);
3242 EXPECT_EQ(ret, E_INVAL_ARG);
3243 }
3244
3245 /**
3246 * @tc.name: Rename
3247 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
3248 * @tc.type: FUNC
3249 */
3250 HWTEST_F(CloudDiskRdbStoreTest, RenameTest3, TestSize.Level1)
3251 {
3252 const std::string oldParentCloudId = "100";
3253 const std::string oldFileName = "";
3254 const std::string newParentCloudId = "100";
3255 const std::string newFileName = "newFileName";
3256 const bool newFileNoNeedUpload = false;
3257 auto rdb = make_shared<RdbStoreMock>();
3258 clouddiskrdbStore_->rdbStore_ = rdb;
3259
3260 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName,
3261 newFileNoNeedUpload);
3262 EXPECT_EQ(ret, E_INVAL_ARG);
3263 }
3264
3265 /**
3266 * @tc.name: Rename
3267 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
3268 * @tc.type: FUNC
3269 */
3270 HWTEST_F(CloudDiskRdbStoreTest, RenameTest4, TestSize.Level1)
3271 {
3272 const std::string oldParentCloudId = "100";
3273 const std::string oldFileName = "test";
3274 const std::string newParentCloudId = "";
3275 const std::string newFileName = "newFileName";
3276 const bool newFileNoNeedUpload = false;
3277 auto rdb = make_shared<RdbStoreMock>();
3278 clouddiskrdbStore_->rdbStore_ = rdb;
3279
3280 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName,
3281 newFileNoNeedUpload);
3282 EXPECT_EQ(ret, E_INVAL_ARG);
3283 }
3284
3285 /**
3286 * @tc.name: Rename
3287 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
3288 * @tc.type: FUNC
3289 */
3290 HWTEST_F(CloudDiskRdbStoreTest, RenameTest5, TestSize.Level1)
3291 {
3292 const std::string oldParentCloudId = "10";
3293 const std::string oldFileName = "mock";
3294 const std::string newParentCloudId = "100";
3295 const std::string newFileName = "newFileName";
3296 const bool newFileNoNeedUpload = false;
3297 auto rdb = make_shared<RdbStoreMock>();
3298 clouddiskrdbStore_->rdbStore_ = rdb;
3299
3300 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName,
3301 newFileNoNeedUpload);
3302 EXPECT_EQ(ret, EINVAL);
3303 }
3304
3305 /**
3306 * @tc.name: Rename
3307 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
3308 * @tc.type: FUNC
3309 */
3310 HWTEST_F(CloudDiskRdbStoreTest, RenameTest6, TestSize.Level1)
3311 {
3312 const std::string oldParentCloudId = "10";
3313 const std::string oldFileName = "oldFileName";
3314 const std::string newParentCloudId = "100";
3315 const std::string newFileName = "..";
3316 const bool newFileNoNeedUpload = false;
3317 auto rdb = make_shared<RdbStoreMock>();
3318 clouddiskrdbStore_->rdbStore_ = rdb;
3319
3320 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName,
3321 newFileNoNeedUpload);
3322 EXPECT_EQ(ret, EINVAL);
3323 }
3324
3325 /**
3326 * @tc.name: Rename
3327 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
3328 * @tc.type: FUNC
3329 */
3330 HWTEST_F(CloudDiskRdbStoreTest, RenameTest7, TestSize.Level1)
3331 {
3332 const std::string oldParentCloudId = "100";
3333 const std::string oldFileName = "oldFileName";
3334 const std::string newParentCloudId = "100";
3335 const std::string newFileName = "mock";
3336 const bool newFileNoNeedUpload = false;
3337 auto rdb = make_shared<RdbStoreMock>();
3338 clouddiskrdbStore_->rdbStore_ = rdb;
3339
3340 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName,
3341 newFileNoNeedUpload);
3342 EXPECT_EQ(ret, EINVAL);
3343 }
3344
3345 /**
3346 * @tc.name: Rename
3347 * @tc.desc: Verify the CloudDiskRdbStore::Rename function
3348 * @tc.type: FUNC
3349 */
3350 HWTEST_F(CloudDiskRdbStoreTest, RenameTest8, TestSize.Level1)
3351 {
3352 const std::string oldParentCloudId = "10";
3353 const std::string oldFileName = "oldFileName";
3354 const std::string newParentCloudId = "100";
3355 const std::string newFileName = "mock";
3356 const bool newFileNoNeedUpload = false;
3357 auto rdb = make_shared<RdbStoreMock>();
3358 clouddiskrdbStore_->rdbStore_ = rdb;
3359
3360 int32_t ret = clouddiskrdbStore_->Rename(oldParentCloudId, oldFileName, newParentCloudId, newFileName,
3361 newFileNoNeedUpload);
3362 EXPECT_EQ(ret, EINVAL);
3363 }
3364
3365 /**
3366 * @tc.name: GetHasChild
3367 * @tc.desc: Verify the CloudDiskRdbStore::GetHasChild function
3368 * @tc.type: FUNC
3369 */
3370 HWTEST_F(CloudDiskRdbStoreTest, GetHasChildTest1, TestSize.Level1)
3371 {
3372 const std::string cloudId = "100";
3373 bool hasChild = true;
3374 bool preCount = true;
3375 auto rdb = make_shared<RdbStoreMock>();
3376 clouddiskrdbStore_->rdbStore_ = rdb;
3377 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3378 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
3379 int32_t ret = clouddiskrdbStore_->GetHasChild(cloudId, hasChild);
3380 EXPECT_EQ(ret, E_RDB);
3381 }
3382
3383 /**
3384 * @tc.name: GetHasChild
3385 * @tc.desc: Verify the CloudDiskRdbStore::GetHasChild function
3386 * @tc.type: FUNC
3387 */
3388 HWTEST_F(CloudDiskRdbStoreTest, GetHasChildTest2, TestSize.Level1)
3389 {
3390 const std::string cloudId = "100";
3391 bool hasChild = true;
3392 bool preCount = true;
3393 auto rdb = make_shared<RdbStoreMock>();
3394 clouddiskrdbStore_->rdbStore_ = rdb;
3395 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3396 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3397 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3398 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
3399 int32_t ret = clouddiskrdbStore_->GetHasChild(cloudId, hasChild);
3400 EXPECT_EQ(ret, E_OK);
3401 }
3402
3403 /**
3404 * @tc.name: GetHasChild
3405 * @tc.desc: Verify the CloudDiskRdbStore::GetHasChild function
3406 * @tc.type: FUNC
3407 */
3408 HWTEST_F(CloudDiskRdbStoreTest, GetHasChildTest3, TestSize.Level1)
3409 {
3410 const std::string cloudId = "100";
3411 bool hasChild = true;
3412 bool preCount = true;
3413 auto rdb = make_shared<RdbStoreMock>();
3414 clouddiskrdbStore_->rdbStore_ = rdb;
3415 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3416 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3417 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3418 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
3419 int32_t ret = clouddiskrdbStore_->GetHasChild(cloudId, hasChild);
3420 EXPECT_EQ(ret, E_OK);
3421 }
3422
3423 /**
3424 * @tc.name: UnlinkSynced
3425 * @tc.desc: Verify the CloudDiskRdbStore::UnlinkSynced function
3426 * @tc.type: FUNC
3427 */
3428 HWTEST_F(CloudDiskRdbStoreTest, UnlinkSyncedTest1, TestSize.Level1)
3429 {
3430 const std::string cloudId = "100";
3431 auto rdb = make_shared<RdbStoreMock>();
3432 clouddiskrdbStore_->rdbStore_ = rdb;
3433 EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<std::string> &>())).WillOnce(Return(E_RDB));
3434
3435 int32_t ret = clouddiskrdbStore_->UnlinkSynced(cloudId);
3436 EXPECT_EQ(ret, E_RDB);
3437 }
3438
3439 /**
3440 * @tc.name: UnlinkSynced
3441 * @tc.desc: Verify the CloudDiskRdbStore::UnlinkSynced function
3442 * @tc.type: FUNC
3443 */
3444 HWTEST_F(CloudDiskRdbStoreTest, UnlinkSyncedTest2, TestSize.Level1)
3445 {
3446 const std::string cloudId = "100";
3447 auto rdb = make_shared<RdbStoreMock>();
3448 clouddiskrdbStore_->rdbStore_ = rdb;
3449 EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<std::string> &>())).WillOnce(Return(E_OK));
3450
3451 int32_t ret = clouddiskrdbStore_->UnlinkSynced(cloudId);
3452 EXPECT_EQ(ret, E_OK);
3453 }
3454
3455 /**
3456 * @tc.name: UnlinkLocal
3457 * @tc.desc: Verify the CloudDiskRdbStore::UnlinkLocal function
3458 * @tc.type: FUNC
3459 */
3460 HWTEST_F(CloudDiskRdbStoreTest, UnlinkLocalTest1, TestSize.Level1)
3461 {
3462 const std::string cloudId = "100";
3463 auto rdb = make_shared<RdbStoreMock>();
3464 clouddiskrdbStore_->rdbStore_ = rdb;
3465 EXPECT_CALL(*rdb, Delete(_, _, _, An<const std::vector<std::string> &>())).WillOnce(Return(E_RDB));
3466
3467 int32_t ret = clouddiskrdbStore_->UnlinkLocal(cloudId);
3468 EXPECT_EQ(ret, E_RDB);
3469 }
3470
3471 /**
3472 * @tc.name: UnlinkLocal
3473 * @tc.desc: Verify the CloudDiskRdbStore::UnlinkLocal function
3474 * @tc.type: FUNC
3475 */
3476 HWTEST_F(CloudDiskRdbStoreTest, UnlinkLocalTest2, TestSize.Level1)
3477 {
3478 const std::string cloudId = "100";
3479 auto rdb = make_shared<RdbStoreMock>();
3480 clouddiskrdbStore_->rdbStore_ = rdb;
3481 EXPECT_CALL(*rdb, Delete(_, _, _, An<const std::vector<std::string> &>())).WillOnce(Return(E_OK));
3482
3483 int32_t ret = clouddiskrdbStore_->UnlinkLocal(cloudId);
3484 EXPECT_EQ(ret, E_OK);
3485 }
3486
3487 /**
3488 * @tc.name: Unlink
3489 * @tc.desc: Verify the CloudDiskRdbStore::Unlink function
3490 * @tc.type: FUNC
3491 */
3492 HWTEST_F(CloudDiskRdbStoreTest, UnlinkTest1, TestSize.Level1)
3493 {
3494 std::string cloudId = "";
3495 const int32_t noUpload = 0;
3496 auto rdb = make_shared<RdbStoreMock>();
3497 clouddiskrdbStore_->rdbStore_ = rdb;
3498
3499 int32_t ret = clouddiskrdbStore_->Unlink(cloudId, noUpload);
3500 EXPECT_EQ(ret, E_INVAL_ARG);
3501 }
3502
3503 /**
3504 * @tc.name: Unlink
3505 * @tc.desc: Verify the CloudDiskRdbStore::Unlink function
3506 * @tc.type: FUNC
3507 */
3508 HWTEST_F(CloudDiskRdbStoreTest, UnlinkTest2, TestSize.Level1)
3509 {
3510 const int32_t noUpload = 1;
3511 std::string cloudId = "rootId";
3512 auto rdb = make_shared<RdbStoreMock>();
3513 clouddiskrdbStore_->rdbStore_ = rdb;
3514
3515 int32_t ret = clouddiskrdbStore_->Unlink(cloudId, noUpload);
3516 EXPECT_EQ(ret, E_INVAL_ARG);
3517 }
3518
3519 /**
3520 * @tc.name: Unlink
3521 * @tc.desc: Verify the CloudDiskRdbStore::Unlink function
3522 * @tc.type: FUNC
3523 */
3524 HWTEST_F(CloudDiskRdbStoreTest, UnlinkTest3, TestSize.Level1)
3525 {
3526 const int32_t noUpload = 1;
3527 std::string cloudId = "100";
3528 auto rdb = make_shared<RdbStoreMock>();
3529 clouddiskrdbStore_->rdbStore_ = rdb;
3530 EXPECT_CALL(*rdb, Delete(_, _, _, An<const std::vector<std::string> &>())).WillOnce(Return(E_OK));
3531
3532 int32_t ret = clouddiskrdbStore_->Unlink(cloudId, noUpload);
3533 EXPECT_EQ(ret, E_OK);
3534 }
3535
3536 /**
3537 * @tc.name: Unlink
3538 * @tc.desc: Verify the CloudDiskRdbStore::Unlink function
3539 * @tc.type: FUNC
3540 */
3541 HWTEST_F(CloudDiskRdbStoreTest, UnlinkTest4, TestSize.Level1)
3542 {
3543 const int32_t noUpload = 0;
3544 std::string cloudId = "100";
3545 auto rdb = make_shared<RdbStoreMock>();
3546 clouddiskrdbStore_->rdbStore_ = rdb;
3547 EXPECT_CALL(*rdb, Update(_, _, _, _, An<const std::vector<std::string> &>())).WillOnce(Return(E_OK));
3548
3549 int32_t ret = clouddiskrdbStore_->Unlink(cloudId, noUpload);
3550 EXPECT_EQ(ret, E_OK);
3551 }
3552
3553 /**
3554 * @tc.name: GetDirtyType
3555 * @tc.desc: Verify the CloudDiskRdbStore::GetDirtyType function
3556 * @tc.type: FUNC
3557 */
3558 HWTEST_F(CloudDiskRdbStoreTest, GetDirtyTypeTest1, TestSize.Level1)
3559 {
3560 int32_t dirtyType = 0;
3561 std::string cloudId = "100";
3562 bool preCount = true;
3563 auto rdb = make_shared<RdbStoreMock>();
3564 clouddiskrdbStore_->rdbStore_ = rdb;
3565 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3566 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
3567
3568 int32_t ret = clouddiskrdbStore_->GetDirtyType(cloudId, dirtyType);
3569 EXPECT_EQ(ret, E_RDB);
3570 }
3571
3572 /**
3573 * @tc.name: GetDirtyType
3574 * @tc.desc: Verify the CloudDiskRdbStore::GetDirtyType function
3575 * @tc.type: FUNC
3576 */
3577 HWTEST_F(CloudDiskRdbStoreTest, GetDirtyTypeTest2, TestSize.Level1)
3578 {
3579 int32_t dirtyType = 0;
3580 std::string cloudId = "100";
3581 bool preCount = true;
3582 auto rdb = make_shared<RdbStoreMock>();
3583 clouddiskrdbStore_->rdbStore_ = rdb;
3584 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3585 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3586 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3587 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
3588
3589 int32_t ret = clouddiskrdbStore_->GetDirtyType(cloudId, dirtyType);
3590 EXPECT_EQ(ret, E_RDB);
3591 }
3592
3593 /**
3594 * @tc.name: GetDirtyType
3595 * @tc.desc: Verify the CloudDiskRdbStore::GetDirtyType function
3596 * @tc.type: FUNC
3597 */
3598 HWTEST_F(CloudDiskRdbStoreTest, GetDirtyTypeTest3, TestSize.Level1)
3599 {
3600 int32_t dirtyType = -1;
3601 std::string cloudId = "100";
3602 bool preCount = true;
3603 auto rdb = make_shared<RdbStoreMock>();
3604 clouddiskrdbStore_->rdbStore_ = rdb;
3605 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3606 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3607 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3608 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
3609 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_RDB));
3610
3611 int32_t ret = clouddiskrdbStore_->GetDirtyType(cloudId, dirtyType);
3612 EXPECT_EQ(ret, E_RDB);
3613 }
3614
3615 /**
3616 * @tc.name: GetDirtyType
3617 * @tc.desc: Verify the CloudDiskRdbStore::GetDirtyType function
3618 * @tc.type: FUNC
3619 */
3620 HWTEST_F(CloudDiskRdbStoreTest, GetDirtyTypeTest4, TestSize.Level1)
3621 {
3622 int32_t dirtyType = 1;
3623 std::string cloudId = "100";
3624 bool preCount = true;
3625 auto rdb = make_shared<RdbStoreMock>();
3626 clouddiskrdbStore_->rdbStore_ = rdb;
3627 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3628 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3629 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3630 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
3631 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
3632
3633 int32_t ret = clouddiskrdbStore_->GetDirtyType(cloudId, dirtyType);
3634 EXPECT_EQ(ret, E_OK);
3635 }
3636
3637 /**
3638 * @tc.name: GetCurNode
3639 * @tc.desc: Verify the CloudDiskRdbStore::GetCurNode function
3640 * @tc.type: FUNC
3641 */
3642 HWTEST_F(CloudDiskRdbStoreTest, GetCurNodeTest1, TestSize.Level1)
3643 {
3644 CacheNode curNode;
3645 std::string cloudId = "";
3646 auto rdb = make_shared<RdbStoreMock>();
3647 clouddiskrdbStore_->rdbStore_ = rdb;
3648 int32_t ret = clouddiskrdbStore_->GetCurNode(cloudId, curNode);
3649 EXPECT_EQ(ret, E_INVAL_ARG);
3650 }
3651
3652 /**
3653 * @tc.name: GetCurNode
3654 * @tc.desc: Verify the CloudDiskRdbStore::GetCurNode function
3655 * @tc.type: FUNC
3656 */
3657 HWTEST_F(CloudDiskRdbStoreTest, GetCurNodeTest2, TestSize.Level1)
3658 {
3659 CacheNode curNode;
3660 std::string cloudId = "100";
3661 bool preCount = true;
3662 auto rdb = make_shared<RdbStoreMock>();
3663 clouddiskrdbStore_->rdbStore_ = rdb;
3664 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3665 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
3666
3667 int32_t ret = clouddiskrdbStore_->GetCurNode(cloudId, curNode);
3668 EXPECT_EQ(ret, E_RDB);
3669 }
3670
3671 /**
3672 * @tc.name: GetCurNode
3673 * @tc.desc: Verify the CloudDiskRdbStore::GetCurNode function
3674 * @tc.type: FUNC
3675 */
3676 HWTEST_F(CloudDiskRdbStoreTest, GetCurNodeTest3, TestSize.Level1)
3677 {
3678 CacheNode curNode;
3679 std::string cloudId = "100";
3680 bool preCount = true;
3681 auto rdb = make_shared<RdbStoreMock>();
3682 clouddiskrdbStore_->rdbStore_ = rdb;
3683 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3684 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3685 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3686 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
3687
3688 int32_t ret = clouddiskrdbStore_->GetCurNode(cloudId, curNode);
3689 EXPECT_EQ(ret, E_RDB);
3690 }
3691
3692 /**
3693 * @tc.name: GetCurNode
3694 * @tc.desc: Verify the CloudDiskRdbStore::GetCurNode function
3695 * @tc.type: FUNC
3696 */
3697 HWTEST_F(CloudDiskRdbStoreTest, GetCurNodeTest4, TestSize.Level1)
3698 {
3699 CacheNode curNode;
3700 std::string cloudId = "100";
3701 bool preCount = true;
3702 auto rdb = make_shared<RdbStoreMock>();
3703 clouddiskrdbStore_->rdbStore_ = rdb;
3704 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3705 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3706 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3707 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
3708 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_RDB));
3709
3710 int32_t ret = clouddiskrdbStore_->GetCurNode(cloudId, curNode);
3711 EXPECT_EQ(ret, E_RDB);
3712 }
3713
3714 /**
3715 * @tc.name: GetCurNode
3716 * @tc.desc: Verify the CloudDiskRdbStore::GetCurNode function
3717 * @tc.type: FUNC
3718 */
3719 HWTEST_F(CloudDiskRdbStoreTest, GetCurNodeTest5, TestSize.Level1)
3720 {
3721 CacheNode curNode;
3722 std::string cloudId = "100";
3723 bool preCount = true;
3724 auto rdb = make_shared<RdbStoreMock>();
3725 clouddiskrdbStore_->rdbStore_ = rdb;
3726 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3727 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3728 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3729 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
3730 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
3731
3732 int32_t ret = clouddiskrdbStore_->GetCurNode(cloudId, curNode);
3733 EXPECT_EQ(ret, E_OK);
3734 }
3735
3736 /**
3737 * @tc.name: GetParentNode
3738 * @tc.desc: Verify the CloudDiskRdbStore::GetParentNode function
3739 * @tc.type: FUNC
3740 */
3741 HWTEST_F(CloudDiskRdbStoreTest, GetParentNodeTest1, TestSize.Level1)
3742 {
3743 const std::string parentCloudId = "";
3744 std::string nextCloudId = "100";
3745 std::string fileName = "test";
3746 auto rdb = make_shared<RdbStoreMock>();
3747 clouddiskrdbStore_->rdbStore_ = rdb;
3748
3749 int32_t ret = clouddiskrdbStore_->GetParentNode(parentCloudId, nextCloudId, fileName);
3750 EXPECT_EQ(ret, E_INVAL_ARG);
3751 }
3752
3753 /**
3754 * @tc.name: GetParentNode
3755 * @tc.desc: Verify the CloudDiskRdbStore::GetParentNode function
3756 * @tc.type: FUNC
3757 */
3758 HWTEST_F(CloudDiskRdbStoreTest, GetParentNodeTest2, TestSize.Level1)
3759 {
3760 const std::string parentCloudId = "100";
3761 std::string nextCloudId = "100";
3762 std::string fileName = "test";
3763 bool preCount = true;
3764 auto rdb = make_shared<RdbStoreMock>();
3765 clouddiskrdbStore_->rdbStore_ = rdb;
3766 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3767 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
3768
3769 int32_t ret = clouddiskrdbStore_->GetParentNode(parentCloudId, nextCloudId, fileName);
3770 EXPECT_EQ(ret, E_RDB);
3771 }
3772
3773 /**
3774 * @tc.name: GetParentNode
3775 * @tc.desc: Verify the CloudDiskRdbStore::GetParentNode function
3776 * @tc.type: FUNC
3777 */
3778 HWTEST_F(CloudDiskRdbStoreTest, GetParentNodeTest3, TestSize.Level1)
3779 {
3780 const std::string parentCloudId = "100";
3781 std::string nextCloudId = "100";
3782 std::string fileName = "test";
3783 bool preCount = true;
3784 auto rdb = make_shared<RdbStoreMock>();
3785 clouddiskrdbStore_->rdbStore_ = rdb;
3786 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3787 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3788 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3789 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
3790
3791 int32_t ret = clouddiskrdbStore_->GetParentNode(parentCloudId, nextCloudId, fileName);
3792 EXPECT_EQ(ret, E_RDB);
3793 }
3794
3795 /**
3796 * @tc.name: GetParentNode
3797 * @tc.desc: Verify the CloudDiskRdbStore::GetParentNode function
3798 * @tc.type: FUNC
3799 */
3800 HWTEST_F(CloudDiskRdbStoreTest, GetParentNodeTest4, TestSize.Level1)
3801 {
3802 const std::string parentCloudId = "100";
3803 std::string nextCloudId = "100";
3804 std::string fileName = "test";
3805 bool preCount = true;
3806 auto rdb = make_shared<RdbStoreMock>();
3807 clouddiskrdbStore_->rdbStore_ = rdb;
3808 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3809 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3810 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3811 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
3812 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_RDB));
3813
3814 int32_t ret = clouddiskrdbStore_->GetParentNode(parentCloudId, nextCloudId, fileName);
3815 EXPECT_EQ(ret, E_RDB);
3816 }
3817
3818 /**
3819 * @tc.name: GetParentNode
3820 * @tc.desc: Verify the CloudDiskRdbStore::GetParentNode function
3821 * @tc.type: FUNC
3822 */
3823 HWTEST_F(CloudDiskRdbStoreTest, GetParentNodeTest5, TestSize.Level1)
3824 {
3825 const std::string parentCloudId = "100";
3826 std::string nextCloudId = "100";
3827 std::string fileName = "test";
3828 bool preCount = true;
3829 auto rdb = make_shared<RdbStoreMock>();
3830 clouddiskrdbStore_->rdbStore_ = rdb;
3831 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3832 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3833 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3834 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
3835 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
3836
3837 int32_t ret = clouddiskrdbStore_->GetParentNode(parentCloudId, nextCloudId, fileName);
3838 EXPECT_EQ(ret, E_OK);
3839 }
3840
3841 /**
3842 * @tc.name: GetUriFromDB
3843 * @tc.desc: Verify the CloudDiskRdbStore::GetUriFromDB function
3844 * @tc.type: FUNC
3845 */
3846 HWTEST_F(CloudDiskRdbStoreTest, GetUriFromDBTest1, TestSize.Level1)
3847 {
3848 const std::string parentCloudId = "";
3849 std::string uri = "100";
3850 auto rdb = make_shared<RdbStoreMock>();
3851 clouddiskrdbStore_->rdbStore_ = rdb;
3852
3853 int32_t ret = clouddiskrdbStore_->GetUriFromDB(parentCloudId, uri);
3854 EXPECT_EQ(ret, E_OK);
3855 }
3856
3857 /**
3858 * @tc.name: GetUriFromDB
3859 * @tc.desc: Verify the CloudDiskRdbStore::GetUriFromDB function
3860 * @tc.type: FUNC
3861 */
3862 HWTEST_F(CloudDiskRdbStoreTest, GetUriFromDBTest2, TestSize.Level1)
3863 {
3864 const std::string parentCloudId = "rootId";
3865 std::string uri = "100";
3866 auto rdb = make_shared<RdbStoreMock>();
3867 clouddiskrdbStore_->rdbStore_ = rdb;
3868
3869 int32_t ret = clouddiskrdbStore_->GetUriFromDB(parentCloudId, uri);
3870 EXPECT_EQ(ret, E_OK);
3871 }
3872
3873 /**
3874 * @tc.name: GetUriFromDB
3875 * @tc.desc: Verify the CloudDiskRdbStore::GetUriFromDB function
3876 * @tc.type: FUNC
3877 */
3878 HWTEST_F(CloudDiskRdbStoreTest, GetUriFromDBTest3, TestSize.Level1)
3879 {
3880 const std::string parentCloudId = "100";
3881 std::string uri = "100";
3882 bool preCount = true;
3883 auto rdb = make_shared<RdbStoreMock>();
3884 clouddiskrdbStore_->rdbStore_ = rdb;
3885 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3886 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
3887
3888 int32_t ret = clouddiskrdbStore_->GetUriFromDB(parentCloudId, uri);
3889 EXPECT_EQ(ret, E_RDB);
3890 }
3891
3892 /**
3893 * @tc.name: GetUriFromDB
3894 * @tc.desc: Verify the CloudDiskRdbStore::GetUriFromDB function
3895 * @tc.type: FUNC
3896 */
3897 HWTEST_F(CloudDiskRdbStoreTest, GetUriFromDBTest4, TestSize.Level1)
3898 {
3899 const std::string parentCloudId = "100";
3900 std::string nextCloudId = "cloudid";
3901 std::string uri = "100";
3902 bool preCount = true;
3903 auto rdb = make_shared<RdbStoreMock>();
3904 clouddiskrdbStore_->rdbStore_ = rdb;
3905 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3906 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3907 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3908 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(E_OK)).WillRepeatedly(Return(E_RDB));
3909 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
3910
3911 int32_t ret = clouddiskrdbStore_->GetUriFromDB(parentCloudId, uri);
3912 EXPECT_EQ(ret, E_OK);
3913 }
3914
3915 /**
3916 * @tc.name: GetUriFromDB
3917 * @tc.desc: Verify the CloudDiskRdbStore::GetUriFromDB function
3918 * @tc.type: FUNC
3919 */
3920 HWTEST_F(CloudDiskRdbStoreTest, GetUriFromDBTest5, TestSize.Level1)
3921 {
3922 const std::string parentCloudId = "100";
3923 std::string nextCloudId = "cloudid";
3924 std::string uri = "100";
3925 bool preCount = true;
3926 auto rdb = make_shared<RdbStoreMock>();
3927 clouddiskrdbStore_->rdbStore_ = rdb;
3928 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
3929 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
3930 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
3931 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
3932 EXPECT_CALL(*rset, GetRow(_)).WillRepeatedly(Return(E_OK));
3933
3934 int32_t ret = clouddiskrdbStore_->GetUriFromDB(parentCloudId, uri);
3935 EXPECT_EQ(ret, E_OK);
3936 }
3937
3938 /**
3939 * @tc.name: GetNotifyUri
3940 * @tc.desc: Verify the CloudDiskRdbStore::GetNotifyUri function
3941 * @tc.type: FUNC
3942 */
3943 HWTEST_F(CloudDiskRdbStoreTest, GetNotifyUriTest1, TestSize.Level1)
3944 {
3945 CacheNode cacheNode;
3946 std::string uri = "100";
3947 auto rdb = make_shared<RdbStoreMock>();
3948 clouddiskrdbStore_->rdbStore_ = rdb;
3949 clouddiskrdbStore_->rootId_ = "";
3950 int32_t ret = clouddiskrdbStore_->GetNotifyUri(cacheNode, uri);
3951 EXPECT_EQ(ret, E_INVAL_ARG);
3952 }
3953
3954 /**
3955 * @tc.name: GetNotifyUri
3956 * @tc.desc: Verify the CloudDiskRdbStore::GetNotifyUri function
3957 * @tc.type: FUNC
3958 */
3959 HWTEST_F(CloudDiskRdbStoreTest, GetNotifyUriTest2, TestSize.Level1)
3960 {
3961 CacheNode cacheNode;
3962 std::string uri = "test";
3963 auto rdb = make_shared<RdbStoreMock>();
3964 clouddiskrdbStore_->rdbStore_ = rdb;
3965 clouddiskrdbStore_->rootId_ = "rootId";
3966 int32_t ret = clouddiskrdbStore_->GetNotifyUri(cacheNode, uri);
3967 EXPECT_EQ(ret, E_OK);
3968 }
3969
3970 /**
3971 * @tc.name: GetNotifyUri
3972 * @tc.desc: Verify the CloudDiskRdbStore::GetNotifyUri function
3973 * @tc.type: FUNC
3974 */
3975 HWTEST_F(CloudDiskRdbStoreTest, GetNotifyUriTest3, TestSize.Level1)
3976 {
3977 CacheNode cacheNode;
3978 std::string uri = "mock";
3979 auto rdb = make_shared<RdbStoreMock>();
3980 clouddiskrdbStore_->rdbStore_ = rdb;
3981 clouddiskrdbStore_->rootId_ = "rootId";
3982 int32_t ret = clouddiskrdbStore_->GetNotifyUri(cacheNode, uri);
3983 EXPECT_EQ(ret, E_OK);
3984 }
3985
3986 /**
3987 * @tc.name: GetNotifyUri
3988 * @tc.desc: Verify the CloudDiskRdbStore::GetNotifyUri function
3989 * @tc.type: FUNC
3990 */
3991 HWTEST_F(CloudDiskRdbStoreTest, GetNotifyUriTest4, TestSize.Level1)
3992 {
3993 CacheNode cacheNode;
3994 cacheNode.parentCloudId = "root";
3995 std::string uri = "mock";
3996 bool preCount = true;
3997 auto rdb = make_shared<RdbStoreMock>();
3998 clouddiskrdbStore_->rdbStore_ = rdb;
3999 clouddiskrdbStore_->rootId_ = "rootId";
4000 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
4001 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
4002
4003 int32_t ret = clouddiskrdbStore_->GetNotifyUri(cacheNode, uri);
4004 EXPECT_EQ(ret, E_RDB);
4005 }
4006
4007 /**
4008 * @tc.name: GetNotifyData
4009 * @tc.desc: Verify the CloudDiskRdbStore::GetNotifyData function
4010 * @tc.type: FUNC
4011 */
4012 HWTEST_F(CloudDiskRdbStoreTest, GetNotifyDataTest1, TestSize.Level1)
4013 {
4014 CacheNode cacheNode;
4015 NotifyData notifyData;
4016 notifyData.uri = "mock";
4017 auto rdb = make_shared<RdbStoreMock>();
4018 clouddiskrdbStore_->rdbStore_ = rdb;
4019 clouddiskrdbStore_->rootId_ = "";
4020
4021 int32_t ret = clouddiskrdbStore_->GetNotifyData(cacheNode, notifyData);
4022 EXPECT_EQ(ret, E_INVAL_ARG);
4023 }
4024
4025 /**
4026 * @tc.name: GetNotifyData
4027 * @tc.desc: Verify the CloudDiskRdbStore::GetNotifyData function
4028 * @tc.type: FUNC
4029 */
4030 HWTEST_F(CloudDiskRdbStoreTest, GetNotifyDataTest2, TestSize.Level1)
4031 {
4032 CacheNode cacheNode;
4033 NotifyData notifyData;
4034 notifyData.uri = "mock";
4035 auto rdb = make_shared<RdbStoreMock>();
4036 clouddiskrdbStore_->rdbStore_ = rdb;
4037 clouddiskrdbStore_->rootId_ = "rootId";
4038
4039 int32_t ret = clouddiskrdbStore_->GetNotifyData(cacheNode, notifyData);
4040 EXPECT_EQ(ret, E_OK);
4041 }
4042
4043 /**
4044 * @tc.name: CheckRootIdValid
4045 * @tc.desc: Verify the CloudDiskRdbStore::CheckRootIdValid function
4046 * @tc.type: FUNC
4047 */
4048 HWTEST_F(CloudDiskRdbStoreTest, CheckRootIdValidTest1, TestSize.Level1)
4049 {
4050 auto rdb = make_shared<RdbStoreMock>();
4051 clouddiskrdbStore_->rdbStore_ = rdb;
4052 clouddiskrdbStore_->rootId_ = "rootId";
4053
4054 int32_t ret = clouddiskrdbStore_->CheckRootIdValid();
4055 EXPECT_EQ(ret, E_OK);
4056 }
4057
4058 /**
4059 * @tc.name: CheckRootIdValid
4060 * @tc.desc: Verify the CloudDiskDataCallBack::CheckRootIdValid function
4061 * @tc.type: FUNC
4062 */
4063 HWTEST_F(CloudDiskRdbStoreTest, CheckRootIdValidTest2, TestSize.Level1)
4064 {
4065 auto rdb = make_shared<RdbStoreMock>();
4066 clouddiskrdbStore_->rdbStore_ = rdb;
4067 clouddiskrdbStore_->rootId_ = "";
4068
4069 int32_t ret = clouddiskrdbStore_->CheckRootIdValid();
4070 EXPECT_EQ(ret, E_INVAL_ARG);
4071 }
4072
4073 /**
4074 * @tc.name: OnCreate
4075 * @tc.desc: Verify the CloudDiskDataCallBack::OnCreate function
4076 * @tc.type: FUNC
4077 */
4078 HWTEST_F(CloudDiskRdbStoreTest, OnCreateTest1, TestSize.Level1)
4079 {
4080 RdbStoreMock store;
4081 RdbStoreMock* rdb = &store;
4082 CloudDiskDataCallBack CloudDiskDataCallBack;
4083 EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_RDB));
4084
4085 int32_t ret = CloudDiskDataCallBack.OnCreate(store);
4086 EXPECT_EQ(ret, NativeRdb::E_ERROR);
4087 }
4088
4089 /**
4090 * @tc.name: OnCreate
4091 * @tc.desc: Verify the CloudDiskDataCallBack::OnCreate function
4092 * @tc.type: FUNC
4093 */
4094 HWTEST_F(CloudDiskRdbStoreTest, OnCreateTest2, TestSize.Level1)
4095 {
4096 RdbStoreMock store;
4097 RdbStoreMock* rdb = &store;
4098 CloudDiskDataCallBack CloudDiskDataCallBack;
4099 EXPECT_CALL(*rdb, ExecuteSql(_, _)).WillRepeatedly(Return(E_OK));
4100
4101 int32_t ret = CloudDiskDataCallBack.OnCreate(store);
4102 EXPECT_EQ(ret, E_OK);
4103 }
4104
4105 /**
4106 * @tc.name: OnUpgrade
4107 * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
4108 * @tc.type: FUNC
4109 */
4110 HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest1, TestSize.Level1)
4111 {
4112 RdbStoreMock store;
4113 int32_t oldVersion = 13;
4114 int32_t newVersion = 14;
4115 CloudDiskDataCallBack CloudDiskDataCallBack;
4116 int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
4117 EXPECT_EQ(ret, E_OK);
4118 }
4119
4120 /**
4121 * @tc.name: OnUpgrade
4122 * @tc.desc: Verify the CloudDiskDataCallBack::OnUpgrade function
4123 * @tc.type: FUNC
4124 */
4125 HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeTest2, TestSize.Level1)
4126 {
4127 RdbStoreMock store;
4128 int32_t oldVersion = 8;
4129 int32_t newVersion = 14;
4130 CloudDiskDataCallBack CloudDiskDataCallBack;
4131 int32_t ret = CloudDiskDataCallBack.OnUpgrade(store, oldVersion, newVersion);
4132 EXPECT_EQ(ret, E_OK);
4133 }
4134
4135 /**
4136 * @tc.name: CreateDentryFile
4137 * @tc.desc: Verify the CloudDiskRdbStore::CreateDentryFile function
4138 * @tc.type: FUNC
4139 */
4140 HWTEST_F(CloudDiskRdbStoreTest, CreateDentryFileTest1, TestSize.Level1)
4141 {
4142 MetaBase metaBase;
4143 metaBase.name = "mock";
4144 std::string destParentCloudId = "";
4145 auto rdb = make_shared<RdbStoreMock>();
4146 clouddiskrdbStore_->rdbStore_ = rdb;
4147
4148 int32_t ret = clouddiskrdbStore_->CreateDentryFile(metaBase, destParentCloudId);
4149 EXPECT_EQ(ret, E_RDB);
4150 }
4151
4152 /**
4153 * @tc.name: CreateDentryFile
4154 * @tc.desc: Verify the CloudDiskRdbStore::CreateDentryFile function
4155 * @tc.type: FUNC
4156 */
4157 HWTEST_F(CloudDiskRdbStoreTest, CreateDentryFileTest2, TestSize.Level1)
4158 {
4159 MetaBase metaBase;
4160 std::string destParentCloudId = "";
4161 auto rdb = make_shared<RdbStoreMock>();
4162 clouddiskrdbStore_->rdbStore_ = rdb;
4163
4164 int32_t ret = clouddiskrdbStore_->CreateDentryFile(metaBase, destParentCloudId);
4165 EXPECT_EQ(ret, E_OK);
4166 }
4167
4168 /**
4169 * @tc.name: InsertCopyData
4170 * @tc.desc: Verify the CloudDiskRdbStore::InsertCopyData function
4171 * @tc.type: FUNC
4172 */
4173 HWTEST_F(CloudDiskRdbStoreTest, InsertCopyDataTest1, TestSize.Level1)
4174 {
4175 std::string srcCloudId = "";
4176 std::string destCloudId = "";
4177 std::string destParentCloudId = "";
4178 auto rdb = make_shared<RdbStoreMock>();
4179 auto transaction = make_shared<TransactionMock>();
4180 clouddiskrdbStore_->rdbStore_ = rdb;
4181 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4182 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
4183 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
4184 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
4185 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
4186 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
4187 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
4188
4189 int32_t ret = clouddiskrdbStore_->InsertCopyData(srcCloudId, destCloudId, destParentCloudId, rset);
4190 EXPECT_EQ(ret, E_RDB);
4191 }
4192
4193 /**
4194 * @tc.name: InsertCopyData
4195 * @tc.desc: Verify the CloudDiskRdbStore::InsertCopyData function
4196 * @tc.type: FUNC
4197 */
4198 HWTEST_F(CloudDiskRdbStoreTest, InsertCopyDataTest2, TestSize.Level1)
4199 {
4200 std::string srcCloudId = "";
4201 std::string destCloudId = "";
4202 std::string destParentCloudId = "";
4203 auto rdb = make_shared<RdbStoreMock>();
4204 auto transaction = make_shared<TransactionMock>();
4205 clouddiskrdbStore_->rdbStore_ = rdb;
4206 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4207 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
4208 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
4209 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
4210 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>("mock"), Return(E_OK)));
4211
4212 int32_t ret = clouddiskrdbStore_->InsertCopyData(srcCloudId, destCloudId, destParentCloudId, rset);
4213 EXPECT_EQ(ret, E_RDB);
4214 }
4215
4216 /**
4217 * @tc.name: InsertCopyData
4218 * @tc.desc: Verify the CloudDiskRdbStore::InsertCopyData function
4219 * @tc.type: FUNC
4220 */
4221 HWTEST_F(CloudDiskRdbStoreTest, InsertCopyDataTest3, TestSize.Level1)
4222 {
4223 std::string srcCloudId = "";
4224 std::string destCloudId = "";
4225 std::string destParentCloudId = "";
4226 auto rdb = make_shared<RdbStoreMock>();
4227 auto transaction = make_shared<TransactionMock>();
4228 clouddiskrdbStore_->rdbStore_ = rdb;
4229 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4230 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
4231 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
4232 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
4233 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
4234 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
4235 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
4236
4237 int32_t ret = clouddiskrdbStore_->InsertCopyData(srcCloudId, destCloudId, destParentCloudId, rset);
4238 EXPECT_EQ(ret, E_OK);
4239 }
4240
4241 /**
4242 * @tc.name: CopyFile
4243 * @tc.desc: Verify the CloudDiskRdbStore::CopyFile function
4244 * @tc.type: FUNC
4245 */
4246 HWTEST_F(CloudDiskRdbStoreTest, CopyFileTest1, TestSize.Level1)
4247 {
4248 std::string srcCloudId = "";
4249 std::string destCloudId = "";
4250 std::string bundleName = "com.ohos.photos";
4251 const int userId = 100;
4252 std::string destPath = "";
4253 bool preCount = true;
4254 auto rdb = make_shared<RdbStoreMock>();
4255 clouddiskrdbStore_->rdbStore_ = rdb;
4256 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4257 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
4258 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(nullptr)));
4259
4260 int32_t ret = clouddiskrdbStore_->CopyFile(srcCloudId, destCloudId,
4261 bundleName, userId, destPath);
4262 EXPECT_EQ(ret, E_RDB);
4263 }
4264
4265 /**
4266 * @tc.name: CopyFile
4267 * @tc.desc: Verify the CloudDiskRdbStore::CopyFile function
4268 * @tc.type: FUNC
4269 */
4270 HWTEST_F(CloudDiskRdbStoreTest, CopyFileTest2, TestSize.Level1)
4271 {
4272 std::string srcCloudId = "";
4273 std::string destCloudId = "";
4274 std::string bundleName = "com.ohos.photos";
4275 const int userId = 100;
4276 std::string destPath = "";
4277 bool preCount = true;
4278 auto rdb = make_shared<RdbStoreMock>();
4279 clouddiskrdbStore_->rdbStore_ = rdb;
4280 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4281 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
4282 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
4283 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
4284
4285 int32_t ret = clouddiskrdbStore_->CopyFile(srcCloudId, destCloudId,
4286 bundleName, userId, destPath);
4287 EXPECT_EQ(ret, E_RDB);
4288 }
4289
4290 /**
4291 * @tc.name: CopyFile
4292 * @tc.desc: Verify the CloudDiskRdbStore::CopyFile function
4293 * @tc.type: FUNC
4294 */
4295 HWTEST_F(CloudDiskRdbStoreTest, CopyFileTest3, TestSize.Level1)
4296 {
4297 std::string srcCloudId = "";
4298 std::string destCloudId = "";
4299 std::string bundleName = "com.ohos.photos";
4300 const int userId = 100;
4301 std::string destPath = "";
4302 bool preCount = true;
4303 auto rdb = make_shared<RdbStoreMock>();
4304 auto transaction = make_shared<TransactionMock>();
4305 clouddiskrdbStore_->rdbStore_ = rdb;
4306 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4307 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
4308 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
4309 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
4310 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
4311 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
4312 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
4313 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
4314 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
4315 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
4316
4317 int32_t ret = clouddiskrdbStore_->CopyFile(srcCloudId, destCloudId,
4318 bundleName, userId, destPath);
4319 EXPECT_EQ(ret, E_RDB);
4320 }
4321
4322 /**
4323 * @tc.name: CopyFile
4324 * @tc.desc: Verify the CloudDiskRdbStore::CopyFile function
4325 * @tc.type: FUNC
4326 */
4327 HWTEST_F(CloudDiskRdbStoreTest, CopyFileTest4, TestSize.Level1)
4328 {
4329 std::string srcCloudId = "";
4330 std::string destCloudId = "";
4331 std::string bundleName = "com.ohos.photos";
4332 const int userId = 100;
4333 std::string destPath = "";
4334 bool preCount = true;
4335 auto rdb = make_shared<RdbStoreMock>();
4336 auto transaction = make_shared<TransactionMock>();
4337 clouddiskrdbStore_->rdbStore_ = rdb;
4338 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4339 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(),
4340 An<const std::vector<std::string> &>(), preCount)).WillOnce(Return(ByMove(rset)));
4341 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
4342 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
4343 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
4344 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(E_OK));
4345 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(E_OK));
4346 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
4347 EXPECT_CALL(*transaction, Insert(_, _, _)).WillOnce(Return(std::make_pair(E_OK, 0)));
4348
4349 int32_t ret = clouddiskrdbStore_->CopyFile(srcCloudId, destCloudId,
4350 bundleName, userId, destPath);
4351 EXPECT_EQ(ret, E_OK);
4352 }
4353
4354 /**
4355 * @tc.name: OnUpgradeExtend
4356 * @tc.desc: Verify the CloudDiskRdbStore::OnUpgradeExtend function
4357 * @tc.type: FUNC
4358 * @tc.require: ICGORT
4359 */
4360 HWTEST_F(CloudDiskRdbStoreTest, OnUpgradeExtendTest001, TestSize.Level1)
4361 {
4362 GTEST_LOG_(INFO) << "OnUpgradeExtendTest001 start";
4363 try {
4364 RdbStoreMock store;
4365 int32_t oldVersion = 15;
4366 int32_t newVersion = 14;
4367 CloudDiskDataCallBack CloudDiskDataCallBack;
4368 int32_t ret = CloudDiskDataCallBack.OnUpgradeExtend(store, oldVersion, newVersion);
4369 EXPECT_EQ(ret, E_OK);
4370
4371 oldVersion = 16;
4372 ret = CloudDiskDataCallBack.OnUpgradeExtend(store, oldVersion, newVersion);
4373 EXPECT_EQ(ret, E_OK);
4374
4375 oldVersion = 17;
4376 ret = CloudDiskDataCallBack.OnUpgradeExtend(store, oldVersion, newVersion);
4377 EXPECT_EQ(ret, E_OK);
4378 } catch (...) {
4379 EXPECT_TRUE(false);
4380 GTEST_LOG_(INFO) << "OnUpgradeExtendTest001 failed";
4381 }
4382 GTEST_LOG_(INFO) << "OnUpgradeExtendTest001 end";
4383 }
4384
4385 /**
4386 * @tc.name: UpdateTHMStatus
4387 * @tc.desc: Verify the CloudDiskRdbStore::UpdateTHMStatus function
4388 * @tc.type: FUNC
4389 * @tc.require: ICPOAK
4390 */
4391 HWTEST_F(CloudDiskRdbStoreTest, UpdateTHMStatusTest001, TestSize.Level1)
4392 {
4393 GTEST_LOG_(INFO) << "UpdateTHMStatusTest001 start";
4394 try {
4395 shared_ptr<CloudDiskMetaFile> metaFile = make_shared<CloudDiskMetaFile>(100, "", "");
4396 MetaBase metaBase;
4397 metaBase.fileType == FILE_TYPE_THUMBNAIL;
4398 int32_t status = 0;
4399 bool preCount = true;
4400 auto rdb = make_shared<RdbStoreMock>();
4401 clouddiskrdbStore_->rdbStore_ = rdb;
4402 auto transaction = make_shared<TransactionMock>();
4403 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
4404 .WillOnce(Return(ByMove(nullptr)));
4405 int32_t ret = clouddiskrdbStore_->UpdateTHMStatus(metaFile, metaBase, status);
4406 EXPECT_EQ(ret, E_RDB);
4407 } catch (...) {
4408 EXPECT_TRUE(false);
4409 GTEST_LOG_(INFO) << "UpdateTHMStatusTest001 failed";
4410 }
4411 GTEST_LOG_(INFO) << "UpdateTHMStatusTest001 end";
4412 }
4413
4414 /**
4415 * @tc.name: UpdateTHMStatus
4416 * @tc.desc: Verify the CloudDiskRdbStore::UpdateTHMStatus function
4417 * @tc.type: FUNC
4418 * @tc.require: ICPOAK
4419 */
4420 HWTEST_F(CloudDiskRdbStoreTest, UpdateTHMStatusTest002, TestSize.Level1)
4421 {
4422 GTEST_LOG_(INFO) << "UpdateTHMStatusTest002 start";
4423 try {
4424 shared_ptr<CloudDiskMetaFile> metaFile = make_shared<CloudDiskMetaFile>(100, "", "");
4425 MetaBase metaBase;
4426 metaBase.fileType == FILE_TYPE_CONTENT;
4427 int32_t status = 0;
4428 bool preCount = true;
4429 auto rdb = make_shared<RdbStoreMock>();
4430 clouddiskrdbStore_->rdbStore_ = rdb;
4431 auto transaction = make_shared<TransactionMock>();
4432 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4433 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
4434 .WillOnce(Return(ByMove(rset)));
4435 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
4436 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
4437 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
4438 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(50, transaction)));
4439 int32_t ret = clouddiskrdbStore_->UpdateTHMStatus(metaFile, metaBase, status);
4440 EXPECT_EQ(ret, 50);
4441 } catch (...) {
4442 EXPECT_TRUE(false);
4443 GTEST_LOG_(INFO) << "UpdateTHMStatusTest002 failed";
4444 }
4445 GTEST_LOG_(INFO) << "UpdateTHMStatusTest002 end";
4446 }
4447
4448 /**
4449 * @tc.name: UpdateTHMStatus
4450 * @tc.desc: Verify the CloudDiskRdbStore::UpdateTHMStatus function
4451 * @tc.type: FUNC
4452 * @tc.require: ICPOAK
4453 */
4454 HWTEST_F(CloudDiskRdbStoreTest, UpdateTHMStatusTest003, TestSize.Level1)
4455 {
4456 GTEST_LOG_(INFO) << "UpdateTHMStatusTest003 start";
4457 try {
4458 shared_ptr<CloudDiskMetaFile> metaFile = make_shared<CloudDiskMetaFile>(100, "", "");
4459 MetaBase metaBase;
4460 metaBase.fileType == FILE_TYPE_CONTENT;
4461 int32_t status = 0;
4462 bool preCount = true;
4463 auto rdb = make_shared<RdbStoreMock>();
4464 clouddiskrdbStore_->rdbStore_ = rdb;
4465 auto transaction = make_shared<TransactionMock>();
4466 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4467 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
4468 .WillOnce(Return(ByMove(rset)));
4469 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
4470 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
4471 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
4472 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
4473 EXPECT_CALL(*transaction, Update(_, _, _)).WillOnce(Return(std::make_pair(E_RDB, 0)));
4474 int32_t ret = clouddiskrdbStore_->UpdateTHMStatus(metaFile, metaBase, status);
4475 EXPECT_EQ(ret, E_RDB);
4476 } catch (...) {
4477 EXPECT_TRUE(false);
4478 GTEST_LOG_(INFO) << "UpdateTHMStatusTest003 failed";
4479 }
4480 GTEST_LOG_(INFO) << "UpdateTHMStatusTest003 end";
4481 }
4482
4483 /**
4484 * @tc.name: UpdateTHMStatus
4485 * @tc.desc: Verify the CloudDiskRdbStore::UpdateTHMStatus function
4486 * @tc.type: FUNC
4487 * @tc.require: ICPOAK
4488 */
4489 HWTEST_F(CloudDiskRdbStoreTest, UpdateTHMStatusTest004, TestSize.Level1)
4490 {
4491 GTEST_LOG_(INFO) << "UpdateTHMStatusTest004 start";
4492 try {
4493 shared_ptr<CloudDiskMetaFile> metaFile = make_shared<CloudDiskMetaFile>(100, "", "");
4494 MetaBase metaBase;
4495 metaBase.fileType == FILE_TYPE_CONTENT;
4496 int32_t status = 0;
4497 bool preCount = true;
4498 auto rdb = make_shared<RdbStoreMock>();
4499 clouddiskrdbStore_->rdbStore_ = rdb;
4500 auto transaction = make_shared<TransactionMock>();
4501 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4502 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
4503 .WillOnce(Return(ByMove(rset)));
4504 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
4505 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
4506 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
4507 EXPECT_CALL(*rdb, CreateTransaction(_)).WillOnce(Return(std::make_pair(E_OK, transaction)));
4508 EXPECT_CALL(*transaction, Update(_, _, _)).WillRepeatedly(Return(std::make_pair(E_OK, 0)));
4509 int32_t ret = clouddiskrdbStore_->UpdateTHMStatus(metaFile, metaBase, status);
4510 EXPECT_EQ(ret, E_OK);
4511 } catch (...) {
4512 EXPECT_TRUE(false);
4513 GTEST_LOG_(INFO) << "UpdateTHMStatusTest004 failed";
4514 }
4515 GTEST_LOG_(INFO) << "UpdateTHMStatusTest004 end";
4516 }
4517
4518 /**
4519 * @tc.name: GetSrcCloudId
4520 * @tc.desc: Verify the CloudDiskRdbStore::GetSrcCloudId function
4521 * @tc.type: FUNC
4522 * @tc.require: ICPOAK
4523 */
4524 HWTEST_F(CloudDiskRdbStoreTest, GetSrcCloudIdTest001, TestSize.Level1)
4525 {
4526 GTEST_LOG_(INFO) << "GetSrcCloudIdTest001 start";
4527 try {
4528 std::string cloudId = "";
4529 std::string srcCloudId = "";
4530 bool preCount = true;
4531 auto rdb = make_shared<RdbStoreMock>();
4532 clouddiskrdbStore_->rdbStore_ = rdb;
4533 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
4534 .WillOnce(Return(ByMove(nullptr)));
4535 int32_t ret = clouddiskrdbStore_->GetSrcCloudId(cloudId, srcCloudId);
4536 EXPECT_EQ(ret, E_RDB);
4537 } catch (...) {
4538 EXPECT_TRUE(false);
4539 GTEST_LOG_(INFO) << "GetSrcCloudIdTest001 failed";
4540 }
4541 GTEST_LOG_(INFO) << "GetSrcCloudIdTest001 end";
4542 }
4543
4544 /**
4545 * @tc.name: GetSrcCloudId
4546 * @tc.desc: Verify the CloudDiskRdbStore::GetSrcCloudId function
4547 * @tc.type: FUNC
4548 * @tc.require: ICPOAK
4549 */
4550 HWTEST_F(CloudDiskRdbStoreTest, GetSrcCloudIdTest002, TestSize.Level1)
4551 {
4552 GTEST_LOG_(INFO) << "GetSrcCloudIdTest002 start";
4553 try {
4554 std::string cloudId = "";
4555 std::string srcCloudId = "";
4556 bool preCount = true;
4557 auto rdb = make_shared<RdbStoreMock>();
4558 clouddiskrdbStore_->rdbStore_ = rdb;
4559 auto transaction = make_shared<TransactionMock>();
4560 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4561 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
4562 .WillOnce(Return(ByMove(rset)));
4563 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_RDB));
4564 int32_t ret = clouddiskrdbStore_->GetSrcCloudId(cloudId, srcCloudId);
4565 EXPECT_EQ(ret, E_RDB);
4566 } catch (...) {
4567 EXPECT_TRUE(false);
4568 GTEST_LOG_(INFO) << "GetSrcCloudIdTest002 failed";
4569 }
4570 GTEST_LOG_(INFO) << "GetSrcCloudIdTest002 end";
4571 }
4572
4573 /**
4574 * @tc.name: GetSrcCloudId
4575 * @tc.desc: Verify the CloudDiskRdbStore::GetSrcCloudId function
4576 * @tc.type: FUNC
4577 * @tc.require: ICPOAK
4578 */
4579 HWTEST_F(CloudDiskRdbStoreTest, GetSrcCloudIdTest003, TestSize.Level1)
4580 {
4581 GTEST_LOG_(INFO) << "GetSrcCloudIdTest003 start";
4582 try {
4583 std::string cloudId = "";
4584 std::string srcCloudId = "";
4585 bool preCount = true;
4586 auto rdb = make_shared<RdbStoreMock>();
4587 clouddiskrdbStore_->rdbStore_ = rdb;
4588 auto transaction = make_shared<TransactionMock>();
4589 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4590 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
4591 .WillOnce(Return(ByMove(rset)));
4592 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
4593 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_RDB));
4594 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
4595 int32_t ret = clouddiskrdbStore_->GetSrcCloudId(cloudId, srcCloudId);
4596 EXPECT_EQ(ret, E_RDB);
4597 } catch (...) {
4598 EXPECT_TRUE(false);
4599 GTEST_LOG_(INFO) << "GetSrcCloudIdTest003 failed";
4600 }
4601 GTEST_LOG_(INFO) << "GetSrcCloudIdTest003 end";
4602 }
4603
4604 /**
4605 * @tc.name: GetSrcCloudId
4606 * @tc.desc: Verify the CloudDiskRdbStore::GetSrcCloudId function
4607 * @tc.type: FUNC
4608 * @tc.require: ICPOAK
4609 */
4610 HWTEST_F(CloudDiskRdbStoreTest, GetSrcCloudIdTest004, TestSize.Level1)
4611 {
4612 GTEST_LOG_(INFO) << "GetSrcCloudIdTest004 start";
4613 try {
4614 std::string cloudId = "";
4615 std::string srcCloudId = "";
4616 bool preCount = true;
4617 auto rdb = make_shared<RdbStoreMock>();
4618 clouddiskrdbStore_->rdbStore_ = rdb;
4619 auto transaction = make_shared<TransactionMock>();
4620 std::shared_ptr<ResultSetMock> rset = std::make_shared<ResultSetMock>();
4621 EXPECT_CALL(*rdb, QueryByStep(An<const AbsRdbPredicates &>(), An<const std::vector<std::string> &>(), preCount))
4622 .WillOnce(Return(ByMove(rset)));
4623 EXPECT_CALL(*rset, GoToNextRow()).WillRepeatedly(Return(E_OK));
4624 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(E_OK));
4625 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(E_OK));
4626 int32_t ret = clouddiskrdbStore_->GetSrcCloudId(cloudId, srcCloudId);
4627 EXPECT_EQ(ret, E_OK);
4628 } catch (...) {
4629 EXPECT_TRUE(false);
4630 GTEST_LOG_(INFO) << "GetSrcCloudIdTest004 failed";
4631 }
4632 GTEST_LOG_(INFO) << "GetSrcCloudIdTest004 end";
4633 }
4634
4635 /**
4636 * @tc.name: TriggerSyncForWrite
4637 * @tc.desc: Verify the CloudDiskRdbStore::TriggerSyncForWrite function
4638 * @tc.type: FUNC
4639 * @tc.require: ICGORT
4640 */
4641 HWTEST_F(CloudDiskRdbStoreTest, TriggerSyncForWriteTest001, TestSize.Level1)
4642 {
4643 GTEST_LOG_(INFO) << "TriggerSyncForWriteTest001 start";
4644 try {
4645 auto rdb = make_shared<RdbStoreMock>();
4646 const std::string fileName = "Test";
4647 const std::string parentCloudId = "100";
4648 clouddiskrdbStore_->rdbStore_ = rdb;
4649 clouddiskrdbStore_->TriggerSyncForWrite(fileName, parentCloudId);
4650 EXPECT_EQ(fileName, "Test");
4651 } catch (...) {
4652 EXPECT_TRUE(false);
4653 GTEST_LOG_(INFO) << "TriggerSyncForWriteTest001 failed";
4654 }
4655 GTEST_LOG_(INFO) << "TriggerSyncForWriteTest001 end";
4656 }
4657
4658 /**
4659 * @tc.name: TriggerSyncForWrite
4660 * @tc.desc: Verify the CloudDiskRdbStore::TriggerSyncForWrite function
4661 * @tc.type: FUNC
4662 * @tc.require: ICGORT
4663 */
4664 HWTEST_F(CloudDiskRdbStoreTest, TriggerSyncForWriteTest002, TestSize.Level1)
4665 {
4666 GTEST_LOG_(INFO) << "TriggerSyncForWriteTest002 start";
4667 try {
4668 auto rdb = make_shared<RdbStoreMock>();
4669 const std::string fileName = "mock";
4670 const std::string parentCloudId = "100";
4671 clouddiskrdbStore_->rdbStore_ = rdb;
4672 clouddiskrdbStore_->TriggerSyncForWrite(fileName, parentCloudId);
4673 EXPECT_EQ(fileName, "mock");
4674 } catch (...) {
4675 EXPECT_TRUE(false);
4676 GTEST_LOG_(INFO) << "TriggerSyncForWriteTest002 failed";
4677 }
4678 GTEST_LOG_(INFO) << "TriggerSyncForWriteTest002 end";
4679 }
4680 } // namespace OHOS::FileManagement::CloudDisk::Test