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 /** 17 * @tc.name: CompensateFilePath001 18 * @tc.desc: Verify the CompensateFilePath function 19 * @tc.type: FUNC 20 * @tc.require: issueI7VEA4 21 */ 22 HWTEST_F(FileDataHandlerTest, CompensateFilePath001, TestSize.Level1) 23 { 24 GTEST_LOG_(INFO) << "CompensateFilePath001 Begin"; 25 try { 26 auto rdb = std::make_shared<RdbStoreMock>(); 27 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 28 29 DriveKit::DKRecordData data; 30 DriveKit::DKRecordFieldMap prop; 31 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("123"))); 32 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 33 DriveKit::DKRecord record; 34 record.SetRecordData(data); 35 int32_t ret = fileDataHandler->CompensateFilePath(record); 36 EXPECT_NE(ret, E_OK); 37 } catch (...) { 38 EXPECT_TRUE(false); 39 GTEST_LOG_(INFO) << " CompensateFilePath001 ERROR"; 40 } 41 GTEST_LOG_(INFO) << "CompensateFilePath001 End"; 42 } 43 44 /** 45 * @tc.name: CompensateFilePath002 46 * @tc.desc: Verify the CompensateFilePath function 47 * @tc.type: FUNC 48 * @tc.require: issueI7VEA4 49 */ 50 HWTEST_F(FileDataHandlerTest, CompensateFilePath002, TestSize.Level1) 51 { 52 GTEST_LOG_(INFO) << "CompensateFilePath002 Begin"; 53 try { 54 auto rdb = std::make_shared<RdbStoreMock>(); 55 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 56 57 DriveKit::DKRecord record; 58 int32_t ret = fileDataHandler->CompensateFilePath(record); 59 EXPECT_EQ(ret, E_INVAL_ARG); 60 } catch (...) { 61 EXPECT_TRUE(false); 62 GTEST_LOG_(INFO) << " CompensateFilePath002 ERROR"; 63 } 64 GTEST_LOG_(INFO) << "CompensateFilePath002 End"; 65 } 66 67 /** 68 * @tc.name: CompensateFilePath003 69 * @tc.desc: Verify the CompensateFilePath function 70 * @tc.type: FUNC 71 * @tc.require: issueI7VEA4 72 */ 73 HWTEST_F(FileDataHandlerTest, CompensateFilePath003, TestSize.Level1) 74 { 75 GTEST_LOG_(INFO) << "CompensateFilePath003 Begin"; 76 try { 77 auto rdb = std::make_shared<RdbStoreMock>(); 78 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 79 80 DriveKit::DKRecordData data; 81 DriveKit::DKRecordFieldMap prop; 82 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_SIZE, DriveKit::DKRecordField("123"))); 83 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 84 DriveKit::DKRecord record; 85 record.SetRecordData(data); 86 int32_t ret = fileDataHandler->CompensateFilePath(record); 87 EXPECT_EQ(ret, E_INVAL_ARG); 88 } catch (...) { 89 EXPECT_TRUE(false); 90 GTEST_LOG_(INFO) << " CompensateFilePath003 ERROR"; 91 } 92 GTEST_LOG_(INFO) << "CompensateFilePath003 End"; 93 } 94 95 /** 96 * @tc.name: CompensateFilePath004 97 * @tc.desc: Verify the CompensateFilePath function 98 * @tc.type: FUNC 99 * @tc.require: issueI7VEA4 100 */ 101 HWTEST_F(FileDataHandlerTest, CompensateFilePath004, TestSize.Level1) 102 { 103 GTEST_LOG_(INFO) << "CompensateFilePath004 Begin"; 104 try { 105 auto rdb = std::make_shared<RdbStoreMock>(); 106 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 107 108 DriveKit::DKRecordData data; 109 DriveKit::DKRecordFieldMap prop; 110 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_DATE_MODIFIED, DriveKit::DKRecordField("123"))); 111 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 112 DriveKit::DKRecord record; 113 record.SetRecordData(data); 114 int32_t ret = fileDataHandler->CompensateFilePath(record); 115 EXPECT_EQ(ret, E_INVAL_ARG); 116 } catch (...) { 117 EXPECT_TRUE(false); 118 GTEST_LOG_(INFO) << " CompensateFilePath004 ERROR"; 119 } 120 GTEST_LOG_(INFO) << "CompensateFilePath004 End"; 121 } 122 123 /** 124 * @tc.name: GetMediaType001 125 * @tc.desc: Verify the GetMediaType function 126 * @tc.type: FUNC 127 * @tc.require: issueI7VEA4 128 */ 129 HWTEST_F(FileDataHandlerTest, GetMediaType001, TestSize.Level1) 130 { 131 GTEST_LOG_(INFO) << "GetMediaType001 Begin"; 132 try { 133 auto rdb = std::make_shared<RdbStoreMock>(); 134 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 135 136 DriveKit::DKRecordData data; 137 data.insert(std::make_pair(FILE_FILETYPE, DriveKit::DKRecordField(FILE_TYPE_IMAGE))); 138 DriveKit::DKRecord record; 139 record.SetRecordData(data); 140 int32_t mediaType = 0; 141 int32_t ret = fileDataHandler->GetMediaType(record, mediaType); 142 EXPECT_EQ(ret, E_OK); 143 } catch (...) { 144 EXPECT_TRUE(false); 145 GTEST_LOG_(INFO) << " GetMediaType001 ERROR"; 146 } 147 GTEST_LOG_(INFO) << "GetMediaType001 End"; 148 } 149 150 /** 151 * @tc.name: GetMediaType002 152 * @tc.desc: Verify the GetMediaType function 153 * @tc.type: FUNC 154 * @tc.require: issueI7VEA4 155 */ 156 HWTEST_F(FileDataHandlerTest, GetMediaType002, TestSize.Level1) 157 { 158 GTEST_LOG_(INFO) << "GetMediaType002 Begin"; 159 try { 160 auto rdb = std::make_shared<RdbStoreMock>(); 161 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 162 163 DriveKit::DKRecordData data; 164 data.insert(std::make_pair(FILE_FILETYPE, DriveKit::DKRecordField(MEDIA_TYPE_VIDEO))); 165 DriveKit::DKRecord record; 166 record.SetRecordData(data); 167 int32_t mediaType = 0; 168 int32_t ret = fileDataHandler->GetMediaType(record, mediaType); 169 EXPECT_EQ(ret, E_OK); 170 } catch (...) { 171 EXPECT_TRUE(false); 172 GTEST_LOG_(INFO) << " GetMediaType002 ERROR"; 173 } 174 GTEST_LOG_(INFO) << "GetMediaType002 End"; 175 } 176 177 /** 178 * @tc.name: GetMediaType003 179 * @tc.desc: Verify the GetMediaType function 180 * @tc.type: FUNC 181 * @tc.require: issueI7VEA4 182 */ 183 HWTEST_F(FileDataHandlerTest, GetMediaType003, TestSize.Level1) 184 { 185 GTEST_LOG_(INFO) << "GetMediaType003 Begin"; 186 try { 187 auto rdb = std::make_shared<RdbStoreMock>(); 188 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 189 190 int32_t mediaType = 0; 191 DriveKit::DKRecord record; 192 int32_t ret = fileDataHandler->GetMediaType(record, mediaType); 193 EXPECT_EQ(ret, E_INVAL_ARG); 194 } catch (...) { 195 EXPECT_TRUE(false); 196 GTEST_LOG_(INFO) << " GetMediaType003 ERROR"; 197 } 198 GTEST_LOG_(INFO) << "GetMediaType003 End"; 199 } 200 201 /** 202 * @tc.name: GetMediaType004 203 * @tc.desc: Verify the GetMediaType function 204 * @tc.type: FUNC 205 * @tc.require: issueI7VEA4 206 */ 207 HWTEST_F(FileDataHandlerTest, GetMediaType004, TestSize.Level1) 208 { 209 GTEST_LOG_(INFO) << "GetMediaType004 Begin"; 210 try { 211 auto rdb = std::make_shared<RdbStoreMock>(); 212 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 213 214 DriveKit::DKRecordData data; 215 data.insert(std::make_pair(FILE_FILETYPE, DriveKit::DKRecordField("abc"))); 216 int32_t mediaType = 0; 217 DriveKit::DKRecord record; 218 record.SetRecordData(data); 219 int32_t ret = fileDataHandler->GetMediaType(record, mediaType); 220 EXPECT_EQ(ret, E_INVAL_ARG); 221 } catch (...) { 222 EXPECT_TRUE(false); 223 GTEST_LOG_(INFO) << " GetMediaType004 ERROR"; 224 } 225 GTEST_LOG_(INFO) << "GetMediaType004 End"; 226 } 227 228 /** 229 * @tc.name: GetAssetUniqueId001 230 * @tc.desc: Verify the GetAssetUniqueId function 231 * @tc.type: FUNC 232 * @tc.require: issueI7VEA4 233 */ 234 HWTEST_F(FileDataHandlerTest, GetAssetUniqueId001, TestSize.Level1) 235 { 236 GTEST_LOG_(INFO) << "GetAssetUniqueId001 Begin"; 237 try { 238 auto rdb = std::make_shared<RdbStoreMock>(); 239 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 240 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 241 242 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)); 243 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 244 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(0)); 245 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))); 246 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(0)); 247 248 int32_t mediaType = static_cast<int>(MediaType::MEDIA_TYPE_IMAGE); 249 int32_t ret = fileDataHandler->GetAssetUniqueId(mediaType); 250 EXPECT_EQ(ret, 1); 251 } catch (...) { 252 EXPECT_TRUE(false); 253 GTEST_LOG_(INFO) << " GetAssetUniqueId001 ERROR"; 254 } 255 GTEST_LOG_(INFO) << "GetAssetUniqueId001 End"; 256 } 257 258 /** 259 * @tc.name: GetAssetUniqueId002 260 * @tc.desc: Verify the GetAssetUniqueId function 261 * @tc.type: FUNC 262 * @tc.require: issueI7VEA4 263 */ 264 HWTEST_F(FileDataHandlerTest, GetAssetUniqueId002, TestSize.Level1) 265 { 266 GTEST_LOG_(INFO) << "GetAssetUniqueId002 Begin"; 267 try { 268 auto rdb = std::make_shared<RdbStoreMock>(); 269 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 270 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 271 272 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)); 273 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 274 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(0)); 275 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))); 276 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(0)); 277 278 int32_t mediaType = static_cast<int>(MediaType::MEDIA_TYPE_VIDEO); 279 int32_t ret = fileDataHandler->GetAssetUniqueId(mediaType); 280 EXPECT_EQ(ret, 1); 281 } catch (...) { 282 EXPECT_TRUE(false); 283 GTEST_LOG_(INFO) << " GetAssetUniqueId002 ERROR"; 284 } 285 GTEST_LOG_(INFO) << "GetAssetUniqueId002 End"; 286 } 287 288 /** 289 * @tc.name: GetAssetUniqueId003 290 * @tc.desc: Verify the GetAssetUniqueId function 291 * @tc.type: FUNC 292 * @tc.require: issueI7VEA4 293 */ 294 HWTEST_F(FileDataHandlerTest, GetAssetUniqueId003, TestSize.Level1) 295 { 296 GTEST_LOG_(INFO) << "GetAssetUniqueId003 Begin"; 297 try { 298 auto rdb = std::make_shared<RdbStoreMock>(); 299 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 300 301 int32_t mediaType = static_cast<int>(MediaType::MEDIA_TYPE_FILE); 302 int32_t ret = fileDataHandler->GetAssetUniqueId(mediaType); 303 EXPECT_EQ(ret, MediaType::MEDIA_TYPE_FILE); 304 } catch (...) { 305 EXPECT_TRUE(false); 306 GTEST_LOG_(INFO) << " GetAssetUniqueId003 ERROR"; 307 } 308 GTEST_LOG_(INFO) << "GetAssetUniqueId003 End"; 309 } 310 311 /** 312 * @tc.name: GetAssetUniqueId004 313 * @tc.desc: Verify the GetAssetUniqueId function 314 * @tc.type: FUNC 315 * @tc.require: issueI7VEA4 316 */ 317 HWTEST_F(FileDataHandlerTest, GetAssetUniqueId004, TestSize.Level1) 318 { 319 GTEST_LOG_(INFO) << "GetAssetUniqueId004 Begin"; 320 try { 321 auto rdb = std::make_shared<RdbStoreMock>(); 322 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 323 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 324 325 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(1)); 326 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))); 327 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(0)); 328 329 int32_t mediaType = static_cast<int>(MediaType::MEDIA_TYPE_IMAGE); 330 int32_t ret = fileDataHandler->GetAssetUniqueId(mediaType); 331 EXPECT_EQ(ret, 1); 332 } catch (...) { 333 EXPECT_TRUE(false); 334 GTEST_LOG_(INFO) << " GetAssetUniqueId004 ERROR"; 335 } 336 GTEST_LOG_(INFO) << "GetAssetUniqueId004 End"; 337 } 338 339 /** 340 * @tc.name: CreateAssetPathById001 341 * @tc.desc: Verify the CreateAssetPathById function 342 * @tc.type: FUNC 343 * @tc.require: issueI7VEA4 344 */ 345 HWTEST_F(FileDataHandlerTest, CreateAssetPathById001, TestSize.Level1) 346 { 347 GTEST_LOG_(INFO) << "CreateAssetPathById001 Begin"; 348 try { 349 auto rdb = std::make_shared<RdbStoreMock>(); 350 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 351 352 int32_t uniqueId = 0; 353 std::string filePath = ""; 354 DriveKit::DKRecord record; 355 int32_t mediaType = static_cast<int>(MediaType::MEDIA_TYPE_IMAGE); 356 int32_t ret = fileDataHandler->CreateAssetPathById(record, uniqueId, mediaType, filePath); 357 EXPECT_EQ(ret, E_OK); 358 } catch (...) { 359 EXPECT_TRUE(false); 360 GTEST_LOG_(INFO) << " CreateAssetPathById001 ERROR"; 361 } 362 GTEST_LOG_(INFO) << "CreateAssetPathById001 End"; 363 } 364 365 /** 366 * @tc.name: CreateAssetPathById002 367 * @tc.desc: Verify the CreateAssetPathById function 368 * @tc.type: FUNC 369 * @tc.require: issueI7VEA4 370 */ 371 HWTEST_F(FileDataHandlerTest, CreateAssetPathById002, TestSize.Level1) 372 { 373 GTEST_LOG_(INFO) << "CreateAssetPathById002 Begin"; 374 try { 375 auto rdb = std::make_shared<RdbStoreMock>(); 376 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 377 378 int32_t uniqueId = -1; 379 std::string filePath = ""; 380 DriveKit::DKRecord record; 381 int32_t mediaType = static_cast<int>(MediaType::MEDIA_TYPE_IMAGE); 382 int32_t ret = fileDataHandler->CreateAssetPathById(record, uniqueId, mediaType, filePath); 383 EXPECT_EQ(ret, E_INVAL_ARG); 384 } catch (...) { 385 EXPECT_TRUE(false); 386 GTEST_LOG_(INFO) << " CreateAssetPathById002 ERROR"; 387 } 388 GTEST_LOG_(INFO) << "CreateAssetPathById002 End"; 389 } 390 391 /** 392 * @tc.name: CreateAssetPathById003 393 * @tc.desc: Verify the CreateAssetPathById function 394 * @tc.type: FUNC 395 * @tc.require: issueI7VEA4 396 */ 397 HWTEST_F(FileDataHandlerTest, CreateAssetPathById003, TestSize.Level1) 398 { 399 GTEST_LOG_(INFO) << "CreateAssetPathById003 Begin"; 400 try { 401 auto rdb = std::make_shared<RdbStoreMock>(); 402 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 403 404 int32_t uniqueId = 0; 405 std::string filePath = ""; 406 DriveKit::DKRecord record; 407 int32_t mediaType = static_cast<int>(MediaType::MEDIA_TYPE_FILE); 408 int32_t ret = fileDataHandler->CreateAssetPathById(record, uniqueId, mediaType, filePath); 409 EXPECT_EQ(ret, E_INVAL_ARG); 410 } catch (...) { 411 EXPECT_TRUE(false); 412 GTEST_LOG_(INFO) << " CreateAssetPathById003 ERROR"; 413 } 414 GTEST_LOG_(INFO) << "CreateAssetPathById003 End"; 415 } 416 417 /** 418 * @tc.name: CreateAssetBucket001 419 * @tc.desc: Verify the CreateAssetBucket function 420 * @tc.type: FUNC 421 * @tc.require: issueI7VEA4 422 */ 423 HWTEST_F(FileDataHandlerTest, CreateAssetBucket001, TestSize.Level1) 424 { 425 GTEST_LOG_(INFO) << "CreateAssetBucket001 Begin"; 426 try { 427 auto rdb = std::make_shared<RdbStoreMock>(); 428 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 429 430 int32_t uniqueId = 0; 431 int32_t bucketNum = 0; 432 int32_t ret = fileDataHandler->CreateAssetBucket(uniqueId, bucketNum); 433 EXPECT_EQ(ret, E_OK); 434 } catch (...) { 435 EXPECT_TRUE(false); 436 GTEST_LOG_(INFO) << " CreateAssetBucket001 ERROR"; 437 } 438 GTEST_LOG_(INFO) << "CreateAssetBucket001 End"; 439 } 440 441 /** 442 * @tc.name: CreateAssetBucket002 443 * @tc.desc: Verify the CreateAssetBucket function 444 * @tc.type: FUNC 445 * @tc.require: issueI7VEA4 446 */ 447 HWTEST_F(FileDataHandlerTest, CreateAssetBucket002, TestSize.Level1) 448 { 449 GTEST_LOG_(INFO) << "CreateAssetBucket002 Begin"; 450 try { 451 auto rdb = std::make_shared<RdbStoreMock>(); 452 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 453 454 int32_t uniqueId = -1; 455 int32_t bucketNum = 0; 456 int32_t ret = fileDataHandler->CreateAssetBucket(uniqueId, bucketNum); 457 EXPECT_EQ(ret, E_INVAL_ARG); 458 } catch (...) { 459 EXPECT_TRUE(false); 460 GTEST_LOG_(INFO) << " CreateAssetBucket002 ERROR"; 461 } 462 GTEST_LOG_(INFO) << "CreateAssetBucket002 End"; 463 } 464 465 /** 466 * @tc.name: CreateAssetBucket003 467 * @tc.desc: Verify the CreateAssetBucket function 468 * @tc.type: FUNC 469 * @tc.require: issueI7VEA4 470 */ 471 HWTEST_F(FileDataHandlerTest, CreateAssetBucket003, TestSize.Level1) 472 { 473 GTEST_LOG_(INFO) << "CreateAssetBucket003 Begin"; 474 try { 475 auto rdb = std::make_shared<RdbStoreMock>(); 476 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 477 478 int32_t uniqueId = 1; 479 int32_t bucketNum = 0; 480 int32_t ret = fileDataHandler->CreateAssetBucket(uniqueId, bucketNum); 481 EXPECT_EQ(ret, E_OK); 482 } catch (...) { 483 EXPECT_TRUE(false); 484 GTEST_LOG_(INFO) << " CreateAssetBucket003 ERROR"; 485 } 486 GTEST_LOG_(INFO) << "CreateAssetBucket003 End"; 487 } 488 489 /** 490 * @tc.name: OnDownloadAssets001 491 * @tc.desc: Verify the OnDownloadAssets function 492 * @tc.type: FUNC 493 * @tc.require: issueI7VEA4 494 */ 495 HWTEST_F(FileDataHandlerTest, OnDownloadAssets001, TestSize.Level1) 496 { 497 GTEST_LOG_(INFO) << "OnDownloadAssets001 Begin"; 498 try { 499 auto rdb = std::make_shared<RdbStoreMock>(); 500 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 501 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(0)); 502 503 DriveKit::DKDownloadAsset asset; 504 asset.fieldKey = "thumbnail"; 505 fileDataHandler->OnDownloadAssets(asset); 506 EXPECT_TRUE(false); 507 } catch (...) { 508 EXPECT_TRUE(true); 509 GTEST_LOG_(INFO) << " OnDownloadAssets001 ERROR"; 510 } 511 GTEST_LOG_(INFO) << "OnDownloadAssets001 End"; 512 } 513 514 /** 515 * @tc.name: OnDownloadAssets002 516 * @tc.desc: Verify the OnDownloadAssets function 517 * @tc.type: FUNC 518 * @tc.require: issueI7VEA4 519 */ 520 HWTEST_F(FileDataHandlerTest, OnDownloadAssets002, TestSize.Level1) 521 { 522 GTEST_LOG_(INFO) << "OnDownloadAssets002 Begin"; 523 try { 524 auto rdb = std::make_shared<RdbStoreMock>(); 525 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 526 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillOnce(Return(1)); 527 528 DriveKit::DKDownloadAsset asset; 529 asset.fieldKey = "thumbnail"; 530 fileDataHandler->OnDownloadAssets(asset); 531 EXPECT_TRUE(false); 532 } catch (...) { 533 EXPECT_TRUE(true); 534 GTEST_LOG_(INFO) << " OnDownloadAssets002 ERROR"; 535 } 536 GTEST_LOG_(INFO) << "OnDownloadAssets002 End"; 537 } 538 539 /** 540 * @tc.name: OnDownloadAssets003 541 * @tc.desc: Verify the OnDownloadAssets function 542 * @tc.type: FUNC 543 * @tc.require: issueI7VEA4 544 */ 545 HWTEST_F(FileDataHandlerTest, OnDownloadAssets003, TestSize.Level1) 546 { 547 GTEST_LOG_(INFO) << "OnDownloadAssets003 Begin"; 548 try { 549 auto rdb = std::make_shared<RdbStoreMock>(); 550 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 551 552 DriveKit::DKDownloadAsset asset; 553 fileDataHandler->OnDownloadAssets(asset); 554 EXPECT_TRUE(false); 555 } catch (...) { 556 EXPECT_TRUE(true); 557 GTEST_LOG_(INFO) << " OnDownloadAssets003 ERROR"; 558 } 559 GTEST_LOG_(INFO) << "OnDownloadAssets003 End"; 560 } 561 562 /** 563 * @tc.name: GetFileExtension001 564 * @tc.desc: Verify the GetFileExtension function 565 * @tc.type: FUNC 566 * @tc.require: issueI7VPAH 567 */ 568 HWTEST_F(FileDataHandlerTest, GetFileExtension001, TestSize.Level1) 569 { 570 GTEST_LOG_(INFO) << "GetFileExtension001 Begin"; 571 try { 572 auto rdb = std::make_shared<RdbStoreMock>(); 573 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 574 575 DriveKit::DKRecordData data; 576 data.insert(std::make_pair(FILE_FILE_NAME, DriveKit::DKRecordField("test.txt"))); 577 DriveKit::DKRecord record; 578 record.SetRecordData(data); 579 string ret = fileDataHandler->GetFileExtension(record); 580 EXPECT_EQ(ret, "txt"); 581 } catch (...) { 582 EXPECT_TRUE(false); 583 GTEST_LOG_(INFO) << " GetFileExtension001 ERROR"; 584 } 585 GTEST_LOG_(INFO) << "GetFileExtension001 End"; 586 } 587 588 /** 589 * @tc.name: GetFileExtension002 590 * @tc.desc: Verify the GetFileExtension function 591 * @tc.type: FUNC 592 * @tc.require: issueI7VPAH 593 */ 594 HWTEST_F(FileDataHandlerTest, GetFileExtension002, TestSize.Level1) 595 { 596 GTEST_LOG_(INFO) << "GetFileExtension002 Begin"; 597 try { 598 auto rdb = std::make_shared<RdbStoreMock>(); 599 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 600 601 DriveKit::DKRecord record; 602 string ret = fileDataHandler->GetFileExtension(record); 603 EXPECT_EQ(ret, ""); 604 } catch (...) { 605 EXPECT_TRUE(false); 606 GTEST_LOG_(INFO) << " GetFileExtension002 ERROR"; 607 } 608 GTEST_LOG_(INFO) << "GetFileExtension002 End"; 609 } 610 611 /** 612 * @tc.name: GetFileExtension003 613 * @tc.desc: Verify the GetFileExtension function 614 * @tc.type: FUNC 615 * @tc.require: issueI7VPAH 616 */ 617 HWTEST_F(FileDataHandlerTest, GetFileExtension003, TestSize.Level1) 618 { 619 GTEST_LOG_(INFO) << "GetFileExtension003 Begin"; 620 try { 621 auto rdb = std::make_shared<RdbStoreMock>(); 622 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 623 624 DriveKit::DKRecordData data; 625 data.insert(std::make_pair(FILE_FILE_NAME, DriveKit::DKRecordField(1))); 626 DriveKit::DKRecord record; 627 record.SetRecordData(data); 628 string ret = fileDataHandler->GetFileExtension(record); 629 EXPECT_EQ(ret, ""); 630 } catch (...) { 631 EXPECT_TRUE(false); 632 GTEST_LOG_(INFO) << " GetFileExtension003 ERROR"; 633 } 634 GTEST_LOG_(INFO) << "GetFileExtension003 End"; 635 } 636 637 /** 638 * @tc.name: GetFileExtension004 639 * @tc.desc: Verify the GetFileExtension function 640 * @tc.type: FUNC 641 * @tc.require: issueI7VPAH 642 */ 643 HWTEST_F(FileDataHandlerTest, GetFileExtension004, TestSize.Level1) 644 { 645 GTEST_LOG_(INFO) << "GetFileExtension004 Begin"; 646 try { 647 auto rdb = std::make_shared<RdbStoreMock>(); 648 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 649 650 DriveKit::DKRecordData data; 651 data.insert(std::make_pair(FILE_FILE_NAME, DriveKit::DKRecordField(""))); 652 DriveKit::DKRecord record; 653 record.SetRecordData(data); 654 string ret = fileDataHandler->GetFileExtension(record); 655 EXPECT_EQ(ret, ""); 656 } catch (...) { 657 EXPECT_TRUE(false); 658 GTEST_LOG_(INFO) << " GetFileExtension004 ERROR"; 659 } 660 GTEST_LOG_(INFO) << "GetFileExtension004 End"; 661 } 662 663 /** 664 * @tc.name: GetFileExtension005 665 * @tc.desc: Verify the GetFileExtension function 666 * @tc.type: FUNC 667 * @tc.require: issueI7VPAH 668 */ 669 HWTEST_F(FileDataHandlerTest, GetFileExtension005, TestSize.Level1) 670 { 671 GTEST_LOG_(INFO) << "GetFileExtension005 Begin"; 672 try { 673 auto rdb = std::make_shared<RdbStoreMock>(); 674 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 675 676 DriveKit::DKRecordData data; 677 data.insert(std::make_pair(FILE_FILE_NAME, DriveKit::DKRecordField("text"))); 678 DriveKit::DKRecord record; 679 record.SetRecordData(data); 680 string ret = fileDataHandler->GetFileExtension(record); 681 EXPECT_EQ(ret, ""); 682 } catch (...) { 683 EXPECT_TRUE(false); 684 GTEST_LOG_(INFO) << " GetFileExtension005 ERROR"; 685 } 686 GTEST_LOG_(INFO) << "GetFileExtension005 End"; 687 } 688 689 /** 690 * @tc.name: CreateAssetRealName001 691 * @tc.desc: Verify the CreateAssetRealName function 692 * @tc.type: FUNC 693 * @tc.require: issueI7VPAH 694 */ 695 HWTEST_F(FileDataHandlerTest, CreateAssetRealName001, TestSize.Level1) 696 { 697 GTEST_LOG_(INFO) << "CreateAssetRealName001 Begin"; 698 try { 699 auto rdb = std::make_shared<RdbStoreMock>(); 700 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 701 702 int32_t fileId = 1; 703 int32_t mediaType = static_cast<int32_t>(MediaType::MEDIA_TYPE_IMAGE); 704 string extension = "txt"; 705 string name = ""; 706 int32_t ret = fileDataHandler->CreateAssetRealName(fileId, mediaType, extension, name); 707 EXPECT_EQ(ret, E_OK); 708 } catch (...) { 709 EXPECT_TRUE(false); 710 GTEST_LOG_(INFO) << " CreateAssetRealName001 ERROR"; 711 } 712 GTEST_LOG_(INFO) << "CreateAssetRealName001 End"; 713 } 714 715 /** 716 * @tc.name: CreateAssetRealName002 717 * @tc.desc: Verify the CreateAssetRealName function 718 * @tc.type: FUNC 719 * @tc.require: issueI7VPAH 720 */ 721 HWTEST_F(FileDataHandlerTest, CreateAssetRealName002, TestSize.Level1) 722 { 723 GTEST_LOG_(INFO) << "CreateAssetRealName002 Begin"; 724 try { 725 auto rdb = std::make_shared<RdbStoreMock>(); 726 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 727 728 int32_t fileId = ASSET_MAX_COMPLEMENT_ID + 1; 729 int32_t mediaType = static_cast<int32_t>(MediaType::MEDIA_TYPE_IMAGE); 730 string extension = "txt"; 731 string name = ""; 732 int32_t ret = fileDataHandler->CreateAssetRealName(fileId, mediaType, extension, name); 733 EXPECT_EQ(ret, E_OK); 734 } catch (...) { 735 EXPECT_TRUE(false); 736 GTEST_LOG_(INFO) << " CreateAssetRealName002 ERROR"; 737 } 738 GTEST_LOG_(INFO) << "CreateAssetRealName002 End"; 739 } 740 741 /** 742 * @tc.name: CreateAssetRealName003 743 * @tc.desc: Verify the CreateAssetRealName function 744 * @tc.type: FUNC 745 * @tc.require: issueI7VPAH 746 */ 747 HWTEST_F(FileDataHandlerTest, CreateAssetRealName003, TestSize.Level1) 748 { 749 GTEST_LOG_(INFO) << "CreateAssetRealName003 Begin"; 750 try { 751 auto rdb = std::make_shared<RdbStoreMock>(); 752 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 753 754 int32_t fileId = 1; 755 int32_t mediaType = static_cast<int32_t>(MediaType::MEDIA_TYPE_VIDEO); 756 string extension = "txt"; 757 string name = ""; 758 int32_t ret = fileDataHandler->CreateAssetRealName(fileId, mediaType, extension, name); 759 EXPECT_EQ(ret, E_OK); 760 } catch (...) { 761 EXPECT_TRUE(false); 762 GTEST_LOG_(INFO) << " CreateAssetRealName003 ERROR"; 763 } 764 GTEST_LOG_(INFO) << "CreateAssetRealName003 End"; 765 } 766 767 /** 768 * @tc.name: CreateAssetRealName004 769 * @tc.desc: Verify the CreateAssetRealName function 770 * @tc.type: FUNC 771 * @tc.require: issueI7VPAH 772 */ 773 HWTEST_F(FileDataHandlerTest, CreateAssetRealName004, TestSize.Level1) 774 { 775 GTEST_LOG_(INFO) << "CreateAssetRealName004 Begin"; 776 try { 777 auto rdb = std::make_shared<RdbStoreMock>(); 778 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 779 780 int32_t fileId = 1; 781 int32_t mediaType = static_cast<int32_t>(MediaType::MEDIA_TYPE_AUDIO); 782 string extension = "txt"; 783 string name = ""; 784 int32_t ret = fileDataHandler->CreateAssetRealName(fileId, mediaType, extension, name); 785 EXPECT_EQ(ret, E_INVAL_ARG); 786 } catch (...) { 787 EXPECT_TRUE(false); 788 GTEST_LOG_(INFO) << " CreateAssetRealName004 ERROR"; 789 } 790 GTEST_LOG_(INFO) << "CreateAssetRealName004 End"; 791 } 792 793 /** 794 * @tc.name: BindAlbums001 795 * @tc.desc: Verify the BindAlbums function 796 * @tc.type: FUNC 797 * @tc.require: issueI7VPAH 798 */ 799 HWTEST_F(FileDataHandlerTest, BindAlbums001, TestSize.Level1) 800 { 801 GTEST_LOG_(INFO) << "BindAlbums001 Begin"; 802 try { 803 auto rdb = std::make_shared<RdbStoreMock>(); 804 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 805 std::unique_ptr<AbsSharedResultSetMock> rset1 = std::make_unique<AbsSharedResultSetMock>(); 806 std::unique_ptr<AbsSharedResultSetMock> rset2 = std::make_unique<AbsSharedResultSetMock>(); 807 EXPECT_CALL(*rset1, GoToNextRow()).WillOnce(Return(0)).WillOnce(Return(1)); 808 EXPECT_CALL(*rset2, GoToNextRow()).WillOnce(Return(0)); 809 EXPECT_CALL(*rset1, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 810 EXPECT_CALL(*rset2, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 811 EXPECT_CALL(*rset1, GetString(_, _)).WillRepeatedly(Return(0)); 812 EXPECT_CALL(*rset1, GetInt(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(1), Return(0))); 813 EXPECT_CALL(*rset2, GetString(_, _)).WillRepeatedly(Return(0)); 814 EXPECT_CALL(*rdb, Query(_, _)) 815 .WillOnce(Return(ByMove(std::move(rset1)))) 816 .WillOnce(Return(ByMove(std::move(rset2)))); 817 818 DKRecordData data; 819 DriveKit::DKRecordFieldMap prop; 820 prop.insert(std::make_pair(Media::MediaColumn::MEDIA_ID, DriveKit::DKRecordField(1))); 821 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 822 DriveKit::DKRecord record; 823 record.SetRecordData(data); 824 std::vector<DriveKit::DKRecord> records; 825 records.push_back(record); 826 int32_t ret = fileDataHandler->BindAlbums(records); 827 EXPECT_EQ(ret, E_OK); 828 } catch (...) { 829 EXPECT_TRUE(false); 830 GTEST_LOG_(INFO) << " BindAlbums001 ERROR"; 831 } 832 GTEST_LOG_(INFO) << "BindAlbums001 End"; 833 } 834 835 /** 836 * @tc.name: BindAlbums002 837 * @tc.desc: Verify the BindAlbums function 838 * @tc.type: FUNC 839 * @tc.require: issueI7VPAH 840 */ 841 HWTEST_F(FileDataHandlerTest, BindAlbums002, TestSize.Level1) 842 { 843 GTEST_LOG_(INFO) << "BindAlbums002 Begin"; 844 try { 845 auto rdb = std::make_shared<RdbStoreMock>(); 846 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 847 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr))); 848 849 DKRecordData data; 850 DriveKit::DKRecordFieldMap prop; 851 prop.insert(std::make_pair(Media::MediaColumn::MEDIA_ID, DriveKit::DKRecordField(1))); 852 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 853 DriveKit::DKRecord record; 854 record.SetRecordData(data); 855 std::vector<DriveKit::DKRecord> records; 856 records.push_back(record); 857 int32_t ret = fileDataHandler->BindAlbums(records); 858 EXPECT_EQ(ret, E_RDB); 859 } catch (...) { 860 EXPECT_TRUE(false); 861 GTEST_LOG_(INFO) << " BindAlbums002 ERROR"; 862 } 863 GTEST_LOG_(INFO) << "BindAlbums002 End"; 864 } 865 866 /** 867 * @tc.name: BindAlbums003 868 * @tc.desc: Verify the BindAlbums function 869 * @tc.type: FUNC 870 * @tc.require: issueI7VPAH 871 */ 872 HWTEST_F(FileDataHandlerTest, BindAlbums003, TestSize.Level1) 873 { 874 GTEST_LOG_(INFO) << "BindAlbums003 Begin"; 875 try { 876 auto rdb = std::make_shared<RdbStoreMock>(); 877 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 878 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 879 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)); 880 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 881 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(1)); 882 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))); 883 884 DKRecordData data; 885 DriveKit::DKRecordFieldMap prop; 886 prop.insert(std::make_pair(Media::MediaColumn::MEDIA_ID, DriveKit::DKRecordField(1))); 887 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 888 DriveKit::DKRecord record; 889 record.SetRecordData(data); 890 std::vector<DriveKit::DKRecord> records; 891 records.push_back(record); 892 int32_t ret = fileDataHandler->BindAlbums(records); 893 EXPECT_EQ(ret, E_RDB); 894 } catch (...) { 895 EXPECT_TRUE(false); 896 GTEST_LOG_(INFO) << " BindAlbums003 ERROR"; 897 } 898 GTEST_LOG_(INFO) << "BindAlbums003 End"; 899 } 900 901 /** 902 * @tc.name: BindAlbums004 903 * @tc.desc: Verify the BindAlbums function 904 * @tc.type: FUNC 905 * @tc.require: issueI7VPAH 906 */ 907 HWTEST_F(FileDataHandlerTest, BindAlbums004, TestSize.Level1) 908 { 909 GTEST_LOG_(INFO) << "BindAlbums004 Begin"; 910 try { 911 auto rdb = std::make_shared<RdbStoreMock>(); 912 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 913 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 914 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)).WillOnce(Return(1)); 915 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 916 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(1), Return(0))); 917 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))).WillOnce(Return(ByMove(nullptr))); 918 919 DKRecordData data; 920 DriveKit::DKRecordFieldMap prop; 921 prop.insert(std::make_pair(Media::MediaColumn::MEDIA_ID, DriveKit::DKRecordField(1))); 922 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 923 DriveKit::DKRecord record; 924 record.SetRecordData(data); 925 std::vector<DriveKit::DKRecord> records; 926 records.push_back(record); 927 int32_t ret = fileDataHandler->BindAlbums(records); 928 EXPECT_EQ(ret, E_RDB); 929 } catch (...) { 930 EXPECT_TRUE(false); 931 GTEST_LOG_(INFO) << " BindAlbums004 ERROR"; 932 } 933 GTEST_LOG_(INFO) << "BindAlbums004 End"; 934 } 935 936 /** 937 * @tc.name: BindAlbumChanges001 938 * @tc.desc: Verify the BindAlbumChanges function 939 * @tc.type: FUNC 940 * @tc.require: issueI7VPAH 941 */ 942 HWTEST_F(FileDataHandlerTest, BindAlbumChanges001, TestSize.Level1) 943 { 944 GTEST_LOG_(INFO) << "BindAlbumChanges001 Begin"; 945 try { 946 auto rdb = std::make_shared<RdbStoreMock>(); 947 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 948 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 949 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(1)); 950 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 951 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0)); 952 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))); 953 954 DKRecordData data; 955 DriveKit::DKRecordFieldMap prop; 956 prop.insert(std::make_pair(Media::MediaColumn::MEDIA_ID, DriveKit::DKRecordField(1))); 957 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 958 DriveKit::DKRecord record; 959 record.SetRecordData(data); 960 std::vector<DriveKit::DKRecord> records; 961 records.push_back(record); 962 int32_t ret = fileDataHandler->BindAlbumChanges(records); 963 EXPECT_EQ(ret, E_OK); 964 } catch (...) { 965 EXPECT_TRUE(false); 966 GTEST_LOG_(INFO) << " BindAlbumChanges001 ERROR"; 967 } 968 GTEST_LOG_(INFO) << "BindAlbumChanges001 End"; 969 } 970 971 /** 972 * @tc.name: BindAlbumChanges002 973 * @tc.desc: Verify the BindAlbumChanges function 974 * @tc.type: FUNC 975 * @tc.require: issueI7Y6UO 976 */ 977 HWTEST_F(FileDataHandlerTest, BindAlbumChanges002, TestSize.Level1) 978 { 979 GTEST_LOG_(INFO) << "BindAlbumChanges002 Begin"; 980 try { 981 auto rdb = std::make_shared<RdbStoreMock>(); 982 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 983 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(nullptr))); 984 985 DKRecordData data; 986 DriveKit::DKRecordFieldMap prop; 987 prop.insert(std::make_pair(Media::MediaColumn::MEDIA_ID, DriveKit::DKRecordField(1))); 988 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 989 DriveKit::DKRecord record; 990 record.SetRecordData(data); 991 std::vector<DriveKit::DKRecord> records; 992 records.push_back(record); 993 int32_t ret = fileDataHandler->BindAlbumChanges(records); 994 EXPECT_EQ(ret, E_RDB); 995 } catch (...) { 996 EXPECT_TRUE(false); 997 GTEST_LOG_(INFO) << " BindAlbumChanges002 ERROR"; 998 } 999 GTEST_LOG_(INFO) << "BindAlbumChanges002 End"; 1000 } 1001 1002 /** 1003 * @tc.name: BindAlbumChanges003 1004 * @tc.desc: Verify the BindAlbumChanges function 1005 * @tc.type: FUNC 1006 * @tc.require: issueI7Y6UO 1007 */ 1008 HWTEST_F(FileDataHandlerTest, BindAlbumChanges003, TestSize.Level1) 1009 { 1010 GTEST_LOG_(INFO) << "BindAlbumChanges003 Begin"; 1011 try { 1012 auto rdb = std::make_shared<RdbStoreMock>(); 1013 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1014 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 1015 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)); 1016 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 1017 EXPECT_CALL(*rset, GetInt(_, _)).WillRepeatedly(Return(1)); 1018 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))); 1019 1020 DKRecordData data; 1021 DriveKit::DKRecordFieldMap prop; 1022 prop.insert(std::make_pair(Media::MediaColumn::MEDIA_ID, DriveKit::DKRecordField(1))); 1023 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1024 DriveKit::DKRecord record; 1025 record.SetRecordData(data); 1026 std::vector<DriveKit::DKRecord> records; 1027 records.push_back(record); 1028 int32_t ret = fileDataHandler->BindAlbumChanges(records); 1029 EXPECT_EQ(ret, E_RDB); 1030 } catch (...) { 1031 EXPECT_TRUE(false); 1032 GTEST_LOG_(INFO) << " BindAlbumChanges003 ERROR"; 1033 } 1034 GTEST_LOG_(INFO) << "BindAlbumChanges003 End"; 1035 } 1036 1037 /** 1038 * @tc.name: BindAlbumChanges004 1039 * @tc.desc: Verify the BindAlbumChanges function 1040 * @tc.type: FUNC 1041 * @tc.require: issueI7Y6UO 1042 */ 1043 HWTEST_F(FileDataHandlerTest, BindAlbumChanges004, TestSize.Level1) 1044 { 1045 GTEST_LOG_(INFO) << "BindAlbumChanges004 Begin"; 1046 try { 1047 int type = static_cast<int32_t>(Media::DirtyType::TYPE_NEW); 1048 auto rdb = std::make_shared<RdbStoreMock>(); 1049 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1050 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 1051 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)).WillOnce(Return(1)); 1052 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 1053 EXPECT_CALL(*rset, GetInt(_, _)) 1054 .WillOnce(DoAll(SetArgReferee<1>(1), Return(0))) 1055 .WillOnce(DoAll(SetArgReferee<1>(type), Return(0))); 1056 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))).WillOnce(Return(ByMove(nullptr))); 1057 1058 DKRecordData data; 1059 DriveKit::DKRecordFieldMap prop; 1060 prop.insert(std::make_pair(Media::MediaColumn::MEDIA_ID, DriveKit::DKRecordField(1))); 1061 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1062 DriveKit::DKRecord record; 1063 record.SetRecordData(data); 1064 std::vector<DriveKit::DKRecord> records; 1065 records.push_back(record); 1066 int32_t ret = fileDataHandler->BindAlbumChanges(records); 1067 EXPECT_EQ(ret, E_RDB); 1068 } catch (...) { 1069 EXPECT_TRUE(false); 1070 GTEST_LOG_(INFO) << " BindAlbumChanges004 ERROR"; 1071 } 1072 GTEST_LOG_(INFO) << "BindAlbumChanges004 End"; 1073 } 1074 1075 /** 1076 * @tc.name: BindAlbumChanges005 1077 * @tc.desc: Verify the BindAlbumChanges function 1078 * @tc.type: FUNC 1079 * @tc.require: issueI7Y6UO 1080 */ 1081 HWTEST_F(FileDataHandlerTest, BindAlbumChanges005, TestSize.Level1) 1082 { 1083 GTEST_LOG_(INFO) << "BindAlbumChanges005 Begin"; 1084 try { 1085 int type = static_cast<int32_t>(Media::DirtyType::TYPE_DELETED); 1086 auto rdb = std::make_shared<RdbStoreMock>(); 1087 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1088 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 1089 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)).WillOnce(Return(1)); 1090 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 1091 EXPECT_CALL(*rset, GetInt(_, _)) 1092 .WillOnce(DoAll(SetArgReferee<1>(2), Return(0))) 1093 .WillOnce(DoAll(SetArgReferee<1>(type), Return(0))); 1094 EXPECT_CALL(*rdb, Query(_, _)) 1095 .WillOnce(Return(ByMove(std::move(rset)))) 1096 .WillOnce(Return(ByMove(nullptr))); 1097 1098 DKRecordData data; 1099 DriveKit::DKRecordFieldMap prop; 1100 prop.insert(std::make_pair(Media::MediaColumn::MEDIA_ID, DriveKit::DKRecordField(1))); 1101 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1102 DriveKit::DKRecord record; 1103 record.SetRecordData(data); 1104 std::vector<DriveKit::DKRecord> records; 1105 records.push_back(record); 1106 int32_t ret = fileDataHandler->BindAlbumChanges(records); 1107 EXPECT_EQ(ret, E_RDB); 1108 } catch (...) { 1109 EXPECT_TRUE(false); 1110 GTEST_LOG_(INFO) << " BindAlbumChanges005 ERROR"; 1111 } 1112 GTEST_LOG_(INFO) << "BindAlbumChanges005 End"; 1113 } 1114 1115 /** 1116 * @tc.name: ConflictHandler001 1117 * @tc.desc: Verify the ConflictHandler function 1118 * @tc.type: FUNC 1119 * @tc.require: issueI7Y6UO 1120 */ 1121 HWTEST_F(FileDataHandlerTest, ConflictHandler001, TestSize.Level1) 1122 { 1123 GTEST_LOG_(INFO) << "ConflictHandler001 Begin"; 1124 try { 1125 auto rdb = std::make_shared<RdbStoreMock>(); 1126 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1127 std::unique_ptr<ResultSetMock> rset = std::make_unique<ResultSetMock>(); 1128 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 1129 EXPECT_CALL(*rset, GetString(_, _)).WillOnce(Return(0)); 1130 EXPECT_CALL(*rset, GetLong(_, _)).WillOnce(Return(0)).WillOnce(Return(0)); 1131 1132 DKRecord record; 1133 int64_t isize = 0; 1134 bool modifyPathflag = false; 1135 int32_t ret = fileDataHandler->ConflictHandler(*rset, record, isize, modifyPathflag); 1136 EXPECT_EQ(ret, E_OK); 1137 } catch (...) { 1138 EXPECT_TRUE(false); 1139 GTEST_LOG_(INFO) << " ConflictHandler001 ERROR"; 1140 } 1141 GTEST_LOG_(INFO) << "ConflictHandler001 End"; 1142 } 1143 1144 /** 1145 * @tc.name: ConflictHandler002 1146 * @tc.desc: Verify the ConflictHandler function 1147 * @tc.type: FUNC 1148 * @tc.require: issueI7Y6UO 1149 */ 1150 HWTEST_F(FileDataHandlerTest, ConflictHandler002, TestSize.Level1) 1151 { 1152 GTEST_LOG_(INFO) << "ConflictHandler002 Begin"; 1153 try { 1154 auto rdb = std::make_shared<RdbStoreMock>(); 1155 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1156 std::unique_ptr<ResultSetMock> rset = std::make_unique<ResultSetMock>(); 1157 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 1158 EXPECT_CALL(*rset, GetString(_, _)).WillOnce(Return(1)); 1159 1160 DKRecord record; 1161 int64_t isize = 0; 1162 bool modifyPathflag = false; 1163 int32_t ret = fileDataHandler->ConflictHandler(*rset, record, isize, modifyPathflag); 1164 EXPECT_EQ(ret, E_INVAL_ARG); 1165 } catch (...) { 1166 EXPECT_TRUE(false); 1167 GTEST_LOG_(INFO) << " ConflictHandler002 ERROR"; 1168 } 1169 GTEST_LOG_(INFO) << "ConflictHandler002 End"; 1170 } 1171 1172 /** 1173 * @tc.name: ConflictHandler003 1174 * @tc.desc: Verify the ConflictHandler function 1175 * @tc.type: FUNC 1176 * @tc.require: issueI7Y6UO 1177 */ 1178 HWTEST_F(FileDataHandlerTest, ConflictHandler003, TestSize.Level1) 1179 { 1180 GTEST_LOG_(INFO) << "ConflictHandler003 Begin"; 1181 try { 1182 auto rdb = std::make_shared<RdbStoreMock>(); 1183 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1184 std::unique_ptr<ResultSetMock> rset = std::make_unique<ResultSetMock>(); 1185 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 1186 EXPECT_CALL(*rset, GetString(_, _)).WillOnce(DoAll(SetArgReferee<1>("1"), Return(0))); 1187 EXPECT_CALL(*rset, GetLong(_, _)).WillOnce(Return(1)); 1188 1189 DKRecord record; 1190 int64_t isize = 0; 1191 bool modifyPathflag = false; 1192 int32_t ret = fileDataHandler->ConflictHandler(*rset, record, isize, modifyPathflag); 1193 EXPECT_EQ(ret, E_INVAL_ARG); 1194 } catch (...) { 1195 EXPECT_TRUE(false); 1196 GTEST_LOG_(INFO) << " ConflictHandler003 ERROR"; 1197 } 1198 GTEST_LOG_(INFO) << "ConflictHandler003 End"; 1199 } 1200 1201 /** 1202 * @tc.name: ConflictHandler004 1203 * @tc.desc: Verify the ConflictHandler function 1204 * @tc.type: FUNC 1205 * @tc.require: issueI7Y6UO 1206 */ 1207 HWTEST_F(FileDataHandlerTest, ConflictHandler004, TestSize.Level1) 1208 { 1209 GTEST_LOG_(INFO) << "ConflictHandler004 Begin"; 1210 try { 1211 auto rdb = std::make_shared<RdbStoreMock>(); 1212 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1213 std::unique_ptr<ResultSetMock> rset = std::make_unique<ResultSetMock>(); 1214 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 1215 EXPECT_CALL(*rset, GetString(_, _)).WillOnce(DoAll(SetArgReferee<1>("1"), Return(0))); 1216 EXPECT_CALL(*rset, GetLong(_, _)).WillOnce(Return(0)).WillOnce(Return(1)); 1217 1218 DKRecord record; 1219 int64_t isize = 0; 1220 bool modifyPathflag = false; 1221 int32_t ret = fileDataHandler->ConflictHandler(*rset, record, isize, modifyPathflag); 1222 EXPECT_EQ(ret, E_INVAL_ARG); 1223 } catch (...) { 1224 EXPECT_TRUE(false); 1225 GTEST_LOG_(INFO) << " ConflictHandler004 ERROR"; 1226 } 1227 GTEST_LOG_(INFO) << "ConflictHandler004 End"; 1228 } 1229 1230 /** 1231 * @tc.name: ConflictHandler005 1232 * @tc.desc: Verify the ConflictHandler function 1233 * @tc.type: FUNC 1234 * @tc.require: issueI7Y6UO 1235 */ 1236 HWTEST_F(FileDataHandlerTest, ConflictHandler005, TestSize.Level1) 1237 { 1238 GTEST_LOG_(INFO) << "ConflictHandler005 Begin"; 1239 try { 1240 auto rdb = std::make_shared<RdbStoreMock>(); 1241 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1242 std::unique_ptr<ResultSetMock> rset = std::make_unique<ResultSetMock>(); 1243 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 1244 EXPECT_CALL(*rset, GetString(_, _)).WillOnce(DoAll(SetArgReferee<1>("1"), Return(0))); 1245 EXPECT_CALL(*rset, GetLong(_, _)).WillOnce(Return(0)).WillOnce(Return(0)); 1246 1247 DKRecord record; 1248 int64_t isize = 1; 1249 bool modifyPathflag = false; 1250 int32_t ret = fileDataHandler->ConflictHandler(*rset, record, isize, modifyPathflag); 1251 EXPECT_EQ(ret, E_OK); 1252 } catch (...) { 1253 EXPECT_TRUE(false); 1254 GTEST_LOG_(INFO) << " ConflictHandler005 ERROR"; 1255 } 1256 GTEST_LOG_(INFO) << "ConflictHandler005 End"; 1257 } 1258 1259 /** 1260 * @tc.name: ConflictHandler006 1261 * @tc.desc: Verify the ConflictHandler function 1262 * @tc.type: FUNC 1263 * @tc.require: issueI7Y6UO 1264 */ 1265 HWTEST_F(FileDataHandlerTest, ConflictHandler006, TestSize.Level1) 1266 { 1267 GTEST_LOG_(INFO) << "ConflictHandler006 Begin"; 1268 try { 1269 auto rdb = std::make_shared<RdbStoreMock>(); 1270 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1271 std::unique_ptr<ResultSetMock> rset = std::make_unique<ResultSetMock>(); 1272 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 1273 EXPECT_CALL(*rset, GetString(_, _)).WillOnce(DoAll(SetArgReferee<1>("1"), Return(0))); 1274 EXPECT_CALL(*rset, GetLong(_, _)).WillOnce(Return(0)).WillOnce(DoAll(SetArgReferee<1>(100), Return(0))); 1275 1276 DKRecord record; 1277 int64_t isize = 0; 1278 bool modifyPathflag = false; 1279 int32_t ret = fileDataHandler->ConflictHandler(*rset, record, isize, modifyPathflag); 1280 EXPECT_EQ(ret, E_OK); 1281 } catch (...) { 1282 EXPECT_TRUE(false); 1283 GTEST_LOG_(INFO) << " ConflictHandler006 ERROR"; 1284 } 1285 GTEST_LOG_(INFO) << "ConflictHandler006 End"; 1286 } 1287 1288 /** 1289 * @tc.name: GetConflictData001 1290 * @tc.desc: Verify the GetConflictData function 1291 * @tc.type: FUNC 1292 * @tc.require: issueI7Y6UO 1293 */ 1294 HWTEST_F(FileDataHandlerTest, GetConflictData001, TestSize.Level1) 1295 { 1296 GTEST_LOG_(INFO) << "GetConflictData001 Begin"; 1297 try { 1298 auto rdb = std::make_shared<RdbStoreMock>(); 1299 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1300 1301 DKRecordData data; 1302 DriveKit::DKRecordFieldMap prop; 1303 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("fullPath"))); 1304 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_RELATIVE_PATH, DriveKit::DKRecordField("relativePath"))); 1305 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1))); 1306 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1307 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1308 DriveKit::DKRecord record; 1309 record.SetRecordData(data); 1310 string fullPath = ""; 1311 int64_t isize = 0; 1312 int64_t imetaModified = 0; 1313 std::string relativePath = ""; 1314 int32_t ret = fileDataHandler->GetConflictData(record, fullPath, isize, imetaModified, relativePath); 1315 EXPECT_EQ(ret, E_OK); 1316 } catch (...) { 1317 EXPECT_TRUE(false); 1318 GTEST_LOG_(INFO) << " GetConflictData001 ERROR"; 1319 } 1320 GTEST_LOG_(INFO) << "GetConflictData001 End"; 1321 } 1322 1323 /** 1324 * @tc.name: GetConflictData002 1325 * @tc.desc: Verify the GetConflictData function 1326 * @tc.type: FUNC 1327 * @tc.require: issueI7Y6UO 1328 */ 1329 HWTEST_F(FileDataHandlerTest, GetConflictData002, TestSize.Level1) 1330 { 1331 GTEST_LOG_(INFO) << "GetConflictData002 Begin"; 1332 try { 1333 auto rdb = std::make_shared<RdbStoreMock>(); 1334 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1335 1336 DriveKit::DKRecord record; 1337 string fullPath = ""; 1338 int64_t isize = 0; 1339 int64_t imetaModified = 0; 1340 std::string relativePath = ""; 1341 int32_t ret = fileDataHandler->GetConflictData(record, fullPath, isize, imetaModified, relativePath); 1342 EXPECT_EQ(ret, E_INVAL_ARG); 1343 } catch (...) { 1344 EXPECT_TRUE(false); 1345 GTEST_LOG_(INFO) << " GetConflictData002 ERROR"; 1346 } 1347 GTEST_LOG_(INFO) << "GetConflictData002 End"; 1348 } 1349 1350 /** 1351 * @tc.name: GetConflictData003 1352 * @tc.desc: Verify the GetConflictData function 1353 * @tc.type: FUNC 1354 * @tc.require: issueI7Y6UO 1355 */ 1356 HWTEST_F(FileDataHandlerTest, GetConflictData003, TestSize.Level1) 1357 { 1358 GTEST_LOG_(INFO) << "GetConflictData003 Begin"; 1359 try { 1360 auto rdb = std::make_shared<RdbStoreMock>(); 1361 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1362 1363 DKRecordData data; 1364 DriveKit::DKRecordFieldMap prop; 1365 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1366 DriveKit::DKRecord record; 1367 record.SetRecordData(data); 1368 string fullPath = ""; 1369 int64_t isize = 0; 1370 int64_t imetaModified = 0; 1371 std::string relativePath = ""; 1372 int32_t ret = fileDataHandler->GetConflictData(record, fullPath, isize, imetaModified, relativePath); 1373 EXPECT_EQ(ret, E_INVAL_ARG); 1374 } catch (...) { 1375 EXPECT_TRUE(false); 1376 GTEST_LOG_(INFO) << " GetConflictData003 ERROR"; 1377 } 1378 GTEST_LOG_(INFO) << "GetConflictData003 End"; 1379 } 1380 1381 /** 1382 * @tc.name: GetConflictData004 1383 * @tc.desc: Verify the GetConflictData function 1384 * @tc.type: FUNC 1385 * @tc.require: issueI7Y6UO 1386 */ 1387 HWTEST_F(FileDataHandlerTest, GetConflictData004, TestSize.Level1) 1388 { 1389 GTEST_LOG_(INFO) << "GetConflictData004 Begin"; 1390 try { 1391 auto rdb = std::make_shared<RdbStoreMock>(); 1392 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1393 1394 DKRecordData data; 1395 DriveKit::DKRecordFieldMap prop; 1396 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1397 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1398 DriveKit::DKRecord record; 1399 record.SetRecordData(data); 1400 string fullPath = ""; 1401 int64_t isize = 0; 1402 int64_t imetaModified = 0; 1403 std::string relativePath = ""; 1404 int32_t ret = fileDataHandler->GetConflictData(record, fullPath, isize, imetaModified, relativePath); 1405 EXPECT_EQ(ret, E_INVAL_ARG); 1406 } catch (...) { 1407 EXPECT_TRUE(false); 1408 GTEST_LOG_(INFO) << " GetConflictData004 ERROR"; 1409 } 1410 GTEST_LOG_(INFO) << "GetConflictData004 End"; 1411 } 1412 1413 /** 1414 * @tc.name: GetConflictData005 1415 * @tc.desc: Verify the GetConflictData function 1416 * @tc.type: FUNC 1417 * @tc.require: issueI7Y6UO 1418 */ 1419 HWTEST_F(FileDataHandlerTest, GetConflictData005, TestSize.Level1) 1420 { 1421 GTEST_LOG_(INFO) << "GetConflictData005 Begin"; 1422 try { 1423 auto rdb = std::make_shared<RdbStoreMock>(); 1424 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1425 1426 DKRecordData data; 1427 DriveKit::DKRecordFieldMap prop; 1428 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField(0))); 1429 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1430 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1431 DriveKit::DKRecord record; 1432 record.SetRecordData(data); 1433 string fullPath = ""; 1434 int64_t isize = 0; 1435 int64_t imetaModified = 0; 1436 std::string relativePath = ""; 1437 int32_t ret = fileDataHandler->GetConflictData(record, fullPath, isize, imetaModified, relativePath); 1438 EXPECT_EQ(ret, E_INVAL_ARG); 1439 } catch (...) { 1440 EXPECT_TRUE(false); 1441 GTEST_LOG_(INFO) << " GetConflictData005 ERROR"; 1442 } 1443 GTEST_LOG_(INFO) << "GetConflictData005 End"; 1444 } 1445 1446 /** 1447 * @tc.name: GetConflictData006 1448 * @tc.desc: Verify the GetConflictData function 1449 * @tc.type: FUNC 1450 * @tc.require: issueI7Y6UO 1451 */ 1452 HWTEST_F(FileDataHandlerTest, GetConflictData006, TestSize.Level1) 1453 { 1454 GTEST_LOG_(INFO) << "GetConflictData006 Begin"; 1455 try { 1456 auto rdb = std::make_shared<RdbStoreMock>(); 1457 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1458 1459 DKRecordData data; 1460 DriveKit::DKRecordFieldMap prop; 1461 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("fullPath"))); 1462 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1463 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1464 DriveKit::DKRecord record; 1465 record.SetRecordData(data); 1466 string fullPath = ""; 1467 int64_t isize = 0; 1468 int64_t imetaModified = 0; 1469 std::string relativePath = ""; 1470 int32_t ret = fileDataHandler->GetConflictData(record, fullPath, isize, imetaModified, relativePath); 1471 EXPECT_EQ(ret, E_INVAL_ARG); 1472 } catch (...) { 1473 EXPECT_TRUE(false); 1474 GTEST_LOG_(INFO) << " GetConflictData006 ERROR"; 1475 } 1476 GTEST_LOG_(INFO) << "GetConflictData006 End"; 1477 } 1478 1479 /** 1480 * @tc.name: GetConflictData007 1481 * @tc.desc: Verify the GetConflictData function 1482 * @tc.type: FUNC 1483 * @tc.require: issueI7Y6UO 1484 */ 1485 HWTEST_F(FileDataHandlerTest, GetConflictData007, TestSize.Level1) 1486 { 1487 GTEST_LOG_(INFO) << "GetConflictData007 Begin"; 1488 try { 1489 auto rdb = std::make_shared<RdbStoreMock>(); 1490 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1491 1492 DKRecordData data; 1493 DriveKit::DKRecordFieldMap prop; 1494 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("fullPath"))); 1495 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_RELATIVE_PATH, DriveKit::DKRecordField(0))); 1496 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1497 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1498 DriveKit::DKRecord record; 1499 record.SetRecordData(data); 1500 string fullPath = ""; 1501 int64_t isize = 0; 1502 int64_t imetaModified = 0; 1503 std::string relativePath = ""; 1504 int32_t ret = fileDataHandler->GetConflictData(record, fullPath, isize, imetaModified, relativePath); 1505 EXPECT_EQ(ret, E_INVAL_ARG); 1506 } catch (...) { 1507 EXPECT_TRUE(false); 1508 GTEST_LOG_(INFO) << " GetConflictData007 ERROR"; 1509 } 1510 GTEST_LOG_(INFO) << "GetConflictData007 End"; 1511 } 1512 1513 /** 1514 * @tc.name: GetConflictData008 1515 * @tc.desc: Verify the GetConflictData function 1516 * @tc.type: FUNC 1517 * @tc.require: issueI7Y6UO 1518 */ 1519 HWTEST_F(FileDataHandlerTest, GetConflictData008, TestSize.Level1) 1520 { 1521 GTEST_LOG_(INFO) << "GetConflictData008 Begin"; 1522 try { 1523 auto rdb = std::make_shared<RdbStoreMock>(); 1524 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1525 1526 DKRecordData data; 1527 DriveKit::DKRecordFieldMap prop; 1528 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("fullPath"))); 1529 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_RELATIVE_PATH, DriveKit::DKRecordField("relativePath"))); 1530 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1531 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1532 DriveKit::DKRecord record; 1533 record.SetRecordData(data); 1534 string fullPath = ""; 1535 int64_t isize = 0; 1536 int64_t imetaModified = 0; 1537 std::string relativePath = ""; 1538 int32_t ret = fileDataHandler->GetConflictData(record, fullPath, isize, imetaModified, relativePath); 1539 EXPECT_EQ(ret, E_INVAL_ARG); 1540 } catch (...) { 1541 EXPECT_TRUE(false); 1542 GTEST_LOG_(INFO) << " GetConflictData008 ERROR"; 1543 } 1544 GTEST_LOG_(INFO) << "GetConflictData008 End"; 1545 } 1546 1547 /** 1548 * @tc.name: GetConflictData009 1549 * @tc.desc: Verify the GetConflictData function 1550 * @tc.type: FUNC 1551 * @tc.require: issueI7Y6UO 1552 */ 1553 HWTEST_F(FileDataHandlerTest, GetConflictData009, TestSize.Level1) 1554 { 1555 GTEST_LOG_(INFO) << "GetConflictData009 Begin"; 1556 try { 1557 auto rdb = std::make_shared<RdbStoreMock>(); 1558 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1559 1560 DKRecordData data; 1561 DriveKit::DKRecordFieldMap prop; 1562 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("fullPath"))); 1563 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_RELATIVE_PATH, DriveKit::DKRecordField("relativePath"))); 1564 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField("abc"))); 1565 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1566 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1567 DriveKit::DKRecord record; 1568 record.SetRecordData(data); 1569 string fullPath = ""; 1570 int64_t isize = 0; 1571 int64_t imetaModified = 0; 1572 std::string relativePath = ""; 1573 int32_t ret = fileDataHandler->GetConflictData(record, fullPath, isize, imetaModified, relativePath); 1574 EXPECT_EQ(ret, E_INVAL_ARG); 1575 } catch (...) { 1576 EXPECT_TRUE(false); 1577 GTEST_LOG_(INFO) << " GetConflictData009 ERROR"; 1578 } 1579 GTEST_LOG_(INFO) << "GetConflictData009 End"; 1580 } 1581 1582 /** 1583 * @tc.name: PullRecordConflict001 1584 * @tc.desc: Verify the PullRecordConflict function 1585 * @tc.type: FUNC 1586 * @tc.require: issueI7Y6UO 1587 */ 1588 HWTEST_F(FileDataHandlerTest, PullRecordConflict001, TestSize.Level1) 1589 { 1590 GTEST_LOG_(INFO) << "PullRecordConflict001 Begin"; 1591 try { 1592 const int rowCount = 1; 1593 auto rdb = std::make_shared<RdbStoreMock>(); 1594 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1595 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 1596 EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0))); 1597 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)); 1598 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 1599 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0)); 1600 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(0)); 1601 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))); 1602 1603 DKRecordData data; 1604 DriveKit::DKRecordFieldMap prop; 1605 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("fullPath"))); 1606 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_RELATIVE_PATH, DriveKit::DKRecordField("relativePath"))); 1607 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1))); 1608 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1609 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1610 data.insert(std::make_pair(DriveKit::DKFieldKey(Media::PhotoColumn::MEDIA_SIZE), 0)); 1611 DriveKit::DKRecord record; 1612 record.SetRecordData(data); 1613 bool comflag = false; 1614 int32_t ret = fileDataHandler->PullRecordConflict(record, comflag); 1615 EXPECT_EQ(ret, E_INVAL_ARG); 1616 } catch (...) { 1617 EXPECT_TRUE(false); 1618 GTEST_LOG_(INFO) << " PullRecordConflict001 ERROR"; 1619 } 1620 GTEST_LOG_(INFO) << "PullRecordConflict001 End"; 1621 } 1622 1623 /** 1624 * @tc.name: PullRecordConflict002 1625 * @tc.desc: Verify the PullRecordConflict function 1626 * @tc.type: FUNC 1627 * @tc.require: issueI7Y6UO 1628 */ 1629 HWTEST_F(FileDataHandlerTest, PullRecordConflict002, TestSize.Level1) 1630 { 1631 GTEST_LOG_(INFO) << "PullRecordConflict002 Begin"; 1632 try { 1633 auto rdb = std::make_shared<RdbStoreMock>(); 1634 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1635 1636 DriveKit::DKRecord record; 1637 bool comflag = false; 1638 int32_t ret = fileDataHandler->PullRecordConflict(record, comflag); 1639 EXPECT_EQ(ret, E_INVAL_ARG); 1640 } catch (...) { 1641 EXPECT_TRUE(false); 1642 GTEST_LOG_(INFO) << " PullRecordConflict002 ERROR"; 1643 } 1644 GTEST_LOG_(INFO) << "PullRecordConflict002 End"; 1645 } 1646 1647 /** 1648 * @tc.name: PullRecordConflict003 1649 * @tc.desc: Verify the PullRecordConflict function 1650 * @tc.type: FUNC 1651 * @tc.require: issueI7Y6UO 1652 */ 1653 HWTEST_F(FileDataHandlerTest, PullRecordConflict003, TestSize.Level1) 1654 { 1655 GTEST_LOG_(INFO) << "PullRecordConflict003 Begin"; 1656 try { 1657 auto rdb = std::make_shared<RdbStoreMock>(); 1658 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1659 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(nullptr)); 1660 1661 DKRecordData data; 1662 DriveKit::DKRecordFieldMap prop; 1663 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("fullPath"))); 1664 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_RELATIVE_PATH, DriveKit::DKRecordField("relativePath"))); 1665 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1))); 1666 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1667 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1668 data.insert(std::make_pair(DriveKit::DKFieldKey(Media::PhotoColumn::MEDIA_SIZE), 0)); 1669 DriveKit::DKRecord record; 1670 record.SetRecordData(data); 1671 bool comflag = false; 1672 int32_t ret = fileDataHandler->PullRecordConflict(record, comflag); 1673 EXPECT_EQ(ret, E_RDB); 1674 } catch (...) { 1675 EXPECT_TRUE(false); 1676 GTEST_LOG_(INFO) << " PullRecordConflict003 ERROR"; 1677 } 1678 GTEST_LOG_(INFO) << "PullRecordConflict003 End"; 1679 } 1680 1681 /** 1682 * @tc.name: PullRecordConflict004 1683 * @tc.desc: Verify the PullRecordConflict function 1684 * @tc.type: FUNC 1685 * @tc.require: issueI7Y6UO 1686 */ 1687 HWTEST_F(FileDataHandlerTest, PullRecordConflict004, TestSize.Level1) 1688 { 1689 GTEST_LOG_(INFO) << "PullRecordConflict004 Begin"; 1690 try { 1691 auto rdb = std::make_shared<RdbStoreMock>(); 1692 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1693 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 1694 EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(Return(1)); 1695 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))); 1696 1697 DKRecordData data; 1698 DriveKit::DKRecordFieldMap prop; 1699 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("fullPath"))); 1700 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_RELATIVE_PATH, DriveKit::DKRecordField("relativePath"))); 1701 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1))); 1702 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1703 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1704 data.insert(std::make_pair(DriveKit::DKFieldKey(Media::PhotoColumn::MEDIA_SIZE), 0)); 1705 DriveKit::DKRecord record; 1706 record.SetRecordData(data); 1707 bool comflag = false; 1708 int32_t ret = fileDataHandler->PullRecordConflict(record, comflag); 1709 EXPECT_EQ(ret, E_RDB); 1710 } catch (...) { 1711 EXPECT_TRUE(false); 1712 GTEST_LOG_(INFO) << " PullRecordConflict004 ERROR"; 1713 } 1714 GTEST_LOG_(INFO) << "PullRecordConflict004 End"; 1715 } 1716 1717 /** 1718 * @tc.name: PullRecordConflict005 1719 * @tc.desc: Verify the PullRecordConflict function 1720 * @tc.type: FUNC 1721 * @tc.require: issueI7Y6UO 1722 */ 1723 HWTEST_F(FileDataHandlerTest, PullRecordConflict005, TestSize.Level1) 1724 { 1725 GTEST_LOG_(INFO) << "PullRecordConflict005 Begin"; 1726 try { 1727 auto rdb = std::make_shared<RdbStoreMock>(); 1728 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1729 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 1730 EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(0), Return(0))); 1731 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))); 1732 1733 DKRecordData data; 1734 DriveKit::DKRecordFieldMap prop; 1735 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("fullPath"))); 1736 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_RELATIVE_PATH, DriveKit::DKRecordField("relativePath"))); 1737 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1))); 1738 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1739 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1740 data.insert(std::make_pair(DriveKit::DKFieldKey(Media::PhotoColumn::MEDIA_SIZE), 0)); 1741 DriveKit::DKRecord record; 1742 record.SetRecordData(data); 1743 bool comflag = false; 1744 int32_t ret = fileDataHandler->PullRecordConflict(record, comflag); 1745 EXPECT_EQ(ret, E_OK); 1746 } catch (...) { 1747 EXPECT_TRUE(false); 1748 GTEST_LOG_(INFO) << " PullRecordConflict005 ERROR"; 1749 } 1750 GTEST_LOG_(INFO) << "PullRecordConflict005 End"; 1751 } 1752 1753 /** 1754 * @tc.name: PullRecordConflict006 1755 * @tc.desc: Verify the PullRecordConflict function 1756 * @tc.type: FUNC 1757 * @tc.require: issueI7Y6UO 1758 */ 1759 HWTEST_F(FileDataHandlerTest, PullRecordConflict006, TestSize.Level1) 1760 { 1761 GTEST_LOG_(INFO) << "PullRecordConflict006 Begin"; 1762 try { 1763 const int rowCount = 2; 1764 auto rdb = std::make_shared<RdbStoreMock>(); 1765 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1766 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 1767 EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0))); 1768 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))); 1769 1770 DKRecordData data; 1771 DriveKit::DKRecordFieldMap prop; 1772 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("fullPath"))); 1773 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_RELATIVE_PATH, DriveKit::DKRecordField("relativePath"))); 1774 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1))); 1775 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1776 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1777 data.insert(std::make_pair(DriveKit::DKFieldKey(Media::PhotoColumn::MEDIA_SIZE), 0)); 1778 DriveKit::DKRecord record; 1779 record.SetRecordData(data); 1780 bool comflag = false; 1781 int32_t ret = fileDataHandler->PullRecordConflict(record, comflag); 1782 EXPECT_EQ(ret, E_RDB); 1783 } catch (...) { 1784 EXPECT_TRUE(false); 1785 GTEST_LOG_(INFO) << " PullRecordConflict006 ERROR"; 1786 } 1787 GTEST_LOG_(INFO) << "PullRecordConflict006 End"; 1788 } 1789 1790 /** 1791 * @tc.name: PullRecordConflict007 1792 * @tc.desc: Verify the PullRecordConflict function 1793 * @tc.type: FUNC 1794 * @tc.require: issueI7Y6UO 1795 */ 1796 HWTEST_F(FileDataHandlerTest, PullRecordConflict007, TestSize.Level1) 1797 { 1798 GTEST_LOG_(INFO) << "PullRecordConflict007 Begin"; 1799 try { 1800 const int rowCount = 1; 1801 auto rdb = std::make_shared<RdbStoreMock>(); 1802 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1803 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 1804 EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0))); 1805 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)); 1806 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 1807 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(1)); 1808 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))); 1809 1810 DKRecordData data; 1811 DriveKit::DKRecordFieldMap prop; 1812 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("fullPath"))); 1813 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_RELATIVE_PATH, DriveKit::DKRecordField("relativePath"))); 1814 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1))); 1815 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1816 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1817 data.insert(std::make_pair(DriveKit::DKFieldKey(Media::PhotoColumn::MEDIA_SIZE), 0)); 1818 DriveKit::DKRecord record; 1819 record.SetRecordData(data); 1820 bool comflag = false; 1821 int32_t ret = fileDataHandler->PullRecordConflict(record, comflag); 1822 EXPECT_EQ(ret, E_INVAL_ARG); 1823 } catch (...) { 1824 EXPECT_TRUE(false); 1825 GTEST_LOG_(INFO) << " PullRecordConflict007 ERROR"; 1826 } 1827 GTEST_LOG_(INFO) << "PullRecordConflict007 End"; 1828 } 1829 1830 /** 1831 * @tc.name: PullRecordConflict008 1832 * @tc.desc: Verify the PullRecordConflict function 1833 * @tc.type: FUNC 1834 * @tc.require: issueI7Y6UO 1835 */ 1836 HWTEST_F(FileDataHandlerTest, PullRecordConflict008, TestSize.Level1) 1837 { 1838 GTEST_LOG_(INFO) << "PullRecordConflict008 Begin"; 1839 try { 1840 const int rowCount = 1; 1841 auto rdb = std::make_shared<RdbStoreMock>(); 1842 auto fileDataHandler = make_shared<FileDataHandler>(USER_ID, BUND_NAME, rdb, std::make_shared<bool>(false)); 1843 std::unique_ptr<AbsSharedResultSetMock> rset = std::make_unique<AbsSharedResultSetMock>(); 1844 EXPECT_CALL(*rset, GetRowCount(_)).WillOnce(DoAll(SetArgReferee<0>(rowCount), Return(0))); 1845 EXPECT_CALL(*rset, GoToNextRow()).WillOnce(Return(0)); 1846 EXPECT_CALL(*rset, GetColumnIndex(_, _)).WillRepeatedly(Return(0)); 1847 EXPECT_CALL(*rset, GetString(_, _)).WillRepeatedly(Return(0)); 1848 EXPECT_CALL(*rset, GetLong(_, _)).WillRepeatedly(Return(0)); 1849 EXPECT_CALL(*rdb, Query(_, _)).WillOnce(Return(ByMove(std::move(rset)))); 1850 EXPECT_CALL(*rdb, Update(_, _, _, _, A<const vector<string> &>())).WillRepeatedly(Return(1)); 1851 1852 DKRecordData data; 1853 DriveKit::DKRecordFieldMap prop; 1854 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_FILE_PATH, DriveKit::DKRecordField("fullPath"))); 1855 prop.insert(std::make_pair(Media::PhotoColumn::MEDIA_RELATIVE_PATH, DriveKit::DKRecordField("relativePath"))); 1856 prop.insert(std::make_pair(Media::PhotoColumn::PHOTO_META_DATE_MODIFIED, DriveKit::DKRecordField(1))); 1857 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_ATTRIBUTES), prop)); 1858 data.insert(std::make_pair(DriveKit::DKFieldKey(FILE_SIZE), 1)); 1859 data.insert(std::make_pair(DriveKit::DKFieldKey(Media::PhotoColumn::MEDIA_SIZE), 1)); 1860 DriveKit::DKRecord record; 1861 record.SetRecordData(data); 1862 bool comflag = false; 1863 int32_t ret = fileDataHandler->PullRecordConflict(record, comflag); 1864 EXPECT_EQ(ret, E_INVAL_ARG); 1865 } catch (...) { 1866 EXPECT_TRUE(false); 1867 GTEST_LOG_(INFO) << " PullRecordConflict008 ERROR"; 1868 } 1869 GTEST_LOG_(INFO) << "PullRecordConflict008 End"; 1870 } 1871