1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include <memory>
19
20 #include "cloud_disk_data_convertor.h"
21 #include "cloud_disk_data_handler.h"
22 #include "clouddisk_rdbstore.h"
23 #include "result_set_mock.h"
24
25 namespace OHOS::FileManagement::CloudSync::Test {
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace std;
29 const int32_t USER_ID = 100;
30
31 class CloudDiskDataConvertorTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase(void)39 void CloudDiskDataConvertorTest::SetUpTestCase(void)
40 {
41 GTEST_LOG_(INFO) << "SetUpTestCase";
42 }
43
TearDownTestCase(void)44 void CloudDiskDataConvertorTest::TearDownTestCase(void)
45 {
46 GTEST_LOG_(INFO) << "TearDownTestCase";
47 }
48
SetUp(void)49 void CloudDiskDataConvertorTest::SetUp(void)
50 {
51 GTEST_LOG_(INFO) << "SetUp";
52 }
53
TearDown(void)54 void CloudDiskDataConvertorTest::TearDown(void)
55 {
56 GTEST_LOG_(INFO) << "TearDown";
57 }
58
59 /**
60 * @tc.name: Convert001
61 * @tc.desc: Verify the Convert function
62 * @tc.type: FUNC
63 * @tc.require: I6JPKG
64 */
65 HWTEST_F(CloudDiskDataConvertorTest, Convert001, TestSize.Level1)
66 {
67 GTEST_LOG_(INFO) << "Convert001 Begin";
68 try {
69 string bundName = "com.ohos.photos";
70 DriveKit::DKRecord record;
71 record.SetDelete(true);
72 DriveKit::DKRecordData data;
73 record.GetRecordData(data);
74 NativeRdb::ValuesBucket values;
75 shared_ptr<CloudDiskDataConvertor> localConvertor =
76 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
77 localConvertor->SetRootId(bundName);
78 int res = localConvertor->Convert(record, values);
79 EXPECT_EQ(res, E_OK);
80 } catch (...) {
81 EXPECT_TRUE(false);
82 GTEST_LOG_(INFO) << "Convert001 ERROR";
83 }
84
85 GTEST_LOG_(INFO) << "Convert001 End";
86 }
87
88 /**
89 * @tc.name: HandleErr001
90 * @tc.desc: Verify the HandleErr function
91 * @tc.type: FUNC
92 * @tc.require: I6JPKG
93 */
94 HWTEST_F(CloudDiskDataConvertorTest, HandleErr001, TestSize.Level1)
95 {
96 GTEST_LOG_(INFO) << "HandleErr001 Begin";
97 try {
98 string bundName = "com.ohos.photos";
99 CloudDisk::CloudDiskRdbStore cloudDiskRdbStore(bundName, USER_ID);
100 auto rdb = cloudDiskRdbStore.GetRaw();
101 ASSERT_TRUE(rdb);
102 auto stopFlag = make_shared<bool>(false);
103 shared_ptr<CloudDiskDataHandler> cloudDiskHandler =
104 make_shared<CloudDiskDataHandler>(USER_ID, bundName, rdb, stopFlag);
105 shared_ptr<CloudDiskDataConvertor> createConvertor = make_shared<CloudDiskDataConvertor>(
106 USER_ID, bundName, FILE_CREATE,
107 std::bind(&CloudDiskDataHandler::HandleCreateConvertErr, cloudDiskHandler, std::placeholders::_1,
108 std::placeholders::_2));
109 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
110 int32_t err = E_RDB;
111 createConvertor->HandleErr(err, *resultSet);
112 EXPECT_EQ(cloudDiskHandler->modifyFailSet_.size(), 0);
113 } catch (...) {
114 EXPECT_TRUE(false);
115 GTEST_LOG_(INFO) << "HandleErr001 ERROR";
116 }
117 GTEST_LOG_(INFO) << "HandleErr001 End";
118 }
119
120 /**
121 * @tc.name: HandleErr002
122 * @tc.desc: Verify the HandleErr function
123 * @tc.type: FUNC
124 * @tc.require: I6JPKG
125 */
126 HWTEST_F(CloudDiskDataConvertorTest, HandleErr002, TestSize.Level1)
127 {
128 GTEST_LOG_(INFO) << "HandleErr002 Begin";
129 try {
130 string bundName = "com.ohos.photos";
131 CloudDisk::CloudDiskRdbStore cloudDiskRdbStore(bundName, USER_ID);
132 auto rdb = cloudDiskRdbStore.GetRaw();
133 ASSERT_TRUE(rdb);
134 auto stopFlag = make_shared<bool>(false);
135 shared_ptr<CloudDiskDataHandler> cloudDiskHandler =
136 make_shared<CloudDiskDataHandler>(USER_ID, bundName, rdb, stopFlag);
137 shared_ptr<CloudDiskDataConvertor> fdirtyConvertor = make_shared<CloudDiskDataConvertor>(
138 USER_ID, bundName, FILE_DATA_MODIFY,
139 std::bind(&CloudDiskDataHandler::HandleFdirtyConvertErr, cloudDiskHandler, std::placeholders::_1,
140 std::placeholders::_2));
141 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
142 int32_t err = E_RDB;
143 fdirtyConvertor->HandleErr(err, *resultSet);
144 EXPECT_EQ(cloudDiskHandler->modifyFailSet_.size(), 1);
145 } catch (...) {
146 EXPECT_TRUE(false);
147 GTEST_LOG_(INFO) << "HandleErr002 ERROR";
148 }
149 GTEST_LOG_(INFO) << "HandleErr002 End";
150 }
151
152 /**
153 * @tc.name: HandleErr003
154 * @tc.desc: Verify the HandleErr function
155 * @tc.type: FUNC
156 * @tc.require: I6JPKG
157 */
158 HWTEST_F(CloudDiskDataConvertorTest, HandleErr003, TestSize.Level1)
159 {
160 GTEST_LOG_(INFO) << "HandleErr003 Begin";
161 try {
162 string bundName = "com.ohos.photos";
163 CloudDisk::CloudDiskRdbStore cloudDiskRdbStore(bundName, USER_ID);
164 auto rdb = cloudDiskRdbStore.GetRaw();
165 ASSERT_TRUE(rdb);
166 auto stopFlag = make_shared<bool>(false);
167 shared_ptr<CloudDiskDataHandler> cloudDiskHandler =
168 make_shared<CloudDiskDataHandler>(USER_ID, bundName, rdb, stopFlag);
169 shared_ptr<CloudDiskDataConvertor> createConvertor = make_shared<CloudDiskDataConvertor>(
170 USER_ID, bundName, FILE_CREATE,
171 std::bind(&CloudDiskDataHandler::HandleCreateConvertErr, cloudDiskHandler, std::placeholders::_1,
172 std::placeholders::_2));
173 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
174 int32_t err = E_RDB;
175 createConvertor->HandleErr(err, *resultSet);
176 EXPECT_EQ(cloudDiskHandler->createFailSet_.size(), 1);
177 } catch (...) {
178 EXPECT_TRUE(false);
179 GTEST_LOG_(INFO) << "HandleErr003 ERROR";
180 }
181 GTEST_LOG_(INFO) << "HandleErr003 End";
182 }
183
184 /**
185 * @tc.name: Convert101
186 * @tc.desc: Verify the Convert function
187 * @tc.type: FUNC
188 * @tc.require: I6JPKG
189 */
190 HWTEST_F(CloudDiskDataConvertorTest, Convert101, TestSize.Level1)
191 {
192 GTEST_LOG_(INFO) << "Convert101 Begin";
193 try {
194 string bundName = "com.ohos.photos";
195 DriveKit::DKRecord record;
196 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
197 shared_ptr<CloudDiskDataConvertor> localConvertor =
198 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DELETE);
199 int res = localConvertor->Convert(record, *resultSet);
200 EXPECT_EQ(res, E_INVAL_ARG);
201 } catch (...) {
202 EXPECT_TRUE(false);
203 GTEST_LOG_(INFO) << " Convert101 ERROR";
204 }
205
206 GTEST_LOG_(INFO) << "Convert101 End";
207 }
208
209 /**
210 * @tc.name: Convert102
211 * @tc.desc: Verify the Convert function
212 * @tc.type: FUNC
213 * @tc.require: I6JPKG
214 */
215 HWTEST_F(CloudDiskDataConvertorTest, Convert102, TestSize.Level1)
216 {
217 GTEST_LOG_(INFO) << "Convert102 Begin";
218 try {
219 string bundName = "com.ohos.photos";
220 CloudDisk::CloudDiskRdbStore cloudDiskRdbStore(bundName, USER_ID);
221 auto rdb = cloudDiskRdbStore.GetRaw();
222 ASSERT_TRUE(rdb);
223 auto stopFlag = make_shared<bool>(false);
224 shared_ptr<CloudDiskDataHandler> cloudDiskHandler =
225 make_shared<CloudDiskDataHandler>(USER_ID, bundName, rdb, stopFlag);
226 shared_ptr<CloudDiskDataConvertor> createConvertor = make_shared<CloudDiskDataConvertor>(
227 USER_ID, bundName, FILE_CREATE,
228 std::bind(&CloudDiskDataHandler::HandleCreateConvertErr, cloudDiskHandler, std::placeholders::_1,
229 std::placeholders::_2));
230 DriveKit::DKRecord record;
231 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
232 int res = createConvertor->Convert(record, *resultSet);
233 EXPECT_FALSE(record.isNewCreate_);
234 EXPECT_EQ(cloudDiskHandler->createFailSet_.size(), 0);
235 EXPECT_EQ(res, E_INVAL_ARG);
236 } catch (...) {
237 EXPECT_TRUE(false);
238 GTEST_LOG_(INFO) << " Convert102 ERROR";
239 }
240
241 GTEST_LOG_(INFO) << "Convert102 End";
242 }
243
244 /**
245 * @tc.name: FillRecordId001
246 * @tc.desc: Verify the FillRecordId function
247 * @tc.type: FUNC
248 * @tc.require: I6JPKG
249 */
250 HWTEST_F(CloudDiskDataConvertorTest, FillRecordId001, TestSize.Level1)
251 {
252 GTEST_LOG_(INFO) << "FillRecordId001 Begin";
253 try {
254 string bundName = "com.ohos.photos";
255 DriveKit::DKRecord record;
256 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
257 shared_ptr<CloudDiskDataConvertor> localConvertor =
258 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
259 int32_t res = localConvertor->FillRecordId(record, *resultSet);
260 EXPECT_EQ(res, E_OK);
261 } catch (...) {
262 EXPECT_TRUE(false);
263 GTEST_LOG_(INFO) << "FillRecordId001 ERROR";
264 }
265
266 GTEST_LOG_(INFO) << "FillRecordId001 End";
267 }
268
269 /**
270 * @tc.name: FillCreatedTime001
271 * @tc.desc: Verify the FillCreatedTime function
272 * @tc.type: FUNC
273 * @tc.require: I6JPKG
274 */
275 HWTEST_F(CloudDiskDataConvertorTest, FillCreatedTime001, TestSize.Level1)
276 {
277 GTEST_LOG_(INFO) << "FillCreatedTime001 Begin";
278 try {
279 string bundName = "com.ohos.photos";
280 DriveKit::DKRecord record;
281 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
282 shared_ptr<CloudDiskDataConvertor> localConvertor =
283 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
284 int32_t res = localConvertor->FillCreatedTime(record, *resultSet);
285 EXPECT_EQ(res, E_OK);
286 } catch (...) {
287 EXPECT_TRUE(false);
288 GTEST_LOG_(INFO) << "FillCreatedTime001 ERROR";
289 }
290
291 GTEST_LOG_(INFO) << "FillCreatedTime001 End";
292 }
293
294 /**
295 * @tc.name: FillCreatedTime002
296 * @tc.desc: Verify the FillCreatedTime function
297 * @tc.type: FUNC
298 * @tc.require: I6JPKG
299 */
300 HWTEST_F(CloudDiskDataConvertorTest, FillCreatedTime002, TestSize.Level1)
301 {
302 GTEST_LOG_(INFO) << "FillCreatedTime002 Begin";
303 try {
304 string bundName = "com.ohos.photos";
305 DriveKit::DKRecord record;
306 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
307 shared_ptr<CloudDiskDataConvertor> deleteConvertor =
308 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DELETE);
309 int32_t res = deleteConvertor->FillCreatedTime(record, *resultSet);
310 EXPECT_EQ(res, E_OK);
311 GTEST_LOG_(INFO) << "zqw record create time is " << record.GetCreateTime();
312 } catch (...) {
313 EXPECT_TRUE(false);
314 GTEST_LOG_(INFO) << "FillCreatedTime002 ERROR";
315 }
316
317 GTEST_LOG_(INFO) << "FillCreatedTime002 End";
318 }
319
320 /**
321 * @tc.name: FillMetaEditedTime001
322 * @tc.desc: Verify the FillMetaEditedTime function
323 * @tc.type: FUNC
324 * @tc.require: I6JPKG
325 */
326 HWTEST_F(CloudDiskDataConvertorTest, FillMetaEditedTime001, TestSize.Level1)
327 {
328 GTEST_LOG_(INFO) << "FillMetaEditedTime001 Begin";
329 try {
330 string bundName = "com.ohos.photos";
331 DriveKit::DKRecord record;
332 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
333 shared_ptr<CloudDiskDataConvertor> localConvertor =
334 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
335 int32_t res = localConvertor->FillMetaEditedTime(record, *resultSet);
336 EXPECT_EQ(res, E_OK);
337 GTEST_LOG_(INFO) << "FillMetaEditedTime001, zqw record edit time is " << record.GetEditedTime();
338 } catch (...) {
339 EXPECT_TRUE(false);
340 GTEST_LOG_(INFO) << "FillMetaEditedTime001 ERROR";
341 }
342
343 GTEST_LOG_(INFO) << "FillMetaEditedTime001 End";
344 }
345
346 /**
347 * @tc.name: FillMetaEditedTime002
348 * @tc.desc: Verify the FillMetaEditedTime function
349 * @tc.type: FUNC
350 * @tc.require: I6JPKG
351 */
352 HWTEST_F(CloudDiskDataConvertorTest, FillMetaEditedTime002, TestSize.Level1)
353 {
354 GTEST_LOG_(INFO) << "FillMetaEditedTime002 Begin";
355 try {
356 string bundName = "com.ohos.photos";
357 DriveKit::DKRecord record;
358 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
359 shared_ptr<CloudDiskDataConvertor> deleteConvertor =
360 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DELETE);
361 int32_t res = deleteConvertor->FillMetaEditedTime(record, *resultSet);
362 EXPECT_EQ(res, E_OK);
363 GTEST_LOG_(INFO) << "FillMetaEditedTime002, zqw record edit time is " << record.GetEditedTime();
364 } catch (...) {
365 EXPECT_TRUE(false);
366 GTEST_LOG_(INFO) << "FillMetaEditedTime002 ERROR";
367 }
368
369 GTEST_LOG_(INFO) << "FillMetaEditedTime002 End";
370 }
371
372 /**
373 * @tc.name: FillVersion001
374 * @tc.desc: Verify the FillVersion function
375 * @tc.type: FUNC
376 * @tc.require: I6JPKG
377 */
378 HWTEST_F(CloudDiskDataConvertorTest, FillVersion001, TestSize.Level1)
379 {
380 GTEST_LOG_(INFO) << "FillVersion001 Begin";
381 try {
382 string bundName = "com.ohos.photos";
383 DriveKit::DKRecord record;
384 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
385 shared_ptr<CloudDiskDataConvertor> localConvertor =
386 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
387 int32_t res = localConvertor->FillVersion(record, *resultSet);
388 EXPECT_EQ(res, E_OK);
389 GTEST_LOG_(INFO) << "FillVersion001, zqw record version is " << record.GetVersion();
390 } catch (...) {
391 EXPECT_TRUE(false);
392 GTEST_LOG_(INFO) << "FillVersion001 ERROR";
393 }
394
395 GTEST_LOG_(INFO) << "FillVersion001 End";
396 }
397
398 /**
399 * @tc.name: ExtractCompatibleValue001
400 * @tc.desc: Verify the ExtractCompatibleValue function
401 * @tc.type: FUNC
402 * @tc.require: I6JPKG
403 */
404 HWTEST_F(CloudDiskDataConvertorTest, ExtractCompatibleValue001, TestSize.Level1)
405 {
406 GTEST_LOG_(INFO) << "ExtractCompatibleValue001 Begin";
407 try {
408 string bundName = "com.ohos.photos";
409 DriveKit::DKRecord record;
410 DriveKit::DKRecordData data;
411 record.GetRecordData(data);
412 NativeRdb::ValuesBucket values;
413 shared_ptr<CloudDiskDataConvertor> localConvertor =
414 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
415 int32_t res = localConvertor->ExtractCompatibleValue(record, data, values);
416 EXPECT_EQ(res, E_INVAL_ARG);
417 } catch (...) {
418 EXPECT_TRUE(false);
419 GTEST_LOG_(INFO) << "ExtractCompatibleValue001 ERROR";
420 }
421
422 GTEST_LOG_(INFO) << "ExtractCompatibleValue001 End";
423 }
424
425 /**
426 * @tc.name: ExtractCompatibleValue002
427 * @tc.desc: Verify the ExtractCompatibleValue function
428 * @tc.type: FUNC
429 * @tc.require: I6JPKG
430 */
431 HWTEST_F(CloudDiskDataConvertorTest, ExtractCompatibleValue002, TestSize.Level1)
432 {
433 GTEST_LOG_(INFO) << "ExtractCompatibleValue002 Begin";
434 try {
435 string bundName = "com.ohos.photos";
436 DriveKit::DKRecord record;
437 record.SetDelete(true);
438 DriveKit::DKRecordData data;
439 record.GetRecordData(data);
440 NativeRdb::ValuesBucket values;
441 shared_ptr<CloudDiskDataConvertor> localConvertor =
442 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
443 int32_t res = localConvertor->ExtractCompatibleValue(record, data, values);
444 EXPECT_EQ(res, E_OK);
445 EXPECT_TRUE(record.GetIsDelete());
446 } catch (...) {
447 EXPECT_TRUE(false);
448 GTEST_LOG_(INFO) << "ExtractCompatibleValue002 ERROR";
449 }
450
451 GTEST_LOG_(INFO) << "ExtractCompatibleValue002 End";
452 }
453
454 /**
455 * @tc.name: CompensateAttributes001
456 * @tc.desc: Verify the CompensateAttributes function
457 * @tc.type: FUNC
458 * @tc.require: I6JPKG
459 */
460 HWTEST_F(CloudDiskDataConvertorTest, CompensateAttributes001, TestSize.Level1)
461 {
462 GTEST_LOG_(INFO) << "CompensateAttributes001 Begin";
463 try {
464 string bundName = "com.ohos.photos";
465 DriveKit::DKRecord record;
466 DriveKit::DKRecordData data;
467 record.GetRecordData(data);
468 NativeRdb::ValuesBucket values;
469 shared_ptr<CloudDiskDataConvertor> localConvertor =
470 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
471 int32_t res = localConvertor->CompensateAttributes(data, record, values);
472 EXPECT_EQ(res, E_OK);
473 } catch (...) {
474 EXPECT_TRUE(false);
475 GTEST_LOG_(INFO) << "CompensateAttributes001 ERROR";
476 }
477
478 GTEST_LOG_(INFO) << "CompensateAttributes001 End";
479 }
480
481 /**
482 * @tc.name: CompensateAttributes002
483 * @tc.desc: Verify the CompensateAttributes function
484 * @tc.type: FUNC
485 * @tc.require: I6JPKG
486 */
487 HWTEST_F(CloudDiskDataConvertorTest, CompensateAttributes002, TestSize.Level1)
488 {
489 GTEST_LOG_(INFO) << "CompensateAttributes002 Begin";
490 try {
491 string bundName = "com.ohos.photos";
492 DriveKit::DKRecord record;
493 DriveKit::DKRecordData data;
494 data.emplace(DK_FILE_ATTRIBUTES, DriveKit::DKRecordField("DKRecordFieldTest"));
495 record.GetRecordData(data);
496 NativeRdb::ValuesBucket values;
497 shared_ptr<CloudDiskDataConvertor> localConvertor =
498 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
499 int32_t res = localConvertor->CompensateAttributes(data, record, values);
500 EXPECT_EQ(res, E_OK);
501 } catch (...) {
502 EXPECT_TRUE(false);
503 GTEST_LOG_(INFO) << "CompensateAttributes002 ERROR";
504 }
505
506 GTEST_LOG_(INFO) << "CompensateAttributes002 End";
507 }
508
509 /**
510 * @tc.name: CompensateAttributes003
511 * @tc.desc: Verify the CompensateAttributes function
512 * @tc.type: FUNC
513 * @tc.require: I6JPKG
514 */
515 HWTEST_F(CloudDiskDataConvertorTest, CompensateAttributes003, TestSize.Level1)
516 {
517 GTEST_LOG_(INFO) << "CompensateAttributes003 Begin";
518 try {
519 string bundName = "com.ohos.photos";
520 DriveKit::DKRecord record;
521 DriveKit::DKRecordData data;
522 data.emplace(DK_FILE_ATTRIBUTES, DriveKit::DKRecordField(1));
523 data.emplace(DK_FILE_TIME_ADDED, DriveKit::DKRecordField(1));
524 data.emplace(DK_FILE_TIME_EDITED, DriveKit::DKRecordField(1));
525 data.emplace(DK_META_TIME_EDITED, DriveKit::DKRecordField(1));
526 record.GetRecordData(data);
527 NativeRdb::ValuesBucket values;
528 shared_ptr<CloudDiskDataConvertor> localConvertor =
529 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
530 int32_t res = localConvertor->CompensateAttributes(data, record, values);
531 EXPECT_EQ(res, E_OK);
532 } catch (...) {
533 EXPECT_TRUE(false);
534 GTEST_LOG_(INFO) << "CompensateAttributes003 ERROR";
535 }
536
537 GTEST_LOG_(INFO) << "CompensateAttributes003 End";
538 }
539
540 /**
541 * @tc.name: ExtractCloudId001
542 * @tc.desc: Verify the ExtractCloudId function
543 * @tc.type: FUNC
544 * @tc.require: I6JPKG
545 */
546 HWTEST_F(CloudDiskDataConvertorTest, ExtractCloudId001, TestSize.Level1)
547 {
548 GTEST_LOG_(INFO) << "ExtractCloudId001 Begin";
549 try {
550 string bundName = "com.ohos.photos";
551 DriveKit::DKRecord record;
552 NativeRdb::ValuesBucket values;
553 shared_ptr<CloudDiskDataConvertor> localConvertor =
554 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
555
556 int32_t res = localConvertor->ExtractCloudId(record, values);
557 EXPECT_EQ(res, E_OK);
558 } catch (...) {
559 EXPECT_TRUE(false);
560 GTEST_LOG_(INFO) << "ExtractCloudId001 ERROR";
561 }
562
563 GTEST_LOG_(INFO) << "ExtractCloudId001 End";
564 }
565
566 /**
567 * @tc.name: ExtractFileName001
568 * @tc.desc: Verify the ExtractFileName function
569 * @tc.type: FUNC
570 * @tc.require: I6JPKG
571 */
572 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileName001, TestSize.Level1)
573 {
574 GTEST_LOG_(INFO) << "ExtractFileName001 Begin";
575 try {
576 string bundName = "com.ohos.photos";
577 DriveKit::DKRecord record;
578 DriveKit::DKRecordData data;
579 record.GetRecordData(data);
580 NativeRdb::ValuesBucket values;
581 shared_ptr<CloudDiskDataConvertor> localConvertor =
582 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
583
584 int32_t res = localConvertor->ExtractFileName(data, values);
585 EXPECT_EQ(res, E_INVAL_ARG);
586 } catch (...) {
587 EXPECT_TRUE(false);
588 GTEST_LOG_(INFO) << "ExtractFileName001 ERROR";
589 }
590
591 GTEST_LOG_(INFO) << "ExtractFileName001 End";
592 }
593
594 /**
595 * @tc.name: ExtractFileName002
596 * @tc.desc: Verify the ExtractFileName function
597 * @tc.type: FUNC
598 * @tc.require: I6JPKG
599 */
600 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileName002, TestSize.Level1)
601 {
602 GTEST_LOG_(INFO) << "ExtractFileName002 Begin";
603 try {
604 string bundName = "com.ohos.photos";
605 DriveKit::DKRecord record;
606 DriveKit::DKRecordData data;
607 data.emplace(DK_FILE_NAME, DriveKit::DKRecordField("1.txt"));
608 record.GetRecordData(data);
609 NativeRdb::ValuesBucket values;
610 shared_ptr<CloudDiskDataConvertor> localConvertor =
611 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
612
613 int32_t res = localConvertor->ExtractFileName(data, values);
614 EXPECT_EQ(res, E_INVAL_ARG);
615 } catch (...) {
616 EXPECT_TRUE(false);
617 GTEST_LOG_(INFO) << "ExtractFileName002 ERROR";
618 }
619
620 GTEST_LOG_(INFO) << "ExtractFileName002 End";
621 }
622
623 /**
624 * @tc.name: ExtractFileName003
625 * @tc.desc: Verify the ExtractFileName function
626 * @tc.type: FUNC
627 * @tc.require: I6JPKG
628 */
629 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileName003, TestSize.Level1)
630 {
631 GTEST_LOG_(INFO) << "ExtractFileName003 Begin";
632 try {
633 string bundName = "com.ohos.photos";
634 DriveKit::DKRecord record;
635 DriveKit::DKRecordData data;
636 data.emplace(DK_FILE_NAME, DriveKit::DKRecordField("testFile"));
637 record.GetRecordData(data);
638 NativeRdb::ValuesBucket values;
639 shared_ptr<CloudDiskDataConvertor> localConvertor =
640 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
641
642 int32_t res = localConvertor->ExtractFileName(data, values);
643 EXPECT_EQ(res, E_INVAL_ARG);
644 } catch (...) {
645 EXPECT_TRUE(false);
646 GTEST_LOG_(INFO) << "ExtractFileName003 ERROR";
647 }
648
649 GTEST_LOG_(INFO) << "ExtractFileName003 End";
650 }
651
652 /**
653 * @tc.name: ExtractFileParentCloudId001
654 * @tc.desc: Verify the ExtractFileParentCloudId function
655 * @tc.type: FUNC
656 * @tc.require: I6JPKG
657 */
658 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileParentCloudId001, TestSize.Level1)
659 {
660 GTEST_LOG_(INFO) << "ExtractFileParentCloudId001 Begin";
661 try {
662 string bundName = "com.ohos.photos";
663 DriveKit::DKRecord record;
664 DriveKit::DKRecordData data;
665 record.GetRecordData(data);
666 NativeRdb::ValuesBucket values;
667 shared_ptr<CloudDiskDataConvertor> localConvertor =
668 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
669
670 int32_t res = localConvertor->ExtractFileParentCloudId(data, values);
671 EXPECT_EQ(res, E_INVAL_ARG);
672 } catch (...) {
673 EXPECT_TRUE(false);
674 GTEST_LOG_(INFO) << "ExtractFileParentCloudId001 ERROR";
675 }
676
677 GTEST_LOG_(INFO) << "ExtractFileParentCloudId001 End";
678 }
679
680 /**
681 * @tc.name: ExtractFileParentCloudId002
682 * @tc.desc: Verify the ExtractFileParentCloudId function
683 * @tc.type: FUNC
684 * @tc.require: I6JPKG
685 */
686 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileParentCloudId002, TestSize.Level1)
687 {
688 GTEST_LOG_(INFO) << "ExtractFileParentCloudId002 Begin";
689 try {
690 string bundName = "com.ohos.photos";
691 DriveKit::DKRecord record;
692 DriveKit::DKRecordData data;
693 record.GetRecordData(data);
694 data.emplace(DK_PARENT_CLOUD_ID, DriveKit::DKRecordField("parentFolder"));
695 NativeRdb::ValuesBucket values;
696 shared_ptr<CloudDiskDataConvertor> localConvertor =
697 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
698
699 int32_t res = localConvertor->ExtractFileParentCloudId(data, values);
700 EXPECT_EQ(res, E_OK);
701 } catch (...) {
702 EXPECT_TRUE(false);
703 GTEST_LOG_(INFO) << "ExtractFileParentCloudId002 ERROR";
704 }
705
706 GTEST_LOG_(INFO) << "ExtractFileParentCloudId002 End";
707 }
708
709 /**
710 * @tc.name: ExtractFileParentCloudId003
711 * @tc.desc: Verify the ExtractFileParentCloudId function
712 * @tc.type: FUNC
713 * @tc.require: I6JPKG
714 */
715 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileParentCloudId003, TestSize.Level1)
716 {
717 GTEST_LOG_(INFO) << "ExtractFileParentCloudId003 Begin";
718 try {
719 string bundName = "com.ohos.photos";
720 DriveKit::DKRecord record;
721 DriveKit::DKRecordData data;
722 data.emplace(DK_PARENT_CLOUD_ID, DriveKit::DKRecordField(1));
723 record.GetRecordData(data);
724 NativeRdb::ValuesBucket values;
725 shared_ptr<CloudDiskDataConvertor> localConvertor =
726 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
727
728 int32_t res = localConvertor->ExtractFileParentCloudId(data, values);
729 EXPECT_EQ(res, E_INVAL_ARG);
730 } catch (...) {
731 EXPECT_TRUE(false);
732 GTEST_LOG_(INFO) << "ExtractFileParentCloudId003 ERROR";
733 }
734
735 GTEST_LOG_(INFO) << "ExtractFileParentCloudId003 End";
736 }
737
738 /**
739 * @tc.name: ExtractFileSize001
740 * @tc.desc: Verify the ExtractFileSize function
741 * @tc.type: FUNC
742 * @tc.require: I6JPKG
743 */
744 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileSize001, TestSize.Level1)
745 {
746 GTEST_LOG_(INFO) << "ExtractFileSize001 Begin";
747 try {
748 string bundName = "com.ohos.photos";
749 DriveKit::DKRecord record;
750 DriveKit::DKRecordData data;
751 record.GetRecordData(data);
752 NativeRdb::ValuesBucket values;
753 shared_ptr<CloudDiskDataConvertor> localConvertor =
754 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
755
756 int32_t res = localConvertor->ExtractFileSize(data, values);
757 EXPECT_EQ(res, E_INVAL_ARG);
758 } catch (...) {
759 EXPECT_TRUE(false);
760 GTEST_LOG_(INFO) << "ExtractFileSize001 ERROR";
761 }
762
763 GTEST_LOG_(INFO) << "ExtractFileSize001 End";
764 }
765
766 /**
767 * @tc.name: ExtractFileSize002
768 * @tc.desc: Verify the ExtractFileSize function
769 * @tc.type: FUNC
770 * @tc.require: I6JPKG
771 */
772 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileSize002, TestSize.Level1)
773 {
774 GTEST_LOG_(INFO) << "ExtractFileSize002 Begin";
775 try {
776 string bundName = "com.ohos.photos";
777 DriveKit::DKRecord record;
778 DriveKit::DKRecordData data;
779 data.emplace(DK_FILE_SIZE, DriveKit::DKRecordField("test"));
780 record.GetRecordData(data);
781 NativeRdb::ValuesBucket values;
782 shared_ptr<CloudDiskDataConvertor> localConvertor =
783 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
784
785 int32_t res = localConvertor->ExtractFileSize(data, values);
786 EXPECT_EQ(res, E_INVAL_ARG);
787 } catch (...) {
788 EXPECT_TRUE(false);
789 GTEST_LOG_(INFO) << "ExtractFileSize002 ERROR";
790 }
791
792 GTEST_LOG_(INFO) << "ExtractFileSize002 End";
793 }
794
795 /**
796 * @tc.name: ExtractFileSize003
797 * @tc.desc: Verify the ExtractFileSize function
798 * @tc.type: FUNC
799 * @tc.require: I6JPKG
800 */
801 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileSize003, TestSize.Level1)
802 {
803 GTEST_LOG_(INFO) << "ExtractFileSize003 Begin";
804 try {
805 string bundName = "com.ohos.photos";
806 DriveKit::DKRecord record;
807 DriveKit::DKRecordData data;
808 data.emplace(DK_FILE_SIZE, DriveKit::DKRecordField(1));
809 record.GetRecordData(data);
810 NativeRdb::ValuesBucket values;
811 shared_ptr<CloudDiskDataConvertor> localConvertor =
812 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
813
814 int32_t res = localConvertor->ExtractFileSize(data, values);
815 EXPECT_EQ(res, E_INVAL_ARG);
816 } catch (...) {
817 EXPECT_TRUE(false);
818 GTEST_LOG_(INFO) << "ExtractFileSize003 ERROR";
819 }
820
821 GTEST_LOG_(INFO) << "ExtractFileSize003 End";
822 }
823
824 /**
825 * @tc.name: ExtractSha256001
826 * @tc.desc: Verify the ExtractSha256 function
827 * @tc.type: FUNC
828 * @tc.require: I6JPKG
829 */
830 HWTEST_F(CloudDiskDataConvertorTest, ExtractSha256001, TestSize.Level1)
831 {
832 GTEST_LOG_(INFO) << "ExtractSha256001 Begin";
833 try {
834 string bundName = "com.ohos.photos";
835 DriveKit::DKRecord record;
836 DriveKit::DKRecordData data;
837 record.GetRecordData(data);
838 NativeRdb::ValuesBucket values;
839 shared_ptr<CloudDiskDataConvertor> localConvertor =
840 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
841
842 int32_t res = localConvertor->ExtractSha256(data, values);
843 EXPECT_EQ(res, E_INVAL_ARG);
844 } catch (...) {
845 EXPECT_TRUE(false);
846 GTEST_LOG_(INFO) << "ExtractSha256001 ERROR";
847 }
848
849 GTEST_LOG_(INFO) << "ExtractSha256001 End";
850 }
851
852 /**
853 * @tc.name: ExtractSha256002
854 * @tc.desc: Verify the ExtractSha256 function
855 * @tc.type: FUNC
856 * @tc.require: I6JPKG
857 */
858 HWTEST_F(CloudDiskDataConvertorTest, ExtractSha256002, TestSize.Level1)
859 {
860 GTEST_LOG_(INFO) << "ExtractSha256002 Begin";
861 try {
862 string bundName = "com.ohos.photos";
863 DriveKit::DKRecord record;
864 DriveKit::DKRecordData data;
865 data.emplace(DK_FILE_SHA256, DriveKit::DKRecordField(1));
866 record.GetRecordData(data);
867 NativeRdb::ValuesBucket values;
868 shared_ptr<CloudDiskDataConvertor> localConvertor =
869 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
870
871 int32_t res = localConvertor->ExtractSha256(data, values);
872 EXPECT_EQ(res, E_INVAL_ARG);
873 } catch (...) {
874 EXPECT_TRUE(false);
875 GTEST_LOG_(INFO) << "ExtractSha256002 ERROR";
876 }
877
878 GTEST_LOG_(INFO) << "ExtractSha256002 End";
879 }
880
881 /**
882 * @tc.name: ExtractSha256003
883 * @tc.desc: Verify the ExtractSha256 function
884 * @tc.type: FUNC
885 * @tc.require: I6JPKG
886 */
887 HWTEST_F(CloudDiskDataConvertorTest, ExtractSha256003, TestSize.Level1)
888 {
889 GTEST_LOG_(INFO) << "ExtractSha256003 Begin";
890 try {
891 string bundName = "com.ohos.photos";
892 DriveKit::DKRecord record;
893 DriveKit::DKRecordData data;
894 data.emplace(DK_FILE_SHA256, DriveKit::DKRecordField("sha256"));
895 record.GetRecordData(data);
896 NativeRdb::ValuesBucket values;
897 shared_ptr<CloudDiskDataConvertor> localConvertor =
898 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
899
900 int32_t res = localConvertor->ExtractSha256(data, values);
901 EXPECT_EQ(res, E_INVAL_ARG);
902 } catch (...) {
903 EXPECT_TRUE(false);
904 GTEST_LOG_(INFO) << "ExtractSha256003 ERROR";
905 }
906
907 GTEST_LOG_(INFO) << "ExtractSha256003 End";
908 }
909
910 /**
911 * @tc.name: ExtractFileTimeRecycled001
912 * @tc.desc: Verify the ExtractFileTimeRecycled function
913 * @tc.type: FUNC
914 * @tc.require: I6JPKG
915 */
916 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileTimeRecycled001, TestSize.Level1)
917 {
918 GTEST_LOG_(INFO) << "ExtractFileTimeRecycled001 Begin";
919 try {
920 string bundName = "com.ohos.photos";
921 DriveKit::DKRecord record;
922 DriveKit::DKRecordData data;
923 record.GetRecordData(data);
924 NativeRdb::ValuesBucket values;
925 shared_ptr<CloudDiskDataConvertor> localConvertor =
926 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
927
928 int32_t res = localConvertor->ExtractFileTimeRecycled(data, values);
929 EXPECT_EQ(res, E_INVAL_ARG);
930 } catch (...) {
931 EXPECT_TRUE(false);
932 GTEST_LOG_(INFO) << "ExtractFileTimeRecycled001 ERROR";
933 }
934
935 GTEST_LOG_(INFO) << "ExtractFileTimeRecycled001 End";
936 }
937
938 /**
939 * @tc.name: ExtractFileTimeRecycled002
940 * @tc.desc: Verify the ExtractFileTimeRecycled function
941 * @tc.type: FUNC
942 * @tc.require: I6JPKG
943 */
944 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileTimeRecycled002, TestSize.Level1)
945 {
946 GTEST_LOG_(INFO) << "ExtractFileTimeRecycled002 Begin";
947 try {
948 string bundName = "com.ohos.photos";
949 DriveKit::DKRecord record;
950 DriveKit::DKRecordData data;
951
952 record.GetRecordData(data);
953 NativeRdb::ValuesBucket values;
954 shared_ptr<CloudDiskDataConvertor> localConvertor =
955 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
956 data.emplace(DK_IS_RECYCLED, DriveKit::DKRecordField(false));
957 int32_t res = localConvertor->ExtractFileTimeRecycled(data, values);
958 EXPECT_EQ(res, E_OK);
959 } catch (...) {
960 EXPECT_TRUE(false);
961 GTEST_LOG_(INFO) << "ExtractFileTimeRecycled002 ERROR";
962 }
963
964 GTEST_LOG_(INFO) << "ExtractFileTimeRecycled002 End";
965 }
966
967 /**
968 * @tc.name: ExtractFileTimeRecycled003
969 * @tc.desc: Verify the ExtractFileTimeRecycled function
970 * @tc.type: FUNC
971 * @tc.require: I6JPKG
972 */
973 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileTimeRecycled003, TestSize.Level1)
974 {
975 GTEST_LOG_(INFO) << "ExtractFileTimeRecycled003 Begin";
976 try {
977 string bundName = "com.ohos.photos";
978 DriveKit::DKRecord record;
979 DriveKit::DKRecordData data;
980
981 record.GetRecordData(data);
982 NativeRdb::ValuesBucket values;
983 shared_ptr<CloudDiskDataConvertor> localConvertor =
984 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
985 data.emplace(DK_IS_RECYCLED, DriveKit::DKRecordField(true));
986 int32_t res = localConvertor->ExtractFileTimeRecycled(data, values);
987 EXPECT_EQ(res, E_INVAL_ARG);
988 } catch (...) {
989 EXPECT_TRUE(false);
990 GTEST_LOG_(INFO) << "ExtractFileTimeRecycled003 ERROR";
991 }
992
993 GTEST_LOG_(INFO) << "ExtractFileTimeRecycled003 End";
994 }
995
996 /**
997 * @tc.name: ExtractFileTimeRecycled004
998 * @tc.desc: Verify the ExtractFileTimeRecycled function
999 * @tc.type: FUNC
1000 * @tc.require: I6JPKG
1001 */
1002 HWTEST_F(CloudDiskDataConvertorTest, ExtractFileTimeRecycled004, TestSize.Level1)
1003 {
1004 GTEST_LOG_(INFO) << "ExtractFileTimeRecycled004 Begin";
1005 try {
1006 string bundName = "com.ohos.photos";
1007 DriveKit::DKRecord record;
1008 DriveKit::DKRecordData data;
1009
1010 record.GetRecordData(data);
1011 NativeRdb::ValuesBucket values;
1012 shared_ptr<CloudDiskDataConvertor> localConvertor =
1013 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1014 data.emplace(DK_IS_RECYCLED, DriveKit::DKRecordField(true));
1015 data.emplace(DK_FILE_TIME_RECYCLED, DriveKit::DKRecordField(true));
1016 int32_t res = localConvertor->ExtractFileTimeRecycled(data, values);
1017 EXPECT_EQ(res, E_INVAL_ARG);
1018 } catch (...) {
1019 EXPECT_TRUE(false);
1020 GTEST_LOG_(INFO) << "ExtractFileTimeRecycled004 ERROR";
1021 }
1022
1023 GTEST_LOG_(INFO) << "ExtractFileTimeRecycled004 End";
1024 }
1025
1026 /**
1027 * @tc.name: ExtractDirectlyRecycled001
1028 * @tc.desc: Verify the ExtractDirectlyRecycled function
1029 * @tc.type: FUNC
1030 * @tc.require: I6JPKG
1031 */
1032 HWTEST_F(CloudDiskDataConvertorTest, ExtractDirectlyRecycled001, TestSize.Level1)
1033 {
1034 GTEST_LOG_(INFO) << "ExtractDirectlyRecycled001 Begin";
1035 try {
1036 string bundName = "com.ohos.photos";
1037 DriveKit::DKRecord record;
1038 DriveKit::DKRecordData data;
1039 record.GetRecordData(data);
1040 NativeRdb::ValuesBucket values;
1041 shared_ptr<CloudDiskDataConvertor> localConvertor =
1042 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1043
1044 int32_t res = localConvertor->ExtractDirectlyRecycled(data, values);
1045 EXPECT_EQ(res, E_INVAL_ARG);
1046 } catch (...) {
1047 EXPECT_TRUE(false);
1048 GTEST_LOG_(INFO) << "ExtractDirectlyRecycled001 ERROR";
1049 }
1050
1051 GTEST_LOG_(INFO) << "ExtractDirectlyRecycled001 End";
1052 }
1053
1054 /**
1055 * @tc.name: ExtractDirectlyRecycled002
1056 * @tc.desc: Verify the ExtractDirectlyRecycled function
1057 * @tc.type: FUNC
1058 * @tc.require: I6JPKG
1059 */
1060 HWTEST_F(CloudDiskDataConvertorTest, ExtractDirectlyRecycled002, TestSize.Level1)
1061 {
1062 GTEST_LOG_(INFO) << "ExtractDirectlyRecycled002 Begin";
1063 try {
1064 string bundName = "com.ohos.photos";
1065 DriveKit::DKRecord record;
1066 DriveKit::DKRecordData data;
1067 data.emplace(DK_DIRECTLY_RECYCLED, DriveKit::DKRecordField(false));
1068 record.GetRecordData(data);
1069 NativeRdb::ValuesBucket values;
1070 shared_ptr<CloudDiskDataConvertor> localConvertor =
1071 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1072
1073 int32_t res = localConvertor->ExtractDirectlyRecycled(data, values);
1074 EXPECT_EQ(res, E_INVAL_ARG);
1075 } catch (...) {
1076 EXPECT_TRUE(false);
1077 GTEST_LOG_(INFO) << "ExtractDirectlyRecycled002 ERROR";
1078 }
1079
1080 GTEST_LOG_(INFO) << "ExtractDirectlyRecycled002 End";
1081 }
1082
1083 /**
1084 * @tc.name: ExtractDirectlyRecycled003
1085 * @tc.desc: Verify the ExtractDirectlyRecycled function
1086 * @tc.type: FUNC
1087 * @tc.require: I6JPKG
1088 */
1089 HWTEST_F(CloudDiskDataConvertorTest, ExtractDirectlyRecycled003, TestSize.Level1)
1090 {
1091 GTEST_LOG_(INFO) << "ExtractDirectlyRecycled003 Begin";
1092 try {
1093 string bundName = "com.ohos.photos";
1094 DriveKit::DKRecord record;
1095 DriveKit::DKRecordData data;
1096 data.emplace(DK_DIRECTLY_RECYCLED, DriveKit::DKRecordField(true));
1097 record.GetRecordData(data);
1098 NativeRdb::ValuesBucket values;
1099 shared_ptr<CloudDiskDataConvertor> localConvertor =
1100 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1101
1102 int32_t res = localConvertor->ExtractDirectlyRecycled(data, values);
1103 EXPECT_EQ(res, E_INVAL_ARG);
1104 } catch (...) {
1105 EXPECT_TRUE(false);
1106 GTEST_LOG_(INFO) << "ExtractDirectlyRecycled003 ERROR";
1107 }
1108
1109 GTEST_LOG_(INFO) << "ExtractDirectlyRecycled003 End";
1110 }
1111
1112 /**
1113 * @tc.name: ExtractIsDirectory001
1114 * @tc.desc: Verify the ExtractIsDirectory function
1115 * @tc.type: FUNC
1116 * @tc.require: I6JPKG
1117 */
1118 HWTEST_F(CloudDiskDataConvertorTest, ExtractIsDirectory001, TestSize.Level1)
1119 {
1120 GTEST_LOG_(INFO) << "ExtractIsDirectory001 Begin";
1121 try {
1122 string bundName = "com.ohos.photos";
1123 DriveKit::DKRecord record;
1124 DriveKit::DKRecordData data;
1125 record.GetRecordData(data);
1126 NativeRdb::ValuesBucket values;
1127 shared_ptr<CloudDiskDataConvertor> localConvertor =
1128 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1129
1130 int32_t res = localConvertor->ExtractIsDirectory(data, values);
1131 EXPECT_EQ(res, E_INVAL_ARG);
1132 } catch (...) {
1133 EXPECT_TRUE(false);
1134 GTEST_LOG_(INFO) << "ExtractIsDirectory001 ERROR";
1135 }
1136
1137 GTEST_LOG_(INFO) << "ExtractIsDirectory001 End";
1138 }
1139
1140 /**
1141 * @tc.name: ExtractIsDirectory002
1142 * @tc.desc: Verify the ExtractIsDirectory function
1143 * @tc.type: FUNC
1144 * @tc.require: I6JPKG
1145 */
1146 HWTEST_F(CloudDiskDataConvertorTest, ExtractIsDirectory002, TestSize.Level1)
1147 {
1148 GTEST_LOG_(INFO) << "ExtractIsDirectory002 Begin";
1149 try {
1150 string bundName = "com.ohos.photos";
1151 DriveKit::DKRecord record;
1152 DriveKit::DKRecordData data;
1153 data.emplace(DK_IS_DIRECTORY, "dir");
1154 record.GetRecordData(data);
1155 NativeRdb::ValuesBucket values;
1156 shared_ptr<CloudDiskDataConvertor> localConvertor =
1157 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1158
1159 int32_t res = localConvertor->ExtractIsDirectory(data, values);
1160 EXPECT_EQ(res, E_INVAL_ARG);
1161 } catch (...) {
1162 EXPECT_TRUE(false);
1163 GTEST_LOG_(INFO) << "ExtractIsDirectory002 ERROR";
1164 }
1165
1166 GTEST_LOG_(INFO) << "ExtractIsDirectory002 End";
1167 }
1168
1169 /**
1170 * @tc.name: ExtractIsDirectory003
1171 * @tc.desc: Verify the ExtractIsDirectory function
1172 * @tc.type: FUNC
1173 * @tc.require: I6JPKG
1174 */
1175 HWTEST_F(CloudDiskDataConvertorTest, ExtractIsDirectory003, TestSize.Level1)
1176 {
1177 GTEST_LOG_(INFO) << "ExtractIsDirectory003 Begin";
1178 try {
1179 string bundName = "com.ohos.photos";
1180 DriveKit::DKRecord record;
1181 DriveKit::DKRecordData data;
1182 data.emplace(DK_IS_DIRECTORY, "file");
1183 record.GetRecordData(data);
1184 NativeRdb::ValuesBucket values;
1185 shared_ptr<CloudDiskDataConvertor> localConvertor =
1186 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1187
1188 int32_t res = localConvertor->ExtractIsDirectory(data, values);
1189 EXPECT_EQ(res, E_INVAL_ARG);
1190 } catch (...) {
1191 EXPECT_TRUE(false);
1192 GTEST_LOG_(INFO) << "ExtractIsDirectory003 ERROR";
1193 }
1194
1195 GTEST_LOG_(INFO) << "ExtractIsDirectory003 End";
1196 }
1197
1198 /**
1199 * @tc.name: ExtractVersion001
1200 * @tc.desc: Verify the ExtractVersion function
1201 * @tc.type: FUNC
1202 * @tc.require: I6JPKG
1203 */
1204 HWTEST_F(CloudDiskDataConvertorTest, ExtractVersion001, TestSize.Level1)
1205 {
1206 GTEST_LOG_(INFO) << "ExtractVersion001 Begin";
1207 try {
1208 string bundName = "com.ohos.photos";
1209 DriveKit::DKRecord record;
1210 NativeRdb::ValuesBucket values;
1211 shared_ptr<CloudDiskDataConvertor> localConvertor =
1212 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1213
1214 int32_t res = localConvertor->ExtractVersion(record, values);
1215 EXPECT_EQ(res, E_OK);
1216 EXPECT_EQ(record.GetVersion(), 0);
1217 } catch (...) {
1218 EXPECT_TRUE(false);
1219 GTEST_LOG_(INFO) << "ExtractVersion001 ERROR";
1220 }
1221
1222 GTEST_LOG_(INFO) << "ExtractVersion001 End";
1223 }
1224
1225 /**
1226 * @tc.name: ExtractVersion002
1227 * @tc.desc: Verify the ExtractVersion function
1228 * @tc.type: FUNC
1229 * @tc.require: I6JPKG
1230 */
1231 HWTEST_F(CloudDiskDataConvertorTest, ExtractVersion002, TestSize.Level1)
1232 {
1233 GTEST_LOG_(INFO) << "ExtractVersion002 Begin";
1234 try {
1235 string bundName = "com.ohos.photos";
1236 DriveKit::DKRecord record;
1237 record.SetVersion(1);
1238 NativeRdb::ValuesBucket values;
1239 shared_ptr<CloudDiskDataConvertor> localConvertor =
1240 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1241
1242 int32_t res = localConvertor->ExtractVersion(record, values);
1243 EXPECT_EQ(res, E_OK);
1244 EXPECT_EQ(record.GetVersion(), 1);
1245 } catch (...) {
1246 EXPECT_TRUE(false);
1247 GTEST_LOG_(INFO) << "ExtractVersion002 ERROR";
1248 }
1249
1250 GTEST_LOG_(INFO) << "ExtractVersion002 End";
1251 }
1252
1253 /**
1254 * @tc.name: HandleFileName001
1255 * @tc.desc: Verify the HandleFileName function
1256 * @tc.type: FUNC
1257 * @tc.require: I6JPKG
1258 */
1259 HWTEST_F(CloudDiskDataConvertorTest, HandleFileName001, TestSize.Level1)
1260 {
1261 GTEST_LOG_(INFO) << "HandleFileName001 Begin";
1262 try {
1263 string bundName = "com.ohos.photos";
1264 DriveKit::DKRecord record;
1265 DriveKit::DKRecordData data;
1266 record.GetRecordData(data);
1267 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1268 shared_ptr<CloudDiskDataConvertor> localConvertor =
1269 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1270
1271 int32_t res = localConvertor->HandleFileName(data, *resultSet);
1272 EXPECT_EQ(res, E_OK);
1273 EXPECT_EQ(data.size(), 1);
1274 } catch (...) {
1275 EXPECT_TRUE(false);
1276 GTEST_LOG_(INFO) << "HandleFileName001 ERROR";
1277 }
1278
1279 GTEST_LOG_(INFO) << "HandleFileName001 End";
1280 }
1281
1282 /**
1283 * @tc.name: HandleFileName002
1284 * @tc.desc: Verify the HandleFileName function
1285 * @tc.type: FUNC
1286 * @tc.require: I6JPKG
1287 */
1288 HWTEST_F(CloudDiskDataConvertorTest, HandleFileName002, TestSize.Level1)
1289 {
1290 GTEST_LOG_(INFO) << "HandleFileName002 Begin";
1291 try {
1292 string bundName = "com.ohos.photos";
1293 DriveKit::DKRecord record;
1294 DriveKit::DKRecordData data;
1295 record.GetRecordData(data);
1296 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1297 shared_ptr<CloudDiskDataConvertor> localConvertor =
1298 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DELETE);
1299
1300 int32_t res = localConvertor->HandleFileName(data, *resultSet);
1301 EXPECT_EQ(res, E_OK);
1302 EXPECT_EQ(data.size(), 0);
1303 } catch (...) {
1304 EXPECT_TRUE(false);
1305 GTEST_LOG_(INFO) << "HandleFileName002 ERROR";
1306 }
1307
1308 GTEST_LOG_(INFO) << "HandleFileName002 End";
1309 }
1310
1311 /**
1312 * @tc.name: HandleParentId001
1313 * @tc.desc: Verify the HandleParentId function
1314 * @tc.type: FUNC
1315 * @tc.require: I6JPKG
1316 */
1317 HWTEST_F(CloudDiskDataConvertorTest, HandleParentId001, TestSize.Level1)
1318 {
1319 GTEST_LOG_(INFO) << "HandleParentId001 Begin";
1320 try {
1321 string bundName = "com.ohos.photos";
1322 DriveKit::DKRecord record;
1323 DriveKit::DKRecordData data;
1324 record.GetRecordData(data);
1325 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1326 shared_ptr<CloudDiskDataConvertor> localConvertor =
1327 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1328
1329 int32_t res = localConvertor->HandleParentId(data, *resultSet);
1330 EXPECT_EQ(res, E_OK);
1331 EXPECT_EQ(data.size(), 1);
1332 } catch (...) {
1333 EXPECT_TRUE(false);
1334 GTEST_LOG_(INFO) << "HandleParentId001 ERROR";
1335 }
1336
1337 GTEST_LOG_(INFO) << "HandleParentId001 End";
1338 }
1339
1340 /**
1341 * @tc.name: HandleParentId002
1342 * @tc.desc: Verify the HandleParentId function
1343 * @tc.type: FUNC
1344 * @tc.require: I6JPKG
1345 */
1346 HWTEST_F(CloudDiskDataConvertorTest, HandleParentId002, TestSize.Level1)
1347 {
1348 GTEST_LOG_(INFO) << "HandleParentId002 Begin";
1349 try {
1350 string bundName = "com.ohos.photos";
1351 DriveKit::DKRecord record;
1352 DriveKit::DKRecordData data;
1353 record.GetRecordData(data);
1354 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1355 shared_ptr<CloudDiskDataConvertor> localConvertor =
1356 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DELETE);
1357
1358 int32_t res = localConvertor->HandleParentId(data, *resultSet);
1359 EXPECT_EQ(res, E_OK);
1360 EXPECT_EQ(data.size(), 0);
1361 } catch (...) {
1362 EXPECT_TRUE(false);
1363 GTEST_LOG_(INFO) << "HandleParentId002 ERROR";
1364 }
1365
1366 GTEST_LOG_(INFO) << "HandleParentId002 End";
1367 }
1368
1369 /**
1370 * @tc.name: HandleDirectlyRecycled001
1371 * @tc.desc: Verify the HandleDirectlyRecycled function
1372 * @tc.type: FUNC
1373 * @tc.require: I6JPKG
1374 */
1375 HWTEST_F(CloudDiskDataConvertorTest, HandleDirectlyRecycled001, TestSize.Level1)
1376 {
1377 GTEST_LOG_(INFO) << "HandleDirectlyRecycled001 Begin";
1378 try {
1379 string bundName = "com.ohos.photos";
1380 DriveKit::DKRecord record;
1381 DriveKit::DKRecordData data;
1382 record.GetRecordData(data);
1383 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1384 shared_ptr<CloudDiskDataConvertor> localConvertor =
1385 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1386
1387 int32_t res = localConvertor->HandleDirectlyRecycled(data, *resultSet);
1388 EXPECT_EQ(res, E_OK);
1389 EXPECT_EQ(data.size(), 1);
1390 } catch (...) {
1391 EXPECT_TRUE(false);
1392 GTEST_LOG_(INFO) << "HandleDirectlyRecycled001 ERROR";
1393 }
1394
1395 GTEST_LOG_(INFO) << "HandleDirectlyRecycled001 End";
1396 }
1397
1398 /**
1399 * @tc.name: HandleDirectlyRecycled002
1400 * @tc.desc: Verify the HandleDirectlyRecycled function
1401 * @tc.type: FUNC
1402 * @tc.require: I6JPKG
1403 */
1404 HWTEST_F(CloudDiskDataConvertorTest, HandleDirectlyRecycled002, TestSize.Level1)
1405 {
1406 GTEST_LOG_(INFO) << "HandleDirectlyRecycled002 Begin";
1407 try {
1408 string bundName = "com.ohos.photos";
1409 DriveKit::DKRecord record;
1410 DriveKit::DKRecordData data;
1411 record.GetRecordData(data);
1412 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1413 shared_ptr<CloudDiskDataConvertor> localConvertor =
1414 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DELETE);
1415
1416 int32_t res = localConvertor->HandleDirectlyRecycled(data, *resultSet);
1417 EXPECT_EQ(res, E_OK);
1418 EXPECT_EQ(data.size(), 0);
1419 } catch (...) {
1420 EXPECT_TRUE(false);
1421 GTEST_LOG_(INFO) << "HandleDirectlyRecycled002 ERROR";
1422 }
1423
1424 GTEST_LOG_(INFO) << "HandleDirectlyRecycled002 End";
1425 }
1426
1427 /**
1428 * @tc.name: HandleRecycleTime001
1429 * @tc.desc: Verify the HandleRecycleTime function
1430 * @tc.type: FUNC
1431 * @tc.require: I6JPKG
1432 */
1433 HWTEST_F(CloudDiskDataConvertorTest, HandleRecycleTime001, TestSize.Level1)
1434 {
1435 GTEST_LOG_(INFO) << "HandleRecycleTime001 Begin";
1436 try {
1437 string bundName = "com.ohos.photos";
1438 DriveKit::DKRecord record;
1439 DriveKit::DKRecordData data;
1440 record.GetRecordData(data);
1441 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1442 shared_ptr<CloudDiskDataConvertor> localConvertor =
1443 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1444
1445 int32_t res = localConvertor->HandleRecycleTime(data, *resultSet);
1446 EXPECT_EQ(res, E_OK);
1447 EXPECT_EQ(data.size(), 1);
1448 } catch (...) {
1449 EXPECT_TRUE(false);
1450 GTEST_LOG_(INFO) << "HandleRecycleTime001 ERROR";
1451 }
1452
1453 GTEST_LOG_(INFO) << "HandleRecycleTime001 End";
1454 }
1455
1456 /**
1457 * @tc.name: HandleRecycleTime002
1458 * @tc.desc: Verify the HandleRecycleTime function
1459 * @tc.type: FUNC
1460 * @tc.require: I6JPKG
1461 */
1462 HWTEST_F(CloudDiskDataConvertorTest, HandleRecycleTime002, TestSize.Level1)
1463 {
1464 GTEST_LOG_(INFO) << "HandleRecycleTime002 Begin";
1465 try {
1466 string bundName = "com.ohos.photos";
1467 DriveKit::DKRecord record;
1468 DriveKit::DKRecordData data;
1469 record.GetRecordData(data);
1470 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1471 shared_ptr<CloudDiskDataConvertor> localConvertor =
1472 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DELETE);
1473
1474 int32_t res = localConvertor->HandleRecycleTime(data, *resultSet);
1475 EXPECT_EQ(res, E_OK);
1476 EXPECT_EQ(data.size(), 0);
1477 } catch (...) {
1478 EXPECT_TRUE(false);
1479 GTEST_LOG_(INFO) << "HandleRecycleTime002 ERROR";
1480 }
1481
1482 GTEST_LOG_(INFO) << "HandleRecycleTime002 End";
1483 }
1484
1485 /**
1486 * @tc.name: HandleType001
1487 * @tc.desc: Verify the HandleType function
1488 * @tc.type: FUNC
1489 * @tc.require: I6JPKG
1490 */
1491 HWTEST_F(CloudDiskDataConvertorTest, HandleType001, TestSize.Level1)
1492 {
1493 GTEST_LOG_(INFO) << "HandleType001 Begin";
1494 try {
1495 string bundName = "com.ohos.photos";
1496 DriveKit::DKRecord record;
1497 DriveKit::DKRecordData data;
1498 record.GetRecordData(data);
1499 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1500 shared_ptr<CloudDiskDataConvertor> localConvertor =
1501 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1502
1503 int32_t res = localConvertor->HandleType(data, *resultSet);
1504 EXPECT_EQ(res, E_OK);
1505 EXPECT_EQ(data.size(), 1);
1506 } catch (...) {
1507 EXPECT_TRUE(false);
1508 GTEST_LOG_(INFO) << "HandleType001 ERROR";
1509 }
1510
1511 GTEST_LOG_(INFO) << "HandleType001 End";
1512 }
1513
1514 /**
1515 * @tc.name: HandleOperateType001
1516 * @tc.desc: Verify the HandleOperateType function
1517 * @tc.type: FUNC
1518 * @tc.require: I6JPKG
1519 */
1520 HWTEST_F(CloudDiskDataConvertorTest, HandleOperateType001, TestSize.Level1)
1521 {
1522 GTEST_LOG_(INFO) << "HandleOperateType001 Begin";
1523 try {
1524 string bundName = "com.ohos.photos";
1525 DriveKit::DKRecord record;
1526 DriveKit::DKRecordData data;
1527 record.GetRecordData(data);
1528 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1529 shared_ptr<CloudDiskDataConvertor> localConvertor =
1530 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1531
1532 int32_t res = localConvertor->HandleOperateType(data, *resultSet);
1533 EXPECT_EQ(res, E_OK);
1534 EXPECT_EQ(data.size(), 1);
1535 } catch (...) {
1536 EXPECT_TRUE(false);
1537 GTEST_LOG_(INFO) << "HandleOperateType001 ERROR";
1538 }
1539
1540 GTEST_LOG_(INFO) << "HandleOperateType001 End";
1541 }
1542
1543 /**
1544 * @tc.name: HandleOperateType002
1545 * @tc.desc: Verify the HandleOperateType function
1546 * @tc.type: FUNC
1547 * @tc.require: I6JPKG
1548 */
1549 HWTEST_F(CloudDiskDataConvertorTest, HandleOperateType002, TestSize.Level1)
1550 {
1551 GTEST_LOG_(INFO) << "HandleOperateType002 Begin";
1552 try {
1553 string bundName = "com.ohos.photos";
1554 DriveKit::DKRecord record;
1555 DriveKit::DKRecordData data;
1556 record.GetRecordData(data);
1557 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1558 shared_ptr<CloudDiskDataConvertor> localConvertor =
1559 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DELETE);
1560
1561 int32_t res = localConvertor->HandleOperateType(data, *resultSet);
1562 EXPECT_EQ(res, E_OK);
1563 EXPECT_EQ(data.size(), 0);
1564 } catch (...) {
1565 EXPECT_TRUE(false);
1566 GTEST_LOG_(INFO) << "HandleOperateType002 ERROR";
1567 }
1568
1569 GTEST_LOG_(INFO) << "HandleOperateType002 End";
1570 }
1571
1572 /**
1573 * @tc.name: HandleCompatibleFileds001
1574 * @tc.desc: Verify the HandleCompatibleFileds function
1575 * @tc.type: FUNC
1576 * @tc.require: I6JPKG
1577 */
1578 HWTEST_F(CloudDiskDataConvertorTest, HandleCompatibleFileds001, TestSize.Level1)
1579 {
1580 GTEST_LOG_(INFO) << "HandleCompatibleFileds001 Begin";
1581 try {
1582 string bundName = "com.ohos.photos";
1583 DriveKit::DKRecord record;
1584 DriveKit::DKRecordData data;
1585 record.GetRecordData(data);
1586 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1587 shared_ptr<CloudDiskDataConvertor> localConvertor =
1588 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1589
1590 int32_t res = localConvertor->HandleCompatibleFileds(data, *resultSet);
1591 EXPECT_EQ(res, E_OK);
1592 } catch (...) {
1593 EXPECT_TRUE(false);
1594 GTEST_LOG_(INFO) << "HandleCompatibleFileds001 ERROR";
1595 }
1596
1597 GTEST_LOG_(INFO) << "HandleCompatibleFileds001 End";
1598 }
1599
1600 /**
1601 * @tc.name: HandleAttributes001
1602 * @tc.desc: Verify the HandleAttributes function
1603 * @tc.type: FUNC
1604 * @tc.require: I6JPKG
1605 */
1606 HWTEST_F(CloudDiskDataConvertorTest, HandleAttributes001, TestSize.Level1)
1607 {
1608 GTEST_LOG_(INFO) << "HandleAttributes001 Begin";
1609 try {
1610 string bundName = "com.ohos.photos";
1611 DriveKit::DKRecord record;
1612 DriveKit::DKRecordData data;
1613 record.GetRecordData(data);
1614 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1615 shared_ptr<CloudDiskDataConvertor> localConvertor =
1616 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1617
1618 int32_t res = localConvertor->HandleAttributes(data, *resultSet);
1619 EXPECT_EQ(res, E_OK);
1620 EXPECT_EQ(data.size(), 1);
1621 } catch (...) {
1622 EXPECT_TRUE(false);
1623 GTEST_LOG_(INFO) << "HandleAttributes001 ERROR";
1624 }
1625
1626 GTEST_LOG_(INFO) << "HandleAttributes001 End";
1627 }
1628
1629 /**
1630 * @tc.name: HandleAttributes002
1631 * @tc.desc: Verify the HandleAttributes function
1632 * @tc.type: FUNC
1633 * @tc.require: I6JPKG
1634 */
1635 HWTEST_F(CloudDiskDataConvertorTest, HandleAttributes002, TestSize.Level1)
1636 {
1637 GTEST_LOG_(INFO) << "HandleAttributes002 Begin";
1638 try {
1639 string bundName = "com.ohos.photos";
1640 DriveKit::DKRecord record;
1641 DriveKit::DKRecordData data;
1642 record.GetRecordData(data);
1643 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1644 shared_ptr<CloudDiskDataConvertor> localConvertor =
1645 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DELETE);
1646
1647 int32_t res = localConvertor->HandleAttributes(data, *resultSet);
1648 EXPECT_EQ(res, E_OK);
1649 EXPECT_EQ(data.size(), 0);
1650 } catch (...) {
1651 EXPECT_TRUE(false);
1652 GTEST_LOG_(INFO) << "HandleAttributes002 ERROR";
1653 }
1654
1655 GTEST_LOG_(INFO) << "HandleAttributes002 End";
1656 }
1657
1658 /**
1659 * @tc.name: HandleCreateTime001
1660 * @tc.desc: Verify the HandleCreateTime function
1661 * @tc.type: FUNC
1662 * @tc.require: I6JPKG
1663 */
1664 HWTEST_F(CloudDiskDataConvertorTest, HandleCreateTime001, TestSize.Level1)
1665 {
1666 GTEST_LOG_(INFO) << "HandleCreateTime001 Begin";
1667 try {
1668 string bundName = "com.ohos.photos";
1669 DriveKit::DKRecordFieldMap map;
1670 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1671 shared_ptr<CloudDiskDataConvertor> localConvertor =
1672 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1673
1674 int32_t res = localConvertor->HandleCreateTime(map, *resultSet);
1675 EXPECT_EQ(res, E_OK);
1676 EXPECT_EQ(map.size(), 1);
1677 } catch (...) {
1678 EXPECT_TRUE(false);
1679 GTEST_LOG_(INFO) << "HandleCreateTime001 ERROR";
1680 }
1681
1682 GTEST_LOG_(INFO) << "HandleCreateTime001 End";
1683 }
1684
1685 /**
1686 * @tc.name: HandleMetaEditedTime001
1687 * @tc.desc: Verify the HandleMetaEditedTime function
1688 * @tc.type: FUNC
1689 * @tc.require: I6JPKG
1690 */
1691 HWTEST_F(CloudDiskDataConvertorTest, HandleMetaEditedTime001, TestSize.Level1)
1692 {
1693 GTEST_LOG_(INFO) << "HandleMetaEditedTime001 Begin";
1694 try {
1695 string bundName = "com.ohos.photos";
1696 DriveKit::DKRecordFieldMap map;
1697 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1698 shared_ptr<CloudDiskDataConvertor> localConvertor =
1699 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1700
1701 int32_t res = localConvertor->HandleMetaEditedTime(map, *resultSet);
1702 EXPECT_EQ(res, E_OK);
1703 EXPECT_EQ(map.size(), 1);
1704 } catch (...) {
1705 EXPECT_TRUE(false);
1706 GTEST_LOG_(INFO) << "HandleMetaEditedTime001 ERROR";
1707 }
1708
1709 GTEST_LOG_(INFO) << "HandleMetaEditedTime001 End";
1710 }
1711
1712 /**
1713 * @tc.name: HandleEditedTime001
1714 * @tc.desc: Verify the HandleEditedTime function
1715 * @tc.type: FUNC
1716 * @tc.require: I6JPKG
1717 */
1718 HWTEST_F(CloudDiskDataConvertorTest, HandleEditedTime001, TestSize.Level1)
1719 {
1720 GTEST_LOG_(INFO) << "HandleEditedTime001 Begin";
1721 try {
1722 string bundName = "com.ohos.photos";
1723 DriveKit::DKRecordFieldMap map;
1724 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1725 shared_ptr<CloudDiskDataConvertor> localConvertor =
1726 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1727
1728 int32_t res = localConvertor->HandleEditedTime(map, *resultSet);
1729 EXPECT_EQ(res, E_OK);
1730 EXPECT_EQ(map.size(), 1);
1731 } catch (...) {
1732 EXPECT_TRUE(false);
1733 GTEST_LOG_(INFO) << "HandleEditedTime001 ERROR";
1734 }
1735
1736 GTEST_LOG_(INFO) << "HandleEditedTime001 End";
1737 }
1738
1739 /**
1740 * @tc.name: HandleAttachments001
1741 * @tc.desc: Verify the HandleAttachments function
1742 * @tc.type: FUNC
1743 * @tc.require: I6JPKG
1744 */
1745 HWTEST_F(CloudDiskDataConvertorTest, HandleAttachments001, TestSize.Level1)
1746 {
1747 GTEST_LOG_(INFO) << "HandleAttachments001 Begin";
1748 try {
1749 string bundName = "com.ohos.photos";
1750 DriveKit::DKRecord record;
1751 DriveKit::DKRecordData data;
1752 record.GetRecordData(data);
1753 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1754 CloudDisk::CloudDiskRdbStore cloudDiskRdbStore(bundName, USER_ID);
1755 auto rdb = cloudDiskRdbStore.GetRaw();
1756 ASSERT_TRUE(rdb);
1757 auto stopFlag = make_shared<bool>(false);
1758 shared_ptr<CloudDiskDataHandler> cloudDiskHandler =
1759 make_shared<CloudDiskDataHandler>(USER_ID, bundName, rdb, stopFlag);
1760 shared_ptr<CloudDiskDataConvertor> createConvertor = make_shared<CloudDiskDataConvertor>(
1761 USER_ID, bundName, FILE_CREATE,
1762 std::bind(&CloudDiskDataHandler::HandleCreateConvertErr, cloudDiskHandler, std::placeholders::_1,
1763 std::placeholders::_2));
1764
1765 int32_t res = createConvertor->HandleAttachments(data, *resultSet);
1766 EXPECT_EQ(res, E_PATH);
1767 } catch (...) {
1768 EXPECT_TRUE(false);
1769 GTEST_LOG_(INFO) << "HandleAttachments001 ERROR";
1770 }
1771
1772 GTEST_LOG_(INFO) << "HandleAttachments001 End";
1773 }
1774
1775 /**
1776 * @tc.name: HandleAttachments002
1777 * @tc.desc: Verify the HandleAttachments function
1778 * @tc.type: FUNC
1779 * @tc.require: I6JPKG
1780 */
1781 HWTEST_F(CloudDiskDataConvertorTest, HandleAttachments002, TestSize.Level1)
1782 {
1783 GTEST_LOG_(INFO) << "HandleAttachments002 Begin";
1784 try {
1785 string bundName = "com.ohos.photos";
1786 shared_ptr<CloudDiskDataConvertor> localConvertor =
1787 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1788
1789 DriveKit::DKRecord recordFile;
1790 DriveKit::DKRecordData dataFile;
1791 dataFile.emplace(DK_IS_DIRECTORY, "file");
1792 recordFile.GetRecordData(dataFile);
1793 NativeRdb::ValuesBucket values;
1794 int32_t res = localConvertor->ExtractIsDirectory(dataFile, values);
1795 EXPECT_EQ(res, E_INVAL_ARG);
1796
1797 DriveKit::DKRecord record;
1798 DriveKit::DKRecordData data;
1799 record.GetRecordData(data);
1800 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1801 res = localConvertor->HandleAttachments(data, *resultSet);
1802 EXPECT_EQ(res, E_OK);
1803 } catch (...) {
1804 EXPECT_TRUE(false);
1805 GTEST_LOG_(INFO) << "HandleAttachments002 ERROR";
1806 }
1807
1808 GTEST_LOG_(INFO) << "HandleAttachments002 End";
1809 }
1810
1811 /**
1812 * @tc.name: HandleAttachments003
1813 * @tc.desc: Verify the HandleAttachments function
1814 * @tc.type: FUNC
1815 * @tc.require: I6JPKG
1816 */
1817 HWTEST_F(CloudDiskDataConvertorTest, HandleAttachments003, TestSize.Level1)
1818 {
1819 GTEST_LOG_(INFO) << "HandleAttachments003 Begin";
1820 try {
1821 string bundName = "com.ohos.photos";
1822 shared_ptr<CloudDiskDataConvertor> localConvertor =
1823 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1824
1825 DriveKit::DKRecord recordFile;
1826 DriveKit::DKRecordData dataFile;
1827 dataFile.emplace(DK_IS_DIRECTORY, "dir");
1828 recordFile.GetRecordData(dataFile);
1829 NativeRdb::ValuesBucket values;
1830 int32_t res = localConvertor->ExtractIsDirectory(dataFile, values);
1831 EXPECT_EQ(res, E_INVAL_ARG);
1832
1833 DriveKit::DKRecord record;
1834 DriveKit::DKRecordData data;
1835 record.GetRecordData(data);
1836 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1837 res = localConvertor->HandleAttachments(data, *resultSet);
1838 EXPECT_EQ(res, E_OK);
1839 } catch (...) {
1840 EXPECT_TRUE(false);
1841 GTEST_LOG_(INFO) << "HandleAttachments003 ERROR";
1842 }
1843
1844 GTEST_LOG_(INFO) << "HandleAttachments003 End";
1845 }
1846
1847 /**
1848 * @tc.name: HandleAttachments004
1849 * @tc.desc: Verify the HandleAttachments function
1850 * @tc.type: FUNC
1851 * @tc.require: I6JPKG
1852 */
1853 HWTEST_F(CloudDiskDataConvertorTest, HandleAttachments004, TestSize.Level1)
1854 {
1855 GTEST_LOG_(INFO) << "HandleAttachments004 Begin";
1856 try {
1857 string bundName = "com.ohos.photos";
1858 DriveKit::DKRecordData data;
1859 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1860 shared_ptr<CloudDiskDataConvertor> deleteConvertor =
1861 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DELETE);
1862
1863 int32_t res = deleteConvertor->HandleAttachments(data, *resultSet);
1864 EXPECT_EQ(res, E_OK);
1865 } catch (...) {
1866 EXPECT_TRUE(false);
1867 GTEST_LOG_(INFO) << "HandleAttachments004 ERROR";
1868 }
1869
1870 GTEST_LOG_(INFO) << "HandleAttachments004 End";
1871 }
1872
1873 /**
1874 * @tc.name: HandleContent001
1875 * @tc.desc: Verify the HandleContent function
1876 * @tc.type: FUNC
1877 * @tc.require: I6JPKG
1878 */
1879 HWTEST_F(CloudDiskDataConvertorTest, HandleContent001, TestSize.Level1)
1880 {
1881 GTEST_LOG_(INFO) << "HandleContent001 Begin";
1882 try {
1883 string bundName = "com.ohos.photos";
1884 DriveKit::DKRecord record;
1885 DriveKit::DKRecordData data;
1886 record.GetRecordData(data);
1887 shared_ptr<CloudDiskDataConvertor> localConvertor =
1888 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1889 string filePath;
1890 string cloudId;
1891 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1892 if (!localConvertor->GetString(FileColumn::CLOUD_ID, cloudId, *resultSet)) {
1893 filePath = CloudFileUtils::GetLocalFilePath(cloudId, bundName, USER_ID);
1894 }
1895 EXPECT_FALSE(filePath.empty());
1896
1897 int32_t res = localConvertor->HandleContent(data, filePath);
1898 EXPECT_EQ(res, E_PATH);
1899 } catch (...) {
1900 EXPECT_TRUE(false);
1901 GTEST_LOG_(INFO) << "HandleContent001 ERROR";
1902 }
1903
1904 GTEST_LOG_(INFO) << "HandleContent001 End";
1905 }
1906
1907 /**
1908 * @tc.name: HandleContent002
1909 * @tc.desc: Verify the HandleContent function
1910 * @tc.type: FUNC
1911 * @tc.require: I6JPKG
1912 */
1913 HWTEST_F(CloudDiskDataConvertorTest, HandleContent002, TestSize.Level1)
1914 {
1915 GTEST_LOG_(INFO) << "HandleContent002 Begin";
1916 try {
1917 string bundName = "com.ohos.photos";
1918 DriveKit::DKRecord record;
1919 DriveKit::DKRecordData data;
1920 record.GetRecordData(data);
1921 shared_ptr<CloudDiskDataConvertor> localConvertor =
1922 make_shared<CloudDiskDataConvertor>(USER_ID, bundName, FILE_DOWNLOAD);
1923
1924 DriveKit::DKRecord recordFile;
1925 DriveKit::DKRecordData dataFile;
1926 dataFile.emplace(DK_IS_DIRECTORY, "file");
1927 recordFile.GetRecordData(dataFile);
1928 NativeRdb::ValuesBucket values;
1929 int32_t res = localConvertor->ExtractIsDirectory(dataFile, values);
1930 EXPECT_EQ(res, E_INVAL_ARG);
1931
1932 string filePath;
1933 string cloudId;
1934 unique_ptr<ResultSetMock> resultSet = make_unique<ResultSetMock>();
1935 if (!localConvertor->GetString(FileColumn::CLOUD_ID, cloudId, *resultSet)) {
1936 filePath = CloudFileUtils::GetLocalFilePath(cloudId, bundName, USER_ID);
1937 }
1938 EXPECT_FALSE(filePath.empty());
1939
1940 res = localConvertor->HandleContent(data, filePath);
1941 EXPECT_EQ(res, E_PATH);
1942 } catch (...) {
1943 EXPECT_TRUE(false);
1944 GTEST_LOG_(INFO) << "HandleContent002 ERROR";
1945 }
1946
1947 GTEST_LOG_(INFO) << "HandleContent002 End";
1948 }
1949
1950 } // namespace OHOS::FileManagement::CloudSync::Test