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 
24 namespace Contacts {
25 namespace Test {
DeleteRawContact()26 void 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 
CheckMergeResultId(std::vector<int64_t> ids, bool merge)43 void 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 
GetMergeResultContactId(const std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet)69 int 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 
GetMergeResultRawContactId( const std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet)84 std::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 
GetMergeRawContactId( const std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet)104 std::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 
ContactQuery( std::vector<std::string> columns, OHOS::DataShare::DataSharePredicates predicates)124 std::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 
RawContactInsert(std::string displayName)133 int64_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 
ContactDataInsert( int64_t rawContactId, std::string contentType, std::string detailInfo, std::string position)143 int64_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 
HWTEST_F(MergeContactTest, merge_test_start, testing::ext::TestSize.Level1)157 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Query_test_100, testing::ext::TestSize.Level1)171 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_200, testing::ext::TestSize.Level1)209 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_300, testing::ext::TestSize.Level1)242 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_400, testing::ext::TestSize.Level1)284 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_500, testing::ext::TestSize.Level1)319 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_600, testing::ext::TestSize.Level1)364 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_700, testing::ext::TestSize.Level1)410 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_800, testing::ext::TestSize.Level1)449 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_900, testing::ext::TestSize.Level1)498 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_1000, testing::ext::TestSize.Level1)543 HWTEST_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  */
HWTEST_F(MergeContactTest, abnormal_merge_Update_test_1100, testing::ext::TestSize.Level1)587 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_1200, testing::ext::TestSize.Level1)625 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_1300, testing::ext::TestSize.Level1)668 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_1400, testing::ext::TestSize.Level1)715 HWTEST_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 
HWTEST_F(MergeContactTest, merge_Update_test_1500, testing::ext::TestSize.Level1)767 HWTEST_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  */
HWTEST_F(MergeContactTest, abnormal_merge_Query_test_1600, testing::ext::TestSize.Level1)810 HWTEST_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  */
HWTEST_F(MergeContactTest, abnormal_merge_Update_test_1700, testing::ext::TestSize.Level1)843 HWTEST_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  */
HWTEST_F(MergeContactTest, abnormal_merge_Update_test_1800, testing::ext::TestSize.Level1)887 HWTEST_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  */
HWTEST_F(MergeContactTest, abnormal_merge_Update_test_1900, testing::ext::TestSize.Level1)925 HWTEST_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  */
HWTEST_F(MergeContactTest, abnormal_merge_Update_test_2000, testing::ext::TestSize.Level1)963 HWTEST_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  */
HWTEST_F(MergeContactTest, abnormal_merge_Update_test_2100, testing::ext::TestSize.Level1)1007 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_2200, testing::ext::TestSize.Level1)1045 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Query_test_2300, testing::ext::TestSize.Level1)1089 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Query_test_2400, testing::ext::TestSize.Level1)1135 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Query_test_2500, testing::ext::TestSize.Level1)1169 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Query_test_2600, testing::ext::TestSize.Level1)1217 HWTEST_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  */
HWTEST_F(MergeContactTest, merge_Update_test_2700, testing::ext::TestSize.Level1)1253 HWTEST_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