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