1/* 2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16#include "mergecontact_test.h" 17 18#include <sys/time.h> 19 20#include "match_candidate.h" 21#include "merger_contacts.h" 22#include "test_common.h" 23 24namespace Contacts { 25namespace Test { 26void MergeContactTest::DeleteRawContact() 27{ 28 OHOS::DataShare::DataSharePredicates predicates; 29 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT); 30 predicates.NotEqualTo("id", "0"); 31 predicates.And(); 32 predicates.EqualTo("is_deleted", "0"); 33 contactsDataAbility.Delete(uriRawContact, predicates); 34 int time = Time::SLEEP_TIME_MERGE_DELETE; 35 std::chrono::milliseconds dura(time); 36 std::this_thread::sleep_for(dura); 37 OHOS::DataShare::DataSharePredicates predicates2; 38 OHOS::Uri uriRawContactComplete(ContactsUri::DELETED_RAW_CONTACT); 39 predicates2.NotEqualTo("id", "0"); 40 contactsDataAbility.Delete(uriRawContactComplete, predicates2); 41} 42 43void MergeContactTest::CheckMergeResultId(std::vector<int64_t> ids, bool merge) 44{ 45 std::vector<int64_t> resultIdVector; 46 int mergeIdSize = ids.size(); 47 for (int i = 0; i < mergeIdSize; i++) { 48 std::vector<std::string> columns; 49 columns.push_back("contact_id"); 50 OHOS::DataShare::DataSharePredicates predicates; 51 predicates.EqualTo("id", std::to_string(ids[i])); 52 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultOne = ContactQuery(columns, predicates); 53 int contactIdOne = GetMergeResultContactId(resultOne); 54 resultIdVector.push_back(contactIdOne); 55 } 56 int size = resultIdVector.size(); 57 int64_t contactId = resultIdVector[0]; 58 for (int i = 1; i < size; i++) { 59 if (merge) { 60 EXPECT_EQ(contactId, resultIdVector[i]); 61 HILOG_INFO("merge contact_id = %{public}ld, contact_idTwo %{public}ld", contactId, resultIdVector[i]); 62 } else { 63 EXPECT_NE(contactId, resultIdVector[i]); 64 HILOG_INFO("split contact_id = %{public}ld", resultIdVector[i]); 65 } 66 } 67} 68 69int MergeContactTest::GetMergeResultContactId(const std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet) 70{ 71 std::vector<std::string> columnNames; 72 resultSet->GetAllColumnNames(columnNames); 73 int resultSetIntValue = 0; 74 if (resultSet->GoToFirstRow() == OHOS::NativeRdb::E_OK) { 75 std::string typeValue = "contact_id"; 76 int columnIndex = 0; 77 resultSet->GetColumnIndex(typeValue, columnIndex); 78 resultSet->GetInt(columnIndex, resultSetIntValue); 79 } 80 resultSet->Close(); 81 return resultSetIntValue; 82} 83 84std::vector<int> MergeContactTest::GetMergeResultRawContactId( 85 const std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet) 86{ 87 std::vector<int> rawContactIdVector; 88 std::vector<std::string> columnNames; 89 resultSet->GetAllColumnNames(columnNames); 90 int resultSetNum = resultSet->GoToFirstRow(); 91 while (resultSetNum == OHOS::NativeRdb::E_OK) { 92 int resultSetIntValue = 0; 93 std::string typeValue = "raw_contact_id"; 94 int columnIndex = 0; 95 resultSet->GetColumnIndex(typeValue, columnIndex); 96 resultSet->GetInt(columnIndex, resultSetIntValue); 97 rawContactIdVector.push_back(resultSetIntValue); 98 resultSetNum = resultSet->GoToNextRow(); 99 } 100 resultSet->Close(); 101 return rawContactIdVector; 102} 103 104std::vector<int> MergeContactTest::GetMergeRawContactId( 105 const std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet) 106{ 107 std::vector<int> rawContactIdVector; 108 std::vector<std::string> columnNames; 109 resultSet->GetAllColumnNames(columnNames); 110 int resultSetNum = resultSet->GoToFirstRow(); 111 while (resultSetNum == OHOS::NativeRdb::E_OK) { 112 int resultSetIntValue = 0; 113 std::string typeValue = "id"; 114 int columnIndex = 0; 115 resultSet->GetColumnIndex(typeValue, columnIndex); 116 resultSet->GetInt(columnIndex, resultSetIntValue); 117 rawContactIdVector.push_back(resultSetIntValue); 118 resultSetNum = resultSet->GoToNextRow(); 119 } 120 resultSet->Close(); 121 return rawContactIdVector; 122} 123 124std::shared_ptr<OHOS::DataShare::DataShareResultSet> MergeContactTest::ContactQuery( 125 std::vector<std::string> columns, OHOS::DataShare::DataSharePredicates predicates) 126{ 127 OHOS::Uri uri(ContactsUri::RAW_CONTACT); 128 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = 129 contactsDataAbility.Query(uri, predicates, columns); 130 return resultSet; 131} 132 133int64_t MergeContactTest::RawContactInsert(std::string displayName) 134{ 135 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT); 136 OHOS::DataShare::DataShareValuesBucket rawContactValues; 137 rawContactValues.Put("display_name", displayName); 138 int64_t code = contactsDataAbility.Insert(uriRawContact, rawContactValues); 139 rawContactValues.Clear(); 140 return code; 141} 142 143int64_t MergeContactTest::ContactDataInsert( 144 int64_t rawContactId, std::string contentType, std::string detailInfo, std::string position) 145{ 146 OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA); 147 OHOS::DataShare::DataShareValuesBucket contactDataValues; 148 contactDataValues.Put("raw_contact_id", rawContactId); 149 contactDataValues.Put("content_type", contentType); 150 contactDataValues.Put("detail_info", detailInfo); 151 contactDataValues.Put("position", position); 152 int64_t code = contactsDataAbility.Insert(uriContactData, contactDataValues); 153 contactDataValues.Clear(); 154 return code; 155} 156 157HWTEST_F(MergeContactTest, merge_test_start, testing::ext::TestSize.Level1) 158{ 159 DeleteRawContact(); 160} 161 162/* 163 * @tc.number merge_Query_test_100 164 * @tc.name Insert contacts with the same name and different mobile numbers, 165 * and check whether the database can find the contacts that can be merged 166 * @tc.desc A: xiaowuwuwu 123456, B: xiaowuwuwu 1234567 167 * @tc.level Level1 168 * @tc.size MediumTest 169 * @tc.type Function 170 */ 171HWTEST_F(MergeContactTest, merge_Query_test_100, testing::ext::TestSize.Level1) 172{ 173 HILOG_INFO("--- merge_Query_test_100 query is starting! ---"); 174 int64_t rawOne = RawContactInsert("xiaowuww"); 175 EXPECT_GT(rawOne, 0); 176 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaowuww", ""); 177 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 178 HILOG_INFO("merge_Query_test_100 dataIdOne = %{public}ld", dataIdOne); 179 int64_t rawTwo = RawContactInsert("xiaowuww"); 180 EXPECT_GT(rawTwo, 0); 181 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaowuww", ""); 182 dataIdTwo = ContactDataInsert(rawTwo, "phone", "1234567", ""); 183 HILOG_INFO("merge_Query_test_100 dataIdTwo = %{public}ld", dataIdTwo); 184 int time = Time::SLEEP_TIME_MERGE; 185 std::chrono::milliseconds dura(time); 186 std::this_thread::sleep_for(dura); 187 OHOS::Uri uriQueryMergeList(ContactsUri::MERGE_LIST); 188 std::vector<std::string> columns; 189 OHOS::DataShare::DataSharePredicates predicates; 190 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = 191 contactsDataAbility.Query(uriQueryMergeList, predicates, columns); 192 int rowCount = 0; 193 resultSet->GetRowCount(rowCount); 194 EXPECT_EQ(2, rowCount); 195 std::vector<int> rawVector = GetMergeResultRawContactId(resultSet); 196 EXPECT_EQ(rawOne, rawVector[0]); 197 EXPECT_EQ(rawTwo, rawVector[1]); 198 DeleteRawContact(); 199} 200 201/* 202 * @tc.number merge_Update_test_200 203 * @tc.name Insert two contacts with the same name to check whether the database can be merged successfully 204 * @tc.desc A: xiaochenc, B: xiaochenc 205 * @tc.level Level1 206 * @tc.size MediumTest 207 * @tc.type Function 208 */ 209HWTEST_F(MergeContactTest, merge_Update_test_200, testing::ext::TestSize.Level1) 210{ 211 HILOG_INFO("--- merge_Update_test_200 Add is starting! ---"); 212 int64_t rawOne = RawContactInsert("xiaochenc"); 213 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaochenc", ""); 214 HILOG_INFO("merge_Update_test_200 : = %{public}ld", dataIdOne); 215 int64_t rawTwo = RawContactInsert("xiaochenc"); 216 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaochenc", ""); 217 HILOG_INFO("merge_Update_test_200 : = %{public}ld", dataIdTwo); 218 int time = 2000; 219 std::chrono::milliseconds dura(time); 220 std::this_thread::sleep_for(dura); 221 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 222 OHOS::DataShare::DataShareValuesBucket value; 223 OHOS::DataShare::DataSharePredicates predicates; 224 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 225 EXPECT_EQ(ret, 0); 226 std::vector<int64_t> resultIdVector; 227 resultIdVector.push_back(rawOne); 228 resultIdVector.push_back(rawTwo); 229 CheckMergeResultId(resultIdVector, true); 230 DeleteRawContact(); 231} 232 233/* 234 * @tc.number merge_Update_test_300 235 * @tc.name Insert two contacts with the same name. One of them has a mobile phone number. 236 * Check whether the database can be merged 237 * @tc.desc A: xiaomingmingming 123456, B: xiaomingmingming 238 * @tc.level Level1 239 * @tc.size MediumTest 240 * @tc.type Function 241 */ 242HWTEST_F(MergeContactTest, merge_Update_test_300, testing::ext::TestSize.Level1) 243{ 244 HILOG_INFO("--- merge_Update_test_300 Add is starting! ---"); 245 int64_t rawOne = RawContactInsert("xiaomingmm"); 246 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaomingmm", ""); 247 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 248 HILOG_INFO("merge_Update_test_300 : = %{public}ld", dataIdOne); 249 int64_t rawTwo = RawContactInsert("xiaomingmm"); 250 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaomingmm", ""); 251 HILOG_INFO("merge_Update_test_300 : = %{public}ld", dataIdTwo); 252 int time = Time::SLEEP_TIME_MERGE; 253 std::chrono::milliseconds dura(time); 254 std::this_thread::sleep_for(dura); 255 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 256 OHOS::DataShare::DataShareValuesBucket value; 257 OHOS::DataShare::DataSharePredicates predicates; 258 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 259 EXPECT_EQ(ret, -1); 260 OHOS::Uri uriManualMerge(ContactsUri::MANUAL_MERGE); 261 value.Clear(); 262 std::vector<std::string> ids; 263 ids.push_back(std::to_string(rawOne)); 264 ids.push_back(std::to_string(rawTwo)); 265 predicates.In("raw_contact_id", ids); 266 ret = contactsDataAbility.Update(uriManualMerge, predicates, value); 267 EXPECT_EQ(ret, 0); 268 std::vector<int64_t> resultIdVector; 269 resultIdVector.push_back(rawOne); 270 resultIdVector.push_back(rawTwo); 271 CheckMergeResultId(resultIdVector, true); 272 DeleteRawContact(); 273} 274 275/* 276 * @tc.number merge_Update_test_400 277 * @tc.name Insert two contacts with the same name. The mobile phone numbers of contacts a and B are the same. 278 * Check whether the database can be merged 279 * @tc.desc A: xiaohong、123456, B: xiaohong、123456 280 * @tc.level Level1 281 * @tc.size MediumTest 282 * @tc.type Function 283 */ 284HWTEST_F(MergeContactTest, merge_Update_test_400, testing::ext::TestSize.Level1) 285{ 286 HILOG_INFO("--- merge_Update_test_400 Add is starting! ---"); 287 int64_t rawOne = RawContactInsert("xiaohong"); 288 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaohong", ""); 289 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 290 HILOG_INFO("merge_Update_test_400 : = %{public}ld", dataIdOne); 291 int64_t rawTwo = RawContactInsert("xiaohong"); 292 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaohong", ""); 293 dataIdTwo = ContactDataInsert(rawTwo, "phone", "123456", ""); 294 HILOG_INFO("merge_Update_test_400 : = %{public}ld", dataIdTwo); 295 int time = Time::SLEEP_TIME_MERGE; 296 std::chrono::milliseconds dura(time); 297 std::this_thread::sleep_for(dura); 298 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 299 OHOS::DataShare::DataShareValuesBucket value; 300 OHOS::DataShare::DataSharePredicates predicates; 301 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 302 EXPECT_EQ(ret, 0); 303 std::vector<int64_t> resultIdVector; 304 resultIdVector.push_back(rawOne); 305 resultIdVector.push_back(rawTwo); 306 CheckMergeResultId(resultIdVector, true); 307 DeleteRawContact(); 308} 309 310/* 311 * @tc.number merge_Update_test_500 312 * @tc.name Insert two contacts with the same name. The mobile phone numbers of contacts a and B are different. 313 * Check whether the database can be merged 314 * @tc.desc A: xiaozhang、123456, B: xiaozhang、1234567 315 * @tc.level Level1 316 * @tc.size MediumTest 317 * @tc.type Function 318 */ 319HWTEST_F(MergeContactTest, merge_Update_test_500, testing::ext::TestSize.Level1) 320{ 321 HILOG_INFO("--- merge_Update_test_500 Add is starting! ---"); 322 int64_t rawOne = RawContactInsert("xiaozhang"); 323 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaozhang", ""); 324 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 325 HILOG_INFO("merge_Update_test_500 : = %{public}ld", dataIdOne); 326 int64_t rawTwo = RawContactInsert("xiaozhang"); 327 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaozhang", ""); 328 dataIdTwo = ContactDataInsert(rawTwo, "phone", "1234567", ""); 329 HILOG_INFO("merge_Update_test_500 : = %{public}ld", dataIdTwo); 330 int time = Time::SLEEP_TIME_MERGE; 331 std::chrono::milliseconds dura(time); 332 std::this_thread::sleep_for(dura); 333 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 334 OHOS::DataShare::DataShareValuesBucket value; 335 OHOS::DataShare::DataSharePredicates predicates; 336 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 337 EXPECT_EQ(ret, -1); 338 std::vector<int64_t> resultIdVector; 339 resultIdVector.push_back(rawOne); 340 resultIdVector.push_back(rawTwo); 341 CheckMergeResultId(resultIdVector, false); 342 343 OHOS::Uri uriManualMerge(ContactsUri::MANUAL_MERGE); 344 value.Clear(); 345 std::vector<std::string> ids; 346 ids.push_back(std::to_string(rawOne)); 347 ids.push_back(std::to_string(rawTwo)); 348 predicates.In("raw_contact_id", ids); 349 ret = contactsDataAbility.Update(uriManualMerge, predicates, value); 350 EXPECT_EQ(ret, 0); 351 CheckMergeResultId(resultIdVector, true); 352 DeleteRawContact(); 353} 354 355/* 356 * @tc.number merge_Update_test_600 357 * @tc.name Insert two contacts with the same name. Contact a has two mobile phone numbers 358 * and contact B has no mobile phone number. Check whether the database can be merged 359 * @tc.desc A: xiaozhou 123456/1234567, B: xiaozhou 360 * @tc.level Level1 361 * @tc.size MediumTest 362 * @tc.type Function 363 */ 364HWTEST_F(MergeContactTest, merge_Update_test_600, testing::ext::TestSize.Level1) 365{ 366 HILOG_INFO("--- merge_Update_test_600 Add is starting! ---"); 367 int64_t rawOne = RawContactInsert("xiaozhou"); 368 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaozhou", ""); 369 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 370 HILOG_INFO("merge_Update_test_600 dataIdOne_1 = %{public}ld", dataIdOne); 371 dataIdOne = ContactDataInsert(rawOne, "phone", "1234567", ""); 372 HILOG_INFO("merge_Update_test_600 dataIdOne_2 = %{public}ld", dataIdOne); 373 int64_t rawTwo = RawContactInsert("xiaozhou"); 374 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaozhou", ""); 375 HILOG_INFO("merge_Update_test_600 : = %{public}ld", dataIdTwo); 376 int time = Time::SLEEP_TIME_MERGE; 377 std::chrono::milliseconds dura(time); 378 std::this_thread::sleep_for(dura); 379 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 380 OHOS::DataShare::DataShareValuesBucket value; 381 OHOS::DataShare::DataSharePredicates predicates; 382 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 383 EXPECT_EQ(ret, -1); 384 std::vector<int64_t> resultIdVector; 385 resultIdVector.push_back(rawOne); 386 resultIdVector.push_back(rawTwo); 387 CheckMergeResultId(resultIdVector, false); 388 389 OHOS::Uri uriManualMerge(ContactsUri::MANUAL_MERGE); 390 value.Clear(); 391 std::vector<std::string> ids; 392 ids.push_back(std::to_string(rawOne)); 393 ids.push_back(std::to_string(rawTwo)); 394 predicates.In("raw_contact_id", ids); 395 ret = contactsDataAbility.Update(uriManualMerge, predicates, value); 396 EXPECT_EQ(ret, 0); 397 CheckMergeResultId(resultIdVector, true); 398 DeleteRawContact(); 399} 400 401/* 402 * @tc.number merge_Update_test_700 403 * @tc.name Insert two contacts with the same name. Both contacts a and B have the same mobile phone numbers. 404 * Check whether the database can be merged 405 * @tc.desc A: xiaobai、123456/1234567, B: xiaobai、123456/1234567 406 * @tc.level Level1 407 * @tc.size MediumTest 408 * @tc.type Function 409 */ 410HWTEST_F(MergeContactTest, merge_Update_test_700, testing::ext::TestSize.Level1) 411{ 412 HILOG_INFO("--- merge_Update_test_700 Add is starting! ---"); 413 int64_t rawOne = RawContactInsert("xiaobai"); 414 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaobai", ""); 415 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 416 HILOG_INFO("merge_Update_test_700 dataIdOne_1 = %{public}ld", dataIdOne); 417 dataIdOne = ContactDataInsert(rawOne, "phone", "1234567", ""); 418 HILOG_INFO("merge_Update_test_700 dataIdOne_2 = %{public}ld", dataIdOne); 419 int64_t rawTwo = RawContactInsert("xiaobai"); 420 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaobai", ""); 421 dataIdTwo = ContactDataInsert(rawTwo, "phone", "123456", ""); 422 HILOG_INFO("merge_Update_test_700 dataIdTwo_1 = %{public}ld", dataIdTwo); 423 dataIdTwo = ContactDataInsert(rawTwo, "phone", "1234567", ""); 424 HILOG_INFO("merge_Update_test_700 dataIdTwo_2 = %{public}ld", dataIdTwo); 425 int time = Time::SLEEP_TIME_MERGE; 426 std::chrono::milliseconds dura(time); 427 std::this_thread::sleep_for(dura); 428 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 429 OHOS::DataShare::DataShareValuesBucket value; 430 OHOS::DataShare::DataSharePredicates predicates; 431 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 432 EXPECT_EQ(ret, 0); 433 std::vector<int64_t> resultIdVector; 434 resultIdVector.push_back(rawOne); 435 resultIdVector.push_back(rawTwo); 436 CheckMergeResultId(resultIdVector, true); 437 DeleteRawContact(); 438} 439 440/* 441 * @tc.number merge_Update_test_800 442 * @tc.name Insert two contacts with the same name. Each contact a and B has two mobile phone numbers, one of which 443 * is the same. Check whether the database can be merged 444 * @tc.desc A: xiaomi、123456/1234567, B: xiaomi、123456/12345678 445 * @tc.level Level1 446 * @tc.size MediumTest 447 * @tc.type Function 448 */ 449HWTEST_F(MergeContactTest, merge_Update_test_800, testing::ext::TestSize.Level1) 450{ 451 HILOG_INFO("--- merge_Update_test_800 Add is starting! ---"); 452 int64_t rawOne = RawContactInsert("xiaomi"); 453 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaomi", ""); 454 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 455 HILOG_INFO("merge_Update_test_800 dataIdOne_1 = %{public}ld", dataIdOne); 456 dataIdOne = ContactDataInsert(rawOne, "phone", "1234567", ""); 457 HILOG_INFO("merge_Update_test_800 dataIdOne_2 = %{public}ld", dataIdOne); 458 int64_t rawTwo = RawContactInsert("xiaomi"); 459 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaomi", ""); 460 dataIdTwo = ContactDataInsert(rawTwo, "phone", "123456", ""); 461 HILOG_INFO("merge_Update_test_800 dataIdTwo_1 = %{public}ld", dataIdTwo); 462 dataIdTwo = ContactDataInsert(rawTwo, "phone", "12345678", ""); 463 HILOG_INFO("merge_Update_test_800 dataIdTwo_2 = %{public}ld", dataIdTwo); 464 int time = Time::SLEEP_TIME_MERGE; 465 std::chrono::milliseconds dura(time); 466 std::this_thread::sleep_for(dura); 467 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 468 OHOS::DataShare::DataShareValuesBucket value; 469 OHOS::DataShare::DataSharePredicates predicates; 470 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 471 EXPECT_EQ(ret, -1); 472 std::vector<int64_t> resultIdVector; 473 resultIdVector.push_back(rawOne); 474 resultIdVector.push_back(rawTwo); 475 CheckMergeResultId(resultIdVector, false); 476 477 OHOS::Uri uriManualMerge(ContactsUri::MANUAL_MERGE); 478 value.Clear(); 479 std::vector<std::string> ids; 480 ids.push_back(std::to_string(rawOne)); 481 ids.push_back(std::to_string(rawTwo)); 482 predicates.In("raw_contact_id", ids); 483 ret = contactsDataAbility.Update(uriManualMerge, predicates, value); 484 EXPECT_EQ(ret, 0); 485 CheckMergeResultId(resultIdVector, true); 486 DeleteRawContact(); 487} 488 489/* 490 * @tc.number merge_Update_test_900 491 * @tc.name Insert two contacts with the same name. Contact a has two mobile phone numbers, and contact B has one 492 * mobile phone number and is the same as one of the mobile phone numbers of A. check whether the database can be merged 493 * @tc.desc A: daniu、123456/1234567, B: daniu、123456 494 * @tc.level Level1 495 * @tc.size MediumTest 496 * @tc.type Function 497 */ 498HWTEST_F(MergeContactTest, merge_Update_test_900, testing::ext::TestSize.Level1) 499{ 500 HILOG_INFO("--- merge_Update_test_900 Add is starting! ---"); 501 int64_t rawOne = RawContactInsert("daniu"); 502 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "daniu", ""); 503 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 504 HILOG_INFO("merge_Update_test_900 dataIdOne_1 = %{public}ld", dataIdOne); 505 dataIdOne = ContactDataInsert(rawOne, "phone", "1234567", ""); 506 HILOG_INFO("merge_Update_test_900 dataIdOne_2 = %{public}ld", dataIdOne); 507 int64_t rawTwo = RawContactInsert("daniu"); 508 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "daniu", ""); 509 dataIdTwo = ContactDataInsert(rawTwo, "phone", "123456", ""); 510 HILOG_INFO("merge_Update_test_900 dataIdTwo = %{public}ld", dataIdTwo); 511 int time = Time::SLEEP_TIME_MERGE; 512 std::chrono::milliseconds dura(time); 513 std::this_thread::sleep_for(dura); 514 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 515 OHOS::DataShare::DataShareValuesBucket value; 516 OHOS::DataShare::DataSharePredicates predicates; 517 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 518 EXPECT_EQ(ret, -1); 519 OHOS::Uri uriManualMerge(ContactsUri::MANUAL_MERGE); 520 value.Clear(); 521 std::vector<std::string> ids; 522 ids.push_back(std::to_string(rawOne)); 523 ids.push_back(std::to_string(rawTwo)); 524 predicates.In("raw_contact_id", ids); 525 ret = contactsDataAbility.Update(uriManualMerge, predicates, value); 526 EXPECT_EQ(ret, 0); 527 std::vector<int64_t> resultIdVector; 528 resultIdVector.push_back(rawOne); 529 resultIdVector.push_back(rawTwo); 530 CheckMergeResultId(resultIdVector, true); 531 DeleteRawContact(); 532} 533 534/* 535 * @tc.number merge_Update_test_1000 536 * @tc.name Insert two contacts with the same name. Contact a has two mobile phone numbers 537 * and contact B has one mobile phone number. Check whether the database can be merged 538 * @tc.desc A: mazi、123456/1234567, B: mazi、123456789 539 * @tc.level Level1 540 * @tc.size MediumTest 541 * @tc.type Function 542 */ 543HWTEST_F(MergeContactTest, merge_Update_test_1000, testing::ext::TestSize.Level1) 544{ 545 HILOG_INFO("--- merge_Update_test_1000 Add is starting! ---"); 546 int64_t rawOne = RawContactInsert("mazi"); 547 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "mazi", ""); 548 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 549 HILOG_INFO("merge_Update_test_1000 dataIdOne_1 = %{public}ld", dataIdOne); 550 dataIdOne = ContactDataInsert(rawOne, "phone", "1234567", ""); 551 HILOG_INFO("merge_Update_test_1000 dataIdOne_2 = %{public}ld", dataIdOne); 552 int64_t rawTwo = RawContactInsert("mazi"); 553 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "mazi", ""); 554 dataIdTwo = ContactDataInsert(rawTwo, "phone", "123456789", ""); 555 HILOG_INFO("merge_Update_test_1000 dataIdTwo = %{public}ld", dataIdTwo); 556 int time = Time::SLEEP_TIME_MERGE; 557 std::chrono::milliseconds dura(time); 558 std::this_thread::sleep_for(dura); 559 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 560 OHOS::DataShare::DataShareValuesBucket value; 561 OHOS::DataShare::DataSharePredicates predicates; 562 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 563 EXPECT_EQ(ret, -1); 564 OHOS::Uri uriManualMerge(ContactsUri::MANUAL_MERGE); 565 value.Clear(); 566 std::vector<std::string> ids; 567 ids.push_back(std::to_string(rawOne)); 568 ids.push_back(std::to_string(rawTwo)); 569 predicates.In("raw_contact_id", ids); 570 ret = contactsDataAbility.Update(uriManualMerge, predicates, value); 571 EXPECT_EQ(ret, 0); 572 std::vector<int64_t> resultIdVector; 573 resultIdVector.push_back(rawOne); 574 resultIdVector.push_back(rawTwo); 575 CheckMergeResultId(resultIdVector, true); 576 DeleteRawContact(); 577} 578 579/* 580 * @tc.number abnormal_merge_Update_test_1100 581 * @tc.name After consolidation, it is transferred to - 1 for splitting 582 * @tc.desc Exception use case: Merge and pass -1 to split 583 * @tc.level Level1 584 * @tc.size MediumTest 585 * @tc.type Function 586 */ 587HWTEST_F(MergeContactTest, abnormal_merge_Update_test_1100, testing::ext::TestSize.Level1) 588{ 589 HILOG_INFO("--- abnormal_merge_Update_test_1100 Add is starting! ---"); 590 int64_t rawOne = RawContactInsert("xiaocai"); 591 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaocai", ""); 592 HILOG_INFO("abnormal_merge_Update_test_1100 : = %{public}ld", dataIdOne); 593 int64_t rawTwo = RawContactInsert("xiaocai"); 594 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaocai", ""); 595 HILOG_INFO("abnormal_merge_Update_test_1100 : = %{public}ld", dataIdTwo); 596 int time = Time::SLEEP_TIME_MERGE; 597 std::chrono::milliseconds dura(time); 598 std::this_thread::sleep_for(dura); 599 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 600 OHOS::DataShare::DataShareValuesBucket valueOne; 601 OHOS::DataShare::DataSharePredicates predicates; 602 contactsDataAbility.Update(uriAutoMerge, predicates, valueOne); 603 OHOS::Uri uriSplitContact(ContactsUri::SPLIT_CONTACT); 604 OHOS::DataShare::DataShareValuesBucket valueTwo; 605 std::vector<std::string> ids; 606 ids.push_back("-1"); 607 predicates.In("raw_contact_id", ids); 608 int ret = contactsDataAbility.Update(uriSplitContact, predicates, valueTwo); 609 EXPECT_EQ(ret, -1); 610 std::vector<int64_t> resultIdVector; 611 resultIdVector.push_back(rawOne); 612 resultIdVector.push_back(rawTwo); 613 CheckMergeResultId(resultIdVector, true); 614 DeleteRawContact(); 615} 616 617/* 618 * @tc.number merge_Update_test_1200 619 * @tc.name Insert multiple automatically merged contacts to check whether the database can be merged 620 * @tc.desc A: xiaoliu、123456, B: xiaoliu、123456, C:xiaoliu、123456 621 * @tc.level Level1 622 * @tc.size MediumTest 623 * @tc.type Function 624 */ 625HWTEST_F(MergeContactTest, merge_Update_test_1200, testing::ext::TestSize.Level1) 626{ 627 int64_t rawOne = RawContactInsert("xiaoliu"); 628 int64_t dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 629 dataIdOne = ContactDataInsert(rawOne, "name", "xiaoliu", ""); 630 HILOG_INFO("merge_Update_test_1200 : = %{public}ld", dataIdOne); 631 int64_t rawTwo = RawContactInsert("xiaoliu"); 632 int64_t dataIdTwo = ContactDataInsert(rawTwo, "phone", "123456", ""); 633 dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaoliu", ""); 634 HILOG_INFO("merge_Update_test_1200 : = %{public}ld", dataIdTwo); 635 int64_t rawThree = RawContactInsert("xiaoliu"); 636 int64_t dataIdThree = ContactDataInsert(rawThree, "phone", "123456", ""); 637 dataIdThree = ContactDataInsert(rawThree, "name", "xiaoliu", ""); 638 HILOG_INFO("merge_Update_test_1200 : = %{public}ld", dataIdThree); 639 int time = Time::SLEEP_TIME_MERGE; 640 std::chrono::milliseconds dura(time); 641 std::this_thread::sleep_for(dura); 642 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 643 OHOS::DataShare::DataShareValuesBucket value; 644 OHOS::DataShare::DataSharePredicates predicates; 645 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 646 EXPECT_EQ(ret, 0); 647 std::vector<std::string> ids; 648 ids.push_back(std::to_string(rawOne)); 649 ids.push_back(std::to_string(rawTwo)); 650 ids.push_back(std::to_string(rawThree)); 651 std::vector<int64_t> resultIdVector; 652 resultIdVector.push_back(rawOne); 653 resultIdVector.push_back(rawTwo); 654 CheckMergeResultId(resultIdVector, true); 655 HILOG_INFO("ret : %{public}d ", ret); 656 DeleteRawContact(); 657} 658 659/* 660 * @tc.number merge_Update_test_1300 661 * @tc.name Insert two automatically merged contacts, modify a's name, 662 * and then automatically merge to see whether the database can be merged 663 * @tc.desc A: xiaohua、123456, B: xiaohua、123456 --> A: xiaohua、123456, B: dayu、123456 664 * @tc.level Level1 665 * @tc.size MediumTest 666 * @tc.type Function 667 */ 668HWTEST_F(MergeContactTest, merge_Update_test_1300, testing::ext::TestSize.Level1) 669{ 670 HILOG_INFO("--- merge_Update_test_1300 Add is starting! ---"); 671 int64_t rawOne = RawContactInsert("xiaohua"); 672 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaohua", ""); 673 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 674 HILOG_INFO("merge_Update_test_1300 dataIdOne = %{public}ld", dataIdOne); 675 int64_t rawTwo = RawContactInsert("xiaohua"); 676 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaohua", ""); 677 dataIdTwo = ContactDataInsert(rawTwo, "phone", "123456", ""); 678 HILOG_INFO("merge_Update_test_1300 dataIdTwo = %{public}ld", dataIdTwo); 679 680 OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA); 681 OHOS::DataShare::DataShareValuesBucket values; 682 values.Put("detail_info", "dayuy"); 683 OHOS::DataShare::DataSharePredicates predicates; 684 predicates.EqualTo("raw_contact_id", std::to_string(rawTwo)); 685 predicates.And(); 686 predicates.EqualTo("type_id", "6"); 687 contactsDataAbility.Update(uriContactData, predicates, values); 688 int time = Time::SLEEP_TIME_MERGE; 689 std::chrono::milliseconds dura(time); 690 std::this_thread::sleep_for(dura); 691 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 692 values.Clear(); 693 OHOS::DataShare::DataSharePredicates predicates2; 694 int ret = contactsDataAbility.Update(uriAutoMerge, predicates2, values); 695 EXPECT_EQ(ret, -1); 696 std::vector<std::string> ids; 697 ids.push_back(std::to_string(rawOne)); 698 ids.push_back(std::to_string(rawTwo)); 699 std::vector<int64_t> resultIdVector; 700 resultIdVector.push_back(rawOne); 701 resultIdVector.push_back(rawTwo); 702 CheckMergeResultId(resultIdVector, false); 703 DeleteRawContact(); 704} 705 706/* 707 * @tc.number merge_Update_test_1400 708 * @tc.name Insert two automatically merged contacts, modify a's mobile phone number, 709 * and then manually merge contacts to see whether the database can be merged 710 * @tc.desc A: xiaobei、123456, B: xiaobei、123456 --> A: xiaobei、123456, B: xiaobei、1234567 711 * @tc.level Level1 712 * @tc.size MediumTest 713 * @tc.type Function 714 */ 715HWTEST_F(MergeContactTest, merge_Update_test_1400, testing::ext::TestSize.Level1) 716{ 717 HILOG_INFO("--- merge_Update_test_1400 Add is starting! ---"); 718 int64_t rawOne = RawContactInsert("xiaobei"); 719 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaobei", ""); 720 dataIdOne = ContactDataInsert(rawOne, "phone", "17612345689", ""); 721 HILOG_INFO("merge_Update_test_1400 dataIdOne = %{public}ld", dataIdOne); 722 int64_t rawTwo = RawContactInsert("xiaobei"); 723 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaobei", ""); 724 dataIdTwo = ContactDataInsert(rawTwo, "phone", "17612345689", ""); 725 HILOG_INFO("merge_Update_test_1400 dataIdTwo = %{public}ld", dataIdTwo); 726 727 OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA); 728 OHOS::DataShare::DataShareValuesBucket values; 729 values.Put("detail_info", "18355421566"); 730 OHOS::DataShare::DataSharePredicates predicates; 731 predicates.EqualTo("raw_contact_id", std::to_string(rawTwo)); 732 predicates.And(); 733 predicates.EqualTo("type_id", "5"); 734 contactsDataAbility.Update(uriContactData, predicates, values); 735 int time = Time::SLEEP_TIME_MERGE; 736 std::chrono::milliseconds dura(time); 737 std::this_thread::sleep_for(dura); 738 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 739 values.Clear(); 740 OHOS::DataShare::DataSharePredicates predicates2; 741 int ret = contactsDataAbility.Update(uriAutoMerge, predicates2, values); 742 EXPECT_EQ(ret, -1); 743 OHOS::Uri uriManualMerge(ContactsUri::MANUAL_MERGE); 744 values.Clear(); 745 std::vector<std::string> ids; 746 ids.push_back(std::to_string(rawOne)); 747 ids.push_back(std::to_string(rawTwo)); 748 predicates2.In("raw_contact_id", ids); 749 ret = contactsDataAbility.Update(uriManualMerge, predicates2, values); 750 EXPECT_EQ(ret, 0); 751 std::vector<int64_t> resultIdVector; 752 resultIdVector.push_back(rawOne); 753 resultIdVector.push_back(rawTwo); 754 CheckMergeResultId(resultIdVector, true); 755 DeleteRawContact(); 756} 757 758/* 759 * @tc.number merge_Update_test_1500 760 * @tc.name After consolidation, it is transferred to rowid1 for splitting 761 * @tc.desc After merging, pass rowId1 to split 762 * @tc.level Level1 763 * @tc.size MediumTest 764 * @tc.type Function 765 */ 766 767HWTEST_F(MergeContactTest, merge_Update_test_1500, testing::ext::TestSize.Level1) 768{ 769 HILOG_INFO("--- merge_Update_test_1500 Add is starting! ---"); 770 int64_t rawOne = RawContactInsert("xiaolil"); 771 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaolil", ""); 772 HILOG_INFO("merge_Update_test_1500 : = %{public}ld", dataIdOne); 773 int64_t rawTwo = RawContactInsert("xiaoli"); 774 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaolil", ""); 775 HILOG_INFO("merge_Update_test_1500 : = %{public}ld", dataIdTwo); 776 int time = Time::SLEEP_TIME_MERGE; 777 std::chrono::milliseconds dura(time); 778 std::this_thread::sleep_for(dura); 779 int ret; 780 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 781 OHOS::DataShare::DataShareValuesBucket valueOne; 782 OHOS::DataShare::DataSharePredicates predicates; 783 ret = contactsDataAbility.Update(uriAutoMerge, predicates, valueOne); 784 EXPECT_EQ(ret, 0); 785 std::vector<int64_t> resultIdVector; 786 resultIdVector.push_back(rawOne); 787 resultIdVector.push_back(rawTwo); 788 CheckMergeResultId(resultIdVector, true); 789 790 OHOS::Uri uriSplitContact(ContactsUri::SPLIT_CONTACT); 791 OHOS::DataShare::DataShareValuesBucket valueTwo; 792 std::vector<std::string> ids; 793 ids.push_back(std::to_string(rawOne)); 794 predicates.In("raw_contact_id", ids); 795 ret = contactsDataAbility.Update(uriSplitContact, predicates, valueTwo); 796 EXPECT_EQ(ret, 0); 797 CheckMergeResultId(resultIdVector, false); 798 DeleteRawContact(); 799} 800 801/* 802 * @tc.number abnormal_merge_Query_test_1600 803 * @tc.name Insert contacts with the same name and different mobile numbers. 804 * The URI address is wrong. Check whether the database can find the contacts that can be merged 805 * @tc.desc A: xiaoma 123456, B: xiaoma 1234567 806 * @tc.level Level1 807 * @tc.size MediumTest 808 * @tc.type Function 809 */ 810HWTEST_F(MergeContactTest, abnormal_merge_Query_test_1600, testing::ext::TestSize.Level1) 811{ 812 HILOG_INFO("--- abnormal_merge_Query_test_1600 Add is starting! ---"); 813 int64_t rawOne = RawContactInsert("xiaoma"); 814 EXPECT_GT(rawOne, 0); 815 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaoma", ""); 816 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 817 HILOG_INFO("abnormal_merge_Query_test_1600 dataIdOne = %{public}ld", dataIdOne); 818 int64_t rawTwo = RawContactInsert("xiaoma"); 819 EXPECT_GT(rawTwo, 0); 820 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaoma", ""); 821 dataIdOne = ContactDataInsert(rawTwo, "phone", "1234567", ""); 822 HILOG_INFO("abnormal_merge_Query_test_1600 dataIdTwo = %{public}ld", dataIdTwo); 823 int time = Time::SLEEP_TIME_MERGE; 824 std::chrono::milliseconds dura(time); 825 std::this_thread::sleep_for(dura); 826 OHOS::Uri uriQueryMergeList(ContactsUri::MERGE_LIST_ERROR); 827 std::vector<std::string> columns; 828 OHOS::DataShare::DataSharePredicates predicates; 829 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = 830 contactsDataAbility.Query(uriQueryMergeList, predicates, columns); 831 EXPECT_EQ(resultSet, nullptr); 832 DeleteRawContact(); 833} 834 835/* 836 * @tc.number abnormal_merge_Update_test_1700 837 * @tc.name Parameter URI address error 838 * @tc.desc Passing an error auto_merge uri 839 * @tc.level Level1 840 * @tc.size MediumTest 841 * @tc.type Function 842 */ 843HWTEST_F(MergeContactTest, abnormal_merge_Update_test_1700, testing::ext::TestSize.Level1) 844{ 845 HILOG_INFO("--- abnormal_merge_Update_test_1700 Add is starting! ---"); 846 int64_t rawOne = RawContactInsert("xiaoqian"); 847 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaoqian", ""); 848 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 849 int64_t rawTwo = RawContactInsert("xiaoqian"); 850 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaoqian", ""); 851 dataIdTwo = ContactDataInsert(rawTwo, "phone", "123456", ""); 852 HILOG_INFO("abnormal_merge_Update_test_1700 dataIdTwo = %{public}ld", dataIdTwo); 853 int time = Time::SLEEP_TIME_MERGE; 854 std::chrono::milliseconds dura(time); 855 std::this_thread::sleep_for(dura); 856 OHOS::Uri uriAutoMerge(ContactsUri::MERGE_ERROR); 857 OHOS::DataShare::DataShareValuesBucket value; 858 OHOS::DataShare::DataSharePredicates predicates; 859 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 860 EXPECT_EQ(ret, -1); 861 std::vector<std::string> ids; 862 ids.push_back(std::to_string(rawOne)); 863 ids.push_back(std::to_string(rawTwo)); 864 std::vector<int64_t> resultIdVector; 865 resultIdVector.push_back(rawOne); 866 resultIdVector.push_back(rawTwo); 867 CheckMergeResultId(resultIdVector, false); 868 869 HILOG_INFO("ret : %{public}d ", ret); 870 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT); 871 predicates.EqualTo("id", std::to_string(rawOne)); 872 predicates.Or(); 873 predicates.EqualTo("id", std::to_string(rawTwo)); 874 contactsDataAbility.Delete(uriRawContact, predicates); 875 DeleteRawContact(); 876} 877 878/* 879 * @tc.number abnormal_merge_Update_test_1800 880 * @tc.name Insert two contacts with different names and merge them automatically to see if the database can be 881 * merged 882 * @tc.desc A: xiaosun、123456, B: xiaomei、123456 883 * @tc.level Level1 884 * @tc.size MediumTest 885 * @tc.type Function 886 */ 887HWTEST_F(MergeContactTest, abnormal_merge_Update_test_1800, testing::ext::TestSize.Level1) 888{ 889 HILOG_INFO("--- abnormal_merge_Update_test_1800 Add is starting! ---"); 890 int64_t rawOne = RawContactInsert("xiaosun"); 891 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaosun", ""); 892 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 893 HILOG_INFO("abnormal_merge_Update_test_1800 dataIdOne = %{public}ld", dataIdOne); 894 int64_t rawTwo = RawContactInsert("xiaomei"); 895 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaomei", ""); 896 dataIdTwo = ContactDataInsert(rawTwo, "phone", "123456", ""); 897 HILOG_INFO("abnormal_merge_Update_test_1800 dataIdTwo = %{public}ld", dataIdTwo); 898 int time = Time::SLEEP_TIME_MERGE; 899 std::chrono::milliseconds dura(time); 900 std::this_thread::sleep_for(dura); 901 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 902 OHOS::DataShare::DataShareValuesBucket value; 903 OHOS::DataShare::DataSharePredicates predicates; 904 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 905 EXPECT_EQ(ret, -1); 906 HILOG_INFO("ret : %{public}d ", ret); 907 std::vector<std::string> ids; 908 ids.push_back(std::to_string(rawOne)); 909 ids.push_back(std::to_string(rawTwo)); 910 std::vector<int64_t> resultIdVector; 911 resultIdVector.push_back(rawOne); 912 resultIdVector.push_back(rawTwo); 913 CheckMergeResultId(resultIdVector, false); 914 DeleteRawContact(); 915} 916 917/* 918 * @tc.number abnormal_merge_Update_test_1900 919 * @tc.name Insert two contacts with different names for automatic merging and manual merging 920 * @tc.desc A: bob2300, B: lileibob2300 --> A: bob2300, B: lileibob2300 921 * @tc.level Level1 922 * @tc.size MediumTest 923 * @tc.type Function 924 */ 925HWTEST_F(MergeContactTest, abnormal_merge_Update_test_1900, testing::ext::TestSize.Level1) 926{ 927 HILOG_INFO("--- abnormal_merge_Update_test_1900 Add is starting! ---"); 928 int64_t rawOne = RawContactInsert("bob2300"); 929 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "bob2300", ""); 930 HILOG_INFO("abnormal_merge_Update_test_1900 dataIdOne = %{public}ld", dataIdOne); 931 int64_t rawTwo = RawContactInsert("lileibob2300"); 932 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "lileibob2300", ""); 933 HILOG_INFO("abnormal_merge_Update_test_1900 dataIdTwo = %{public}ld", dataIdTwo); 934 int time = Time::SLEEP_TIME_MERGE; 935 std::chrono::milliseconds dura(time); 936 std::this_thread::sleep_for(dura); 937 938 OHOS::DataShare::DataShareValuesBucket values; 939 OHOS::DataShare::DataSharePredicates predicates; 940 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 941 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, values); 942 EXPECT_EQ(ret, -1); 943 std::this_thread::sleep_for(dura); 944 OHOS::Uri uriManualMerge(ContactsUri::MANUAL_MERGE); 945 values.Clear(); 946 std::vector<std::string> ids; 947 ids.push_back(std::to_string(rawOne)); 948 ids.push_back(std::to_string(rawTwo)); 949 predicates.In("raw_contact_id", ids); 950 ret = contactsDataAbility.Update(uriManualMerge, predicates, values); 951 EXPECT_EQ(ret, -1); 952 DeleteRawContact(); 953} 954 955/* 956 * @tc.number abnormal_merge_Update_test_2000 957 * @tc.name Pass in the wrong field name -- nameee, name 958 * @tc.desc A: xiaowang, B: xiaowang 959 * @tc.level Level1 960 * @tc.size MediumTest 961 * @tc.type Function 962 */ 963HWTEST_F(MergeContactTest, abnormal_merge_Update_test_2000, testing::ext::TestSize.Level1) 964{ 965 HILOG_INFO("--- abnormal_merge_Update_test_2000 Add is starting! ---"); 966 int64_t rawOne = RawContactInsert("xiaowang"); 967 EXPECT_GT(rawOne, 0); 968 int64_t dataIdOne = ContactDataInsert(rawOne, "nameee", "xiaowang", ""); 969 HILOG_INFO("abnormal_merge_Update_test_2000 dataIdOne = %{public}ld", dataIdOne); 970 int64_t rawTwo = RawContactInsert("xiaowang"); 971 EXPECT_GT(rawOne, 0); 972 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaowang", ""); 973 HILOG_INFO("abnormal_merge_Update_test_2000 dataIdTwo = %{public}ld", dataIdTwo); 974 int time = Time::SLEEP_TIME_MERGE; 975 std::chrono::milliseconds dura(time); 976 std::this_thread::sleep_for(dura); 977 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 978 OHOS::DataShare::DataShareValuesBucket value; 979 OHOS::DataShare::DataSharePredicates predicates; 980 int ret = contactsDataAbility.Update(uriAutoMerge, predicates, value); 981 EXPECT_EQ(ret, -1); 982 std::vector<std::string> ids; 983 ids.push_back(std::to_string(rawOne)); 984 ids.push_back(std::to_string(rawTwo)); 985 std::vector<int64_t> resultIdVector; 986 resultIdVector.push_back(rawOne); 987 resultIdVector.push_back(rawTwo); 988 CheckMergeResultId(resultIdVector, false); 989 990 HILOG_INFO("ret : %{public}d ", ret); 991 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT); 992 predicates.EqualTo("id", std::to_string(dataIdOne)); 993 predicates.Or(); 994 predicates.EqualTo("id", std::to_string(dataIdTwo)); 995 contactsDataAbility.Delete(uriRawContact, predicates); 996 DeleteRawContact(); 997} 998 999/* 1000 * @tc.number abnormal_merge_Update_test_2100 1001 * @tc.name After consolidation, it is transferred to 0 for splitting 1002 * @tc.desc Exception use case: Merge and pass 0 to split 1003 * @tc.level Level1 1004 * @tc.size MediumTest 1005 * @tc.type Function 1006 */ 1007HWTEST_F(MergeContactTest, abnormal_merge_Update_test_2100, testing::ext::TestSize.Level1) 1008{ 1009 HILOG_INFO("--- abnormal_merge_Update_test_2100 Add is starting! ---"); 1010 int64_t rawOne = RawContactInsert("xiaocheng"); 1011 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaocheng", ""); 1012 HILOG_INFO("abnormal_merge_Update_test_2100 : = %{public}ld", dataIdOne); 1013 int64_t rawTwo = RawContactInsert("xiaocheng"); 1014 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaocheng", ""); 1015 HILOG_INFO("abnormal_merge_Update_test_2100 : = %{public}ld", dataIdTwo); 1016 std::chrono::milliseconds dura(Time::SLEEP_TIME_MERGE); 1017 std::this_thread::sleep_for(dura); 1018 OHOS::Uri uriAutoMerge(ContactsUri::AUTO_MERGE); 1019 OHOS::DataShare::DataShareValuesBucket valueOne; 1020 OHOS::DataShare::DataSharePredicates predicates; 1021 contactsDataAbility.Update(uriAutoMerge, predicates, valueOne); 1022 OHOS::Uri uriSplitContact(ContactsUri::SPLIT_CONTACT); 1023 OHOS::DataShare::DataShareValuesBucket valueTwo; 1024 std::vector<std::string> ids; 1025 ids.push_back("0"); 1026 predicates.In("raw_contact_id", ids); 1027 int ret = contactsDataAbility.Update(uriSplitContact, predicates, valueTwo); 1028 EXPECT_EQ(ret, -1); 1029 1030 std::vector<int64_t> resultIdVector; 1031 resultIdVector.push_back(rawOne); 1032 resultIdVector.push_back(rawTwo); 1033 CheckMergeResultId(resultIdVector, true); 1034 DeleteRawContact(); 1035} 1036 1037/* 1038 * @tc.number merge_Update_test_2200 1039 * @tc.name Insert multiple manually merged contacts to check whether the database can be merged 1040 * @tc.desc A: xiaocai、1234567, B: xiaocai、123456, C:xiaocai、12345678 1041 * @tc.level Level1 1042 * @tc.size MediumTest 1043 * @tc.type Function 1044 */ 1045HWTEST_F(MergeContactTest, merge_Update_test_2200, testing::ext::TestSize.Level1) 1046{ 1047 int64_t rawOne = RawContactInsert("xiaocai"); 1048 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaocai", ""); 1049 dataIdOne = ContactDataInsert(rawOne, "phone", "1234567", ""); 1050 HILOG_INFO("merge_Update_test_2200 : = %{public}ld", dataIdOne); 1051 int64_t rawTwo = RawContactInsert("xiaocai"); 1052 int64_t dataIdTwo = ContactDataInsert(rawTwo, "phone", "123456", ""); 1053 dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaocai", ""); 1054 HILOG_INFO("merge_Update_test_2200 : = %{public}ld", dataIdTwo); 1055 int64_t rawThree = RawContactInsert("xiaocai"); 1056 int64_t dataIdThree = ContactDataInsert(rawThree, "phone", "12345678", ""); 1057 dataIdThree = ContactDataInsert(rawThree, "name", "xiaocai", ""); 1058 HILOG_INFO("merge_Update_test_2200 : = %{public}ld", dataIdThree); 1059 int time = Time::SLEEP_TIME_MERGE; 1060 std::chrono::milliseconds dura(time); 1061 std::this_thread::sleep_for(dura); 1062 OHOS::Uri uriManualMerge(ContactsUri::MANUAL_MERGE); 1063 OHOS::DataShare::DataShareValuesBucket value; 1064 OHOS::DataShare::DataSharePredicates predicates; 1065 std::vector<std::string> ids; 1066 ids.push_back(std::to_string(rawOne)); 1067 ids.push_back(std::to_string(rawTwo)); 1068 ids.push_back(std::to_string(rawThree)); 1069 predicates.In("raw_contact_id", ids); 1070 int ret = contactsDataAbility.Update(uriManualMerge, predicates, value); 1071 EXPECT_EQ(ret, 0); 1072 std::vector<int64_t> resultIdVector; 1073 resultIdVector.push_back(rawOne); 1074 resultIdVector.push_back(rawTwo); 1075 CheckMergeResultId(resultIdVector, true); 1076 HILOG_INFO("ret : %{public}d ", ret); 1077 DeleteRawContact(); 1078} 1079 1080/* 1081 * @tc.number merge_Query_test_2300 1082 * @tc.name Insert two contacts with the same name to check whether the database 1083 * can find the contacts that can be merged 1084 * @tc.desc A: xsiaowuwwwww B: xsiaowuwwwww 1085 * @tc.level Level1 1086 * @tc.size MediumTest 1087 * @tc.type Function 1088 */ 1089HWTEST_F(MergeContactTest, merge_Query_test_2300, testing::ext::TestSize.Level1) 1090{ 1091 HILOG_INFO("--- merge_Query_test_2300 query is starting! ---"); 1092 int64_t rawOne = RawContactInsert("xsiaowuwwwww"); 1093 EXPECT_GT(rawOne, 0); 1094 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xsiaowuwwwww", ""); 1095 HILOG_INFO("merge_Query_test_2300 dataIdOne = %{public}ld", dataIdOne); 1096 int64_t rawTwo = RawContactInsert("xsiaowuwwwww"); 1097 EXPECT_GT(rawTwo, 0); 1098 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xsiaowuwwwww", ""); 1099 HILOG_INFO("merge_Query_test_2300 dataIdTwo = %{public}ld", dataIdTwo); 1100 int time = Time::SLEEP_TIME_MERGE; 1101 std::chrono::milliseconds dura(time); 1102 std::this_thread::sleep_for(dura); 1103 std::vector<std::string> columns; 1104 OHOS::DataShare::DataSharePredicates predicates; 1105 predicates.BeginWrap(); 1106 predicates.EqualTo("id", std::to_string(rawOne)); 1107 predicates.Or(); 1108 predicates.EqualTo("id", std::to_string(rawTwo)); 1109 predicates.EndWrap(); 1110 predicates.And(); 1111 predicates.EqualTo("merge_mode", "2"); 1112 predicates.And(); 1113 predicates.EqualTo("is_deleted", "0"); 1114 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT); 1115 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = 1116 contactsDataAbility.Query(uriRawContact, predicates, columns); 1117 int rowCount = 0; 1118 resultSet->GetRowCount(rowCount); 1119 EXPECT_EQ(2, rowCount); 1120 std::vector<int> rawVector = GetMergeRawContactId(resultSet); 1121 EXPECT_EQ(rawOne, rawVector[0]); 1122 EXPECT_EQ(rawTwo, rawVector[1]); 1123 DeleteRawContact(); 1124} 1125 1126/* 1127 * @tc.number merge_Query_test_2400 1128 * @tc.name Insert two contacts with different names to check whether the database 1129 * can find the contacts that can be merged 1130 * @tc.desc A: jackxsiaowuwwwww, B: xsiaowuwwwww 1131 * @tc.level Level1 1132 * @tc.size MediumTest 1133 * @tc.type Function 1134 */ 1135HWTEST_F(MergeContactTest, merge_Query_test_2400, testing::ext::TestSize.Level1) 1136{ 1137 HILOG_INFO("--- merge_Query_test_2400 query is starting! ---"); 1138 int64_t rawOne = RawContactInsert("jackxsiaowuwwwww"); 1139 EXPECT_GT(rawOne, 0); 1140 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "jackxsiaowuwwwww", ""); 1141 HILOG_INFO("merge_Query_test_2400 dataIdOne = %{public}ld", dataIdOne); 1142 int64_t rawTwo = RawContactInsert("xsiaowuwwwww"); 1143 EXPECT_GT(rawTwo, 0); 1144 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xsiaowuwwwww", ""); 1145 HILOG_INFO("merge_Query_test_2400 dataIdTwo = %{public}ld", dataIdTwo); 1146 int time = Time::SLEEP_TIME_MERGE; 1147 std::chrono::milliseconds dura(time); 1148 std::this_thread::sleep_for(dura); 1149 OHOS::Uri uriQueryMergeList(ContactsUri::MERGE_LIST); 1150 std::vector<std::string> columns; 1151 OHOS::DataShare::DataSharePredicates predicates; 1152 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = 1153 contactsDataAbility.Query(uriQueryMergeList, predicates, columns); 1154 int rowCount = 0; 1155 resultSet->GetRowCount(rowCount); 1156 EXPECT_EQ(0, rowCount); 1157 DeleteRawContact(); 1158} 1159 1160/* 1161 * @tc.number merge_Query_test_2500 1162 * @tc.name Insert contacts with the same name and phone number, and check whether the database 1163 * can find contacts that can be merged 1164 * @tc.desc A: xiaowuwwl 123456, B: xiaowuwwl 123456 1165 * @tc.level Level1 1166 * @tc.size MediumTest 1167 * @tc.type Function 1168 */ 1169HWTEST_F(MergeContactTest, merge_Query_test_2500, testing::ext::TestSize.Level1) 1170{ 1171 HILOG_INFO("--- merge_Query_test_2500 query is starting! ---"); 1172 int64_t rawOne = RawContactInsert("xiaowuwwl"); 1173 EXPECT_GT(rawOne, 0); 1174 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "xiaowuwwl", ""); 1175 dataIdOne = ContactDataInsert(rawOne, "phone", "123456", ""); 1176 HILOG_INFO("merge_Query_test_2500 dataIdOne = %{public}ld", dataIdOne); 1177 int64_t rawTwo = RawContactInsert("xiaowuww"); 1178 EXPECT_GT(rawTwo, 0); 1179 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "xiaowuwwl", ""); 1180 dataIdTwo = ContactDataInsert(rawTwo, "phone", "123456", ""); 1181 HILOG_INFO("merge_Query_test_2500 dataIdTwo = %{public}ld", dataIdTwo); 1182 int time = Time::SLEEP_TIME_MERGE; 1183 std::chrono::milliseconds dura(time); 1184 std::this_thread::sleep_for(dura); 1185 std::vector<std::string> columns; 1186 OHOS::DataShare::DataSharePredicates predicates; 1187 predicates.BeginWrap(); 1188 predicates.EqualTo("id", std::to_string(rawOne)); 1189 predicates.Or(); 1190 predicates.EqualTo("id", std::to_string(rawTwo)); 1191 predicates.EndWrap(); 1192 predicates.And(); 1193 predicates.EqualTo("merge_mode", "2"); 1194 predicates.And(); 1195 predicates.EqualTo("is_deleted", "0"); 1196 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT); 1197 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = 1198 contactsDataAbility.Query(uriRawContact, predicates, columns); 1199 int rowCount = 0; 1200 resultSet->GetRowCount(rowCount); 1201 EXPECT_EQ(2, rowCount); 1202 std::vector<int> rawVector = GetMergeRawContactId(resultSet); 1203 EXPECT_EQ(rawOne, rawVector[0]); 1204 EXPECT_EQ(rawTwo, rawVector[1]); 1205 DeleteRawContact(); 1206} 1207 1208/* 1209 * @tc.number merge_Query_test_2600 1210 * @tc.name Insert contacts with different names and phone numbers, and check whether the 1211 * database can find the contacts that can be merged 1212 * @tc.desc A: cxiaowuwwl 123456565454, B: nxiaowuwwl 1234564488 1213 * @tc.level Level1 1214 * @tc.size MediumTest 1215 * @tc.type Function 1216 */ 1217HWTEST_F(MergeContactTest, merge_Query_test_2600, testing::ext::TestSize.Level1) 1218{ 1219 HILOG_INFO("--- merge_Query_test_2600 query is starting! ---"); 1220 int64_t rawOne = RawContactInsert("cxiaowuwwl"); 1221 EXPECT_GT(rawOne, 0); 1222 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "cxiaowuwwl", ""); 1223 dataIdOne = ContactDataInsert(rawOne, "phone", "123456565454", ""); 1224 HILOG_INFO("merge_Query_test_2600 dataIdOne = %{public}ld", dataIdOne); 1225 int64_t rawTwo = RawContactInsert("nxiaowuww"); 1226 EXPECT_GT(rawTwo, 0); 1227 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "nxiaowuwwl", ""); 1228 dataIdTwo = ContactDataInsert(rawTwo, "phone", "1234564488", ""); 1229 HILOG_INFO("merge_Query_test_2600 dataIdTwo = %{public}ld", dataIdTwo); 1230 int time = Time::SLEEP_TIME_MERGE; 1231 std::chrono::milliseconds dura(time); 1232 std::this_thread::sleep_for(dura); 1233 OHOS::Uri uriQueryMergeList(ContactsUri::MERGE_LIST); 1234 std::vector<std::string> columns; 1235 OHOS::DataShare::DataSharePredicates predicates; 1236 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = 1237 contactsDataAbility.Query(uriQueryMergeList, predicates, columns); 1238 int rowCount = 0; 1239 resultSet->GetRowCount(rowCount); 1240 EXPECT_EQ(0, rowCount); 1241 DeleteRawContact(); 1242} 1243 1244/* 1245 * @tc.number merge_Update_test_2700 1246 * @tc.name Insert two contacts with the same name. Contacts A and B have two different mobile 1247 * phone numbers, and check whether the database can be merged 1248 * @tc.desc A: jack12345 123456565454 1234565654546 , B: jack12345 1234564488 12345644888 1249 * @tc.level Level1 1250 * @tc.size MediumTest 1251 * @tc.type Function 1252 */ 1253HWTEST_F(MergeContactTest, merge_Update_test_2700, testing::ext::TestSize.Level1) 1254{ 1255 HILOG_INFO("--- merge_Update_test_2700 query is starting! ---"); 1256 int64_t rawOne = RawContactInsert("jack12345"); 1257 EXPECT_GT(rawOne, 0); 1258 int64_t dataIdOne = ContactDataInsert(rawOne, "name", "jack12345", ""); 1259 dataIdOne = ContactDataInsert(rawOne, "phone", "123456565454", ""); 1260 dataIdOne = ContactDataInsert(rawOne, "phone", "1234565654546", ""); 1261 HILOG_INFO("merge_Update_test_2700 dataIdOne = %{public}ld", dataIdOne); 1262 int64_t rawTwo = RawContactInsert("jack12345"); 1263 EXPECT_GT(rawTwo, 0); 1264 int64_t dataIdTwo = ContactDataInsert(rawTwo, "name", "jack12345", ""); 1265 dataIdTwo = ContactDataInsert(rawTwo, "phone", "1234564488", ""); 1266 dataIdTwo = ContactDataInsert(rawTwo, "phone", "12345644888", ""); 1267 HILOG_INFO("merge_Update_test_2700 dataIdTwo = %{public}ld", dataIdTwo); 1268 int time = Time::SLEEP_TIME_MERGE; 1269 std::chrono::milliseconds dura(time); 1270 std::this_thread::sleep_for(dura); 1271 OHOS::Uri uriManualMerge(ContactsUri::MANUAL_MERGE); 1272 OHOS::DataShare::DataShareValuesBucket value; 1273 OHOS::DataShare::DataSharePredicates predicates; 1274 std::vector<std::string> ids; 1275 ids.push_back(std::to_string(rawOne)); 1276 ids.push_back(std::to_string(rawTwo)); 1277 predicates.In("raw_contact_id", ids); 1278 int ret = contactsDataAbility.Update(uriManualMerge, predicates, value); 1279 EXPECT_EQ(ret, 0); 1280 std::vector<int64_t> resultIdVector; 1281 resultIdVector.push_back(rawOne); 1282 resultIdVector.push_back(rawTwo); 1283 CheckMergeResultId(resultIdVector, true); 1284 DeleteRawContact(); 1285} 1286} // namespace Test 1287} // namespace Contacts