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 "contactability_test.h"
17 #include "random_number_utils.h"
18
19 #include "data_ability_operation_builder.h"
20
21 namespace Contacts {
22 namespace Test {
ContactAbilityTest()23 ContactAbilityTest::ContactAbilityTest()
24 {
25 }
26
~ContactAbilityTest()27 ContactAbilityTest::~ContactAbilityTest()
28 {
29 }
30
RawContactInsert(std::string displayName, OHOS::DataShare::DataShareValuesBucket &rawContactValues)31 int64_t ContactAbilityTest::RawContactInsert(std::string displayName,
32 OHOS::DataShare::DataShareValuesBucket &rawContactValues)
33 {
34 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
35 rawContactValues.Put("display_name", displayName);
36 int64_t code = contactsDataAbility.Insert(uriRawContact, rawContactValues);
37 return code;
38 }
39
RawContactExpandInsert( std::vector<std::string> valueVector, int isFavorite, OHOS::DataShare::DataShareValuesBucket &rawContactValues)40 int64_t ContactAbilityTest::RawContactExpandInsert(
41 std::vector<std::string> valueVector, int isFavorite, OHOS::DataShare::DataShareValuesBucket &rawContactValues)
42 {
43 int indexZero = 0;
44 int indexOne = 1;
45 int indexTwo = 2;
46 int indexThree = 3;
47 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
48 rawContactValues.Put("display_name", valueVector[indexZero]);
49 rawContactValues.Put("company", valueVector[indexOne]);
50 rawContactValues.Put("position", valueVector[indexTwo]);
51 rawContactValues.Put("favorite", isFavorite);
52 rawContactValues.Put("phonetic_name", valueVector[indexThree]);
53 int64_t code = contactsDataAbility.Insert(uriRawContact, rawContactValues);
54 return code;
55 }
56
RawContactLastContactedInsert( std::string displayName, int lastestContactedTime, OHOS::DataShare::DataShareValuesBucket &rawContactValues)57 int64_t ContactAbilityTest::RawContactLastContactedInsert(
58 std::string displayName, int lastestContactedTime, OHOS::DataShare::DataShareValuesBucket &rawContactValues)
59 {
60 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
61 rawContactValues.Put("display_name", displayName);
62 rawContactValues.Put("lastest_contacted_time", lastestContactedTime);
63 int64_t code = contactsDataAbility.Insert(uriRawContact, rawContactValues);
64 return code;
65 }
66
ContactDataInsert(int64_t rawContactId, std::string contentType, std::string detailInfo, std::string position, OHOS::DataShare::DataShareValuesBucket &contactDataValues)67 int64_t ContactAbilityTest::ContactDataInsert(int64_t rawContactId, std::string contentType, std::string detailInfo,
68 std::string position, OHOS::DataShare::DataShareValuesBucket &contactDataValues)
69 {
70 OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA);
71 contactDataValues.Put("raw_contact_id", rawContactId);
72 contactDataValues.Put("content_type", contentType);
73 contactDataValues.Put("detail_info", detailInfo);
74 contactDataValues.Put("position", position);
75 int64_t code = contactsDataAbility.Insert(uriContactData, contactDataValues);
76 return code;
77 }
78
GroupsInsert(std::string groupName, OHOS::DataShare::DataShareValuesBucket &groupValues)79 int64_t ContactAbilityTest::GroupsInsert(std::string groupName, OHOS::DataShare::DataShareValuesBucket &groupValues)
80 {
81 OHOS::Uri uriGroups(ContactsUri::GROUPS);
82 groupValues.Put("group_name", groupName);
83 int64_t code = contactsDataAbility.Insert(uriGroups, groupValues);
84 return code;
85 }
86
ContactBlocklistInsert( std::string phoneNumber, OHOS::DataShare::DataShareValuesBucket &contactBlocklistValues)87 int64_t ContactAbilityTest::ContactBlocklistInsert(
88 std::string phoneNumber, OHOS::DataShare::DataShareValuesBucket &contactBlocklistValues)
89 {
90 OHOS::Uri uriBlocklist(ContactsUri::BLOCKLIST);
91 contactBlocklistValues.Put("phone_number", phoneNumber);
92 int64_t code = contactsDataAbility.Insert(uriBlocklist, contactBlocklistValues);
93 return code;
94 }
95
ContactUpdate(const std::string &tableName, OHOS::DataShare::DataShareValuesBucket updateValues, OHOS::DataShare::DataSharePredicates predicates)96 int ContactAbilityTest::ContactUpdate(const std::string &tableName, OHOS::DataShare::DataShareValuesBucket updateValues,
97 OHOS::DataShare::DataSharePredicates predicates)
98 {
99 int code = 0;
100 if (tableName == ContactTabName::RAW_CONTACT) {
101 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
102 code = contactsDataAbility.Update(uriRawContact, predicates, updateValues);
103 } else if (tableName == ContactTabName::CONTACT_DATA) {
104 OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA);
105 code = contactsDataAbility.Update(uriContactData, predicates, updateValues);
106 } else if (tableName == ContactTabName::GROUPS) {
107 OHOS::Uri uriGroups(ContactsUri::GROUPS);
108 code = contactsDataAbility.Update(uriGroups, predicates, updateValues);
109 } else if (tableName == ContactTabName::CONTACT_BLOCKLIST) {
110 OHOS::Uri uriBlocklist(ContactsUri::BLOCKLIST);
111 code = contactsDataAbility.Update(uriBlocklist, predicates, updateValues);
112 } else {
113 HILOG_ERROR("ContactsDataAbility ====>no match uri action");
114 }
115 return code;
116 }
117
ContactDelete(const std::string &tableName, OHOS::DataShare::DataSharePredicates predicates)118 int ContactAbilityTest::ContactDelete(const std::string &tableName, OHOS::DataShare::DataSharePredicates predicates)
119 {
120 int code = 0;
121 if (tableName == ContactTabName::RAW_CONTACT) {
122 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
123 code = contactsDataAbility.Delete(uriRawContact, predicates);
124 } else if (tableName == ContactTabName::CONTACT_DATA) {
125 OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA);
126 code = contactsDataAbility.Delete(uriContactData, predicates);
127 } else if (tableName == ContactTabName::GROUPS) {
128 OHOS::Uri uriGroups(ContactsUri::GROUPS);
129 code = contactsDataAbility.Delete(uriGroups, predicates);
130 } else if (tableName == ContactTabName::CONTACT_BLOCKLIST) {
131 OHOS::Uri uriBlocklist(ContactsUri::BLOCKLIST);
132 code = contactsDataAbility.Delete(uriBlocklist, predicates);
133 } else if (tableName == ContactTabName::CONTACT) {
134 OHOS::Uri uriContact(ContactsUri::CONTACT);
135 code = contactsDataAbility.Delete(uriContact, predicates);
136 } else if (tableName == ContactTabName::DELETED_RAW_CONTACT_RECORD) {
137 OHOS::Uri deleteRawContact(ContactsUri::DELETED_RAW_CONTACT_RECORD);
138 code = contactsDataAbility.Delete(deleteRawContact, predicates);
139 } else {
140 HILOG_ERROR("ContactsDataAbility ====>no match uri action");
141 }
142 return code;
143 }
144
ContactQuery( const std::string &tableName, std::vector<std::string> &columns, OHOS::DataShare::DataSharePredicates predicates)145 std::shared_ptr<OHOS::DataShare::DataShareResultSet> ContactAbilityTest::ContactQuery(
146 const std::string &tableName, std::vector<std::string> &columns, OHOS::DataShare::DataSharePredicates predicates)
147 {
148 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet;
149
150 if (tableName == ContactTabName::RAW_CONTACT) {
151 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
152 resultSet = contactsDataAbility.Query(uriRawContact, predicates, columns);
153 } else if (tableName == ContactTabName::CONTACT_DATA) {
154 OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA);
155 resultSet = contactsDataAbility.Query(uriContactData, predicates, columns);
156 } else if (tableName == ContactTabName::CONTACT) {
157 OHOS::Uri uriContact(ContactsUri::CONTACT);
158 resultSet = contactsDataAbility.Query(uriContact, predicates, columns);
159 } else if (tableName == ContactTabName::GROUPS) {
160 OHOS::Uri uriGroups(ContactsUri::GROUPS);
161 resultSet = contactsDataAbility.Query(uriGroups, predicates, columns);
162 } else if (tableName == ContactTabName::CONTACT_BLOCKLIST) {
163 OHOS::Uri uriBlocklist(ContactsUri::BLOCKLIST);
164 resultSet = contactsDataAbility.Query(uriBlocklist, predicates, columns);
165 } else if (tableName == ContactTabName::DELETED_RAW_CONTACT) {
166 OHOS::Uri uriDeletedRawContact(ContactsUri::DELETED_RAW_CONTACT);
167 resultSet = contactsDataAbility.Query(uriDeletedRawContact, predicates, columns);
168 } else if (tableName == ContactTabName::SEARCH_CONTACT) {
169 OHOS::Uri uriSearchContact(ContactsUri::SEARCH);
170 resultSet = contactsDataAbility.Query(uriSearchContact, predicates, columns);
171 } else {
172 HILOG_ERROR("ContactsDataAbility ====>no match uri action");
173 }
174 return resultSet;
175 }
176
QueryAndExpectResult(std::string &tableName, OHOS::DataShare::DataSharePredicates predicates, OHOS::DataShare::DataShareValuesBucket &values, std::string testName)177 void ContactAbilityTest::QueryAndExpectResult(std::string &tableName, OHOS::DataShare::DataSharePredicates predicates,
178 OHOS::DataShare::DataShareValuesBucket &values, std::string testName)
179 {
180 std::vector<std::string> columns;
181 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(tableName, columns, predicates);
182 CheckResultSet(values, resultSet, testName);
183 }
184
RawContactInsertValues(OHOS::DataShare::DataShareValuesBucket &values)185 int64_t ContactAbilityTest::RawContactInsertValues(OHOS::DataShare::DataShareValuesBucket &values)
186 {
187 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
188 int64_t code = contactsDataAbility.Insert(uriRawContact, values);
189 return code;
190 }
191
ContactDataInsertValues(OHOS::DataShare::DataShareValuesBucket &values)192 int64_t ContactAbilityTest::ContactDataInsertValues(OHOS::DataShare::DataShareValuesBucket &values)
193 {
194 OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA);
195 int64_t code = contactsDataAbility.Insert(uriContactData, values);
196 return code;
197 }
198
GroupsInsertValues(OHOS::DataShare::DataShareValuesBucket &values)199 int64_t ContactAbilityTest::GroupsInsertValues(OHOS::DataShare::DataShareValuesBucket &values)
200 {
201 OHOS::Uri uriGroups(ContactsUri::GROUPS);
202 int64_t code = contactsDataAbility.Insert(uriGroups, values);
203 return code;
204 }
205
ContactBlocklistInsertValues(OHOS::DataShare::DataShareValuesBucket &values)206 int64_t ContactAbilityTest::ContactBlocklistInsertValues(OHOS::DataShare::DataShareValuesBucket &values)
207 {
208 OHOS::Uri uriContactBolcklist(ContactsUri::BLOCKLIST);
209 int64_t code = contactsDataAbility.Insert(uriContactBolcklist, values);
210 return code;
211 }
212
GetAllRawContactColumns( std::vector<std::string> &columnInt, std::vector<std::string> &columnStr)213 void ContactAbilityTest::GetAllRawContactColumns(
214 std::vector<std::string> &columnInt, std::vector<std::string> &columnStr)
215 {
216 columnInt.push_back("photo_id");
217 columnInt.push_back("photo_file_id");
218 columnInt.push_back("is_transfer_voicemail");
219 columnInt.push_back("account_id");
220 columnInt.push_back("version");
221 columnInt.push_back("contacted_count");
222 columnInt.push_back("lastest_contacted_time");
223 columnInt.push_back("favorite");
224 columnInt.push_back("phonetic_name_type");
225 columnInt.push_back("read_only");
226 columnInt.push_back("merge_mode");
227 columnInt.push_back("is_need_merge");
228 columnInt.push_back("merge_status");
229 columnInt.push_back("is_merge_target");
230 columnInt.push_back("vibration_setting");
231 columnInt.push_back("sync_id");
232
233 columnStr.push_back("personal_ringtone");
234 columnStr.push_back("personal_notification_ringtone");
235 columnStr.push_back("photo_first_name");
236 columnStr.push_back("display_name");
237 columnStr.push_back("sort");
238 columnStr.push_back("favorite_order");
239 columnStr.push_back("phonetic_name");
240 columnStr.push_back("company");
241 columnStr.push_back("position");
242 columnStr.push_back("sort_first_letter");
243 columnStr.push_back("syn_1");
244 columnStr.push_back("syn_2");
245 columnStr.push_back("syn_3");
246 }
247
GetAllContactDataColumns( std::vector<std::string> &columnInt, std::vector<std::string> &columnStr)248 void ContactAbilityTest::GetAllContactDataColumns(
249 std::vector<std::string> &columnInt, std::vector<std::string> &columnStr)
250 {
251 columnInt.push_back("read_only");
252 columnInt.push_back("version");
253 columnInt.push_back("is_preferred_number");
254
255 columnStr.push_back("detail_info");
256 columnStr.push_back("family_name");
257 columnStr.push_back("middle_name_phonetic");
258 columnStr.push_back("given_name");
259 columnStr.push_back("given_name_phonetic");
260 columnStr.push_back("alias_detail_info");
261 columnStr.push_back("phonetic_name");
262 columnStr.push_back("position");
263 columnStr.push_back("extend1");
264 columnStr.push_back("extend2");
265 columnStr.push_back("extend3");
266 columnStr.push_back("extend4");
267 columnStr.push_back("city");
268 columnStr.push_back("country");
269 columnStr.push_back("neighborhood");
270 columnStr.push_back("pobox");
271 columnStr.push_back("region");
272 columnStr.push_back("street");
273 columnStr.push_back("alpha_name");
274 columnStr.push_back("other_lan_last_name");
275 columnStr.push_back("other_lan_first_name");
276 columnStr.push_back("lan_style");
277 columnStr.push_back("custom_data");
278 columnStr.push_back("extend6");
279 columnStr.push_back("extend7");
280 columnStr.push_back("syn_1");
281 columnStr.push_back("syn_2");
282 columnStr.push_back("syn_3");
283 }
284
GetAllGroupsColumns(std::vector<std::string> &columnInt, std::vector<std::string> &columnStr)285 void ContactAbilityTest::GetAllGroupsColumns(std::vector<std::string> &columnInt, std::vector<std::string> &columnStr)
286 {
287 columnInt.push_back("account_id");
288 columnInt.push_back("ringtone_modify_time");
289 columnInt.push_back("lastest_modify_time");
290 columnStr.push_back("group_name");
291 columnStr.push_back("group_notes");
292 columnStr.push_back("group_ringtone");
293 }
294
GetAllContactBlocklistColumns( std::vector<std::string> &columnInt, std::vector<std::string> &columnStr)295 void ContactAbilityTest::GetAllContactBlocklistColumns(
296 std::vector<std::string> &columnInt, std::vector<std::string> &columnStr)
297 {
298 columnInt.push_back("types");
299 columnStr.push_back("phone_number");
300 columnStr.push_back("content");
301 columnStr.push_back("time_stamp");
302 }
303
GetDetailsContactDataColumns(std::vector<std::string> &columns)304 void ContactAbilityTest::GetDetailsContactDataColumns(std::vector<std::string> &columns)
305 {
306 columns.push_back("email");
307 columns.push_back("im");
308 columns.push_back("nickname");
309 columns.push_back("organization");
310 columns.push_back("phone");
311 columns.push_back("name");
312 columns.push_back("postal_address");
313 columns.push_back("photo");
314 columns.push_back("group_membership");
315 columns.push_back("note");
316 columns.push_back("contact_event");
317 columns.push_back("website");
318 columns.push_back("relation");
319 columns.push_back("contact_misc");
320 columns.push_back("hicall_device");
321 columns.push_back("camcard");
322 columns.push_back("sip_address");
323 }
324
MergeColumns( std::vector<std::string> &columns, std::vector<std::string> &columnsInt, std::vector<std::string> &columnsStr)325 void ContactAbilityTest::MergeColumns(
326 std::vector<std::string> &columns, std::vector<std::string> &columnsInt, std::vector<std::string> &columnsStr)
327 {
328 int columnsIntSize = columnsInt.size();
329 for (int i = 0; i < columnsIntSize; i++) {
330 columns.push_back(columnsInt[i]);
331 }
332 int columnsStrSize = columnsStr.size();
333 for (int i = 0; i < columnsStrSize; i++) {
334 columns.push_back(columnsStr[i]);
335 }
336 }
337
338 /**
339 * @brief get ValuesBucket
340 * @params columnsStart column start index
341 * @params columnsEnd column end index
342 * @return ValuesBucket
343 */
GetAllColumnsValues( std::vector<std::string> &columnsInt, std::vector<std::string> &columnsStr)344 OHOS::DataShare::DataShareValuesBucket ContactAbilityTest::GetAllColumnsValues(
345 std::vector<std::string> &columnsInt, std::vector<std::string> &columnsStr)
346 {
347 OHOS::DataShare::DataShareValuesBucket valuesBucket;
348 int randomInt = 0;
349 int columnsIntSize = columnsInt.size();
350 for (int i = 0; i < columnsIntSize; i++) {
351 randomInt = ContactsRand();
352 HILOG_INFO("rand=%{public}d", randomInt);
353 valuesBucket.Put(columnsInt[i], randomInt);
354 }
355 std::string randomStr = "";
356 int columnsStringSize = columnsStr.size();
357 for (int i = 0; i < columnsStringSize; i++) {
358 randomStr = columnsStr[i] + std::to_string(ContactsRand());
359 valuesBucket.Put(columnsStr[i], randomStr);
360 }
361
362 return valuesBucket;
363 }
364
ClearContacts()365 void ContactAbilityTest::ClearContacts()
366 {
367 OHOS::DataShare::DataSharePredicates predicates;
368 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
369 predicates.NotEqualTo("id", "0");
370 predicates.And();
371 predicates.EqualTo("is_deleted", "0");
372 contactsDataAbility.Delete(uriRawContact, predicates);
373 int time = 1000;
374 std::chrono::milliseconds dura(time);
375 std::this_thread::sleep_for(dura);
376 OHOS::DataShare::DataSharePredicates predicates2;
377 OHOS::Uri uriRawContactComplete(ContactsUri::DELETED_RAW_CONTACT);
378 predicates2.NotEqualTo("id", "0");
379 contactsDataAbility.Delete(uriRawContactComplete, predicates2);
380 }
381
382 /*
383 * @tc.number contact_Insert_test_100
384 * @tc.name Add the basic information of a single contact and verify whether the insertion is successful
385 * @tc.desc New capabilities for basic contact data
386 * @tc.level Level1
387 * @tc.size MediumTest
388 * @tc.type Function
389 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_100, testing::ext::TestSize.Level1)390 HWTEST_F(ContactAbilityTest, contact_Insert_test_100, testing::ext::TestSize.Level1)
391 {
392 HILOG_INFO("--- contact_Insert_test_100 is starting! ---");
393 OHOS::DataShare::DataShareValuesBucket values;
394 int64_t rawContactId = RawContactInsert("liming", values);
395 HILOG_INFO("contact_Insert_test_100 : rawContactId = %{public}ld", rawContactId);
396 EXPECT_GT(rawContactId, 0);
397
398 OHOS::DataShare::DataSharePredicates predicates;
399 predicates.EqualTo("id", std::to_string(rawContactId));
400 std::string rawContacts = ContactTabName::RAW_CONTACT;
401 QueryAndExpectResult(rawContacts, predicates, values, "contact_Insert_test_100");
402 ClearContacts();
403 }
404
405 /*
406 * @tc.number contact_Insert_test_200
407 * @tc.name Add the basic information of multiple contacts and verify whether the insertion is successful
408 * @tc.desc New capabilities for basic contact data
409 * @tc.level Level1
410 * @tc.size MediumTest
411 * @tc.type Function
412 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_200, testing::ext::TestSize.Level1)413 HWTEST_F(ContactAbilityTest, contact_Insert_test_200, testing::ext::TestSize.Level1)
414 {
415 HILOG_INFO("--- contact_Insert_test_200 is starting! ---");
416 OHOS::DataShare::DataShareValuesBucket values;
417 int64_t rawContactIdOne = RawContactInsert("xiaoqian", values);
418 HILOG_INFO("contact_Insert_test_200 : rawContactIdOne = %{public}ld", rawContactIdOne);
419 EXPECT_GT(rawContactIdOne, 0);
420 OHOS::DataShare::DataSharePredicates predicates;
421 predicates.EqualTo("id", std::to_string(rawContactIdOne));
422 std::string rawContacts = ContactTabName::RAW_CONTACT;
423 QueryAndExpectResult(rawContacts, predicates, values, "contact_Insert_test_200");
424 values.Clear();
425
426 int64_t rawContactIdTwo = RawContactInsert("xiaowang", values);
427 HILOG_INFO("contact_Insert_test_200 : rawContactIdTwo = %{public}ld", rawContactIdTwo);
428 EXPECT_GT(rawContactIdTwo, 0);
429 predicates.EqualTo("id", std::to_string(rawContactIdTwo));
430 QueryAndExpectResult(rawContacts, predicates, values, "contact_Insert_test_200");
431
432 int64_t rawContactIdThree = RawContactInsert("xiaozhou", values);
433 HILOG_INFO("contact_Insert_test_200 : rawContactIdThree = %{public}ld", rawContactIdThree);
434 EXPECT_GT(rawContactIdThree, 0);
435 OHOS::DataShare::DataSharePredicates predicates2;
436 predicates.EqualTo("id", std::to_string(rawContactIdThree));
437 QueryAndExpectResult(rawContacts, predicates2, values, "contact_Insert_test_200");
438 ClearContacts();
439 }
440
441 /*
442 * @tc.number contact_Insert_test_300
443 * @tc.name Add a full field data to the raw_contact table and verify whether the insertion is successful
444 * @tc.desc Added ability to raw_contact
445 * @tc.level Level1
446 * @tc.size MediumTest
447 * @tc.type Function
448 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_300, testing::ext::TestSize.Level1)449 HWTEST_F(ContactAbilityTest, contact_Insert_test_300, testing::ext::TestSize.Level1)
450 {
451 HILOG_INFO("-----contact_Insert_test_300 is starting!-----");
452 std::vector<std::string> columnsInt;
453 std::vector<std::string> columnsStr;
454 std::vector<std::string> columns;
455 std::string rawContacts = ContactTabName::RAW_CONTACT;
456 GetAllRawContactColumns(columnsInt, columnsStr);
457 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
458 int rawId = RawContactInsertValues(valuesBucket);
459 EXPECT_GT(rawId, 0);
460
461 MergeColumns(columns, columnsInt, columnsStr);
462 OHOS::DataShare::DataSharePredicates predicates;
463 predicates.EqualTo("id", std::to_string(rawId));
464 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(rawContacts, columns, predicates);
465
466 // resultSet count 1
467 int rowCount = -1;
468 resultSet->GetRowCount(rowCount);
469 EXPECT_EQ(1, rowCount);
470 CheckResultSet(valuesBucket, resultSet, "contact_Insert_test_300");
471 ClearContacts();
472 }
473
474 /*
475 * @tc.number contact_Insert_test_400
476 * @tc.name Add the basic information of a single contact and verify whether the insertion is successful
477 (name, name Pinyin, Pinyin name, company, position, favorite or not)
478 * @tc.desc Add basic information of a single contact
479 * @tc.level Level1
480 * @tc.size MediumTest
481 * @tc.type Function
482 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_400, testing::ext::TestSize.Level1)483 HWTEST_F(ContactAbilityTest, contact_Insert_test_400, testing::ext::TestSize.Level1)
484 {
485 HILOG_INFO("--- contact_Insert_test_400 is starting! ---");
486 OHOS::DataShare::DataShareValuesBucket values;
487 std::vector<std::string> vectorValue;
488 vectorValue.push_back("liming");
489 vectorValue.push_back("tiantianxaingshang");
490 vectorValue.push_back("Test");
491 vectorValue.push_back("liming||lm");
492 int64_t rawContactId = RawContactExpandInsert(vectorValue, 1, values);
493 HILOG_INFO("contact_Insert_test_400 : rawContactId = %{public}ld", rawContactId);
494 EXPECT_GT(rawContactId, 0);
495
496 OHOS::DataShare::DataSharePredicates predicates;
497 predicates.EqualTo("id", std::to_string(rawContactId));
498 std::string rawContacts = ContactTabName::RAW_CONTACT;
499 QueryAndExpectResult(rawContacts, predicates, values, "contact_Insert_test_400");
500 ClearContacts();
501 }
502
503 /*
504 * @tc.number contact_Insert_test_500
505 * @tc.name Add individual contact details and verify that the insertion was successful
506 * (including name, nickname, company, position, mobile phone number and email address)
507 * @tc.desc New ability to contact detailed data
508 * @tc.level Level1
509 * @tc.size MediumTest
510 * @tc.type Function
511 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_500, testing::ext::TestSize.Level1)512 HWTEST_F(ContactAbilityTest, contact_Insert_test_500, testing::ext::TestSize.Level1)
513 {
514 HILOG_INFO("--- contact_Insert_test_500 is starting! ---");
515 std::string contactData = ContactTabName::CONTACT_DATA;
516 OHOS::DataShare::DataShareValuesBucket rawContactValues;
517 int64_t rawContactId = RawContactInsert("ligang", rawContactValues);
518 HILOG_INFO("contact_Insert_test_500 : rawContactId = %{public}ld", rawContactId);
519 EXPECT_GT(rawContactId, 0);
520 OHOS::DataShare::DataShareValuesBucket values;
521 int64_t contactDataIdOne = ContactDataInsert(rawContactId, "name", "ligang", "", values);
522 HILOG_INFO("contact_Insert_test_500 : contactDataIdOne = %{public}ld", contactDataIdOne);
523 EXPECT_GT(contactDataIdOne, 0);
524 OHOS::DataShare::DataSharePredicates predicates;
525 predicates.EqualTo("id", std::to_string(contactDataIdOne));
526 QueryAndExpectResult(contactData, predicates, values, "contact_Insert_test_500");
527 values.Clear();
528
529 int64_t contactDataIdTwo = ContactDataInsert(rawContactId, "organization", "tiantianxaingshang", "Test", values);
530 HILOG_INFO("contact_Insert_test_500 : contactDataIdTwo = %{public}ld", contactDataIdTwo);
531 EXPECT_GT(contactDataIdTwo, 0);
532 OHOS::DataShare::DataSharePredicates predicates2;
533 predicates2.EqualTo("id", std::to_string(contactDataIdTwo));
534 QueryAndExpectResult(contactData, predicates2, values, "contact_Insert_test_500");
535 values.Clear();
536
537 int64_t contactDataIdThree = ContactDataInsert(rawContactId, "email", "8523@163.com", "", values);
538 HILOG_INFO("contact_Insert_test_500 : contactDataIdThree = %{public}ld", contactDataIdThree);
539 EXPECT_GT(contactDataIdThree, 0);
540 OHOS::DataShare::DataSharePredicates predicates3;
541 predicates3.EqualTo("id", std::to_string(contactDataIdThree));
542 QueryAndExpectResult(contactData, predicates3, values, "contact_Insert_test_500");
543 values.Clear();
544
545 int64_t contactDataIdFour = ContactDataInsert(rawContactId, "phone", "188520314", "", values);
546 HILOG_INFO("contact_Insert_test_500 : contactDataIdFour = %{public}ld", contactDataIdFour);
547 EXPECT_GT(contactDataIdFour, 0);
548 OHOS::DataShare::DataSharePredicates predicates4;
549 predicates4.EqualTo("id", std::to_string(contactDataIdFour));
550 QueryAndExpectResult(contactData, predicates4, values, "contact_Insert_test_500");
551 values.Clear();
552
553 int64_t contactDataIdFive = ContactDataInsert(rawContactId, "nickname", "xiaogang", "", values);
554 HILOG_INFO("contact_Insert_test_500 : contactDataIdFive = %{public}ld", contactDataIdFive);
555 EXPECT_GT(contactDataIdFive, 0);
556 OHOS::DataShare::DataSharePredicates predicates5;
557 predicates5.EqualTo("id", std::to_string(contactDataIdFive));
558 QueryAndExpectResult(contactData, predicates5, values, "contact_Insert_test_500");
559 values.Clear();
560 ClearContacts();
561 }
562
563 /*
564 * @tc.number contact_Insert_test_600
565 * @tc.name Add individual contact details and verify that the insertion was successful
566 * (including home, group, aim, notes, and URL)
567 * @tc.desc New ability to contact detailed data
568 * @tc.level Level1
569 * @tc.size MediumTest
570 * @tc.type Function
571 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_600, testing::ext::TestSize.Level1)572 HWTEST_F(ContactAbilityTest, contact_Insert_test_600, testing::ext::TestSize.Level1)
573 {
574 HILOG_INFO("--- contact_Insert_test_600 is starting! ---");
575 std::string contactData = ContactTabName::CONTACT_DATA;
576 OHOS::DataShare::DataShareValuesBucket values;
577 int64_t rawContactId = RawContactInsert("chengshao", values);
578 HILOG_INFO("contact_Insert_test_600 : rawContactId = %{public}ld", rawContactId);
579 EXPECT_GT(rawContactId, 0);
580 values.Clear();
581
582 int64_t contactDataIdOne = ContactDataInsert(rawContactId, "postal_address", "NanJingCity", "", values);
583 HILOG_INFO("contact_Insert_test_600 : contactDataIdOne = %{public}ld", contactDataIdOne);
584 EXPECT_GT(contactDataIdOne, 0);
585 OHOS::DataShare::DataSharePredicates predicates;
586 predicates.EqualTo("id", std::to_string(contactDataIdOne));
587 QueryAndExpectResult(contactData, predicates, values, "contact_Insert_test_600");
588 values.Clear();
589
590 int64_t contactDataIdTwo = ContactDataInsert(rawContactId, "group_membership", "1", "", values);
591 HILOG_INFO("contact_Insert_test_600 : contactDataIdTwo = %{public}ld", contactDataIdTwo);
592 EXPECT_GT(contactDataIdTwo, 0);
593 OHOS::DataShare::DataSharePredicates predicates2;
594 predicates2.EqualTo("id", std::to_string(contactDataIdTwo));
595 QueryAndExpectResult(contactData, predicates2, values, "contact_Insert_test_600");
596 values.Clear();
597
598 int64_t contactDataIdThree = ContactDataInsert(rawContactId, "note", "dalao", "", values);
599 HILOG_INFO("contact_Insert_test_600 : contactDataIdThree = %{public}ld", contactDataIdThree);
600 OHOS::DataShare::DataSharePredicates predicates3;
601 predicates3.EqualTo("id", std::to_string(contactDataIdThree));
602 QueryAndExpectResult(contactData, predicates3, values, "contact_Insert_test_600");
603 values.Clear();
604
605 int64_t contactDataIdFour = ContactDataInsert(rawContactId, "im", "aaaa", "", values);
606 HILOG_INFO("contact_Insert_test_600 : contactDataIdFour = %{public}ld", contactDataIdFour);
607 EXPECT_GT(contactDataIdFour, 0);
608 OHOS::DataShare::DataSharePredicates predicates4;
609 predicates4.EqualTo("id", std::to_string(contactDataIdFour));
610 QueryAndExpectResult(contactData, predicates4, values, "contact_Insert_test_600");
611 values.Clear();
612
613 int64_t contactDataIdFive = ContactDataInsert(rawContactId, "website", "www.48236.com", "", values);
614 HILOG_INFO("contact_Insert_test_600 : contactDataIdFive = %{public}ld", contactDataIdFive);
615 EXPECT_GT(contactDataIdFive, 0);
616 OHOS::DataShare::DataSharePredicates predicates5;
617 predicates5.EqualTo("id", std::to_string(contactDataIdFive));
618 QueryAndExpectResult(contactData, predicates5, values, "contact_Insert_test_600");
619 values.Clear();
620 ClearContacts();
621 }
622
623 /*
624 * @tc.number contact_Insert_test_700
625 * @tc.name Add individual contact details and verify that the insertion was successful
626 * (including phone ring tones, birthdays, and assistants)
627 * @tc.desc New ability to contact detailed data
628 * @tc.level Level1
629 * @tc.size MediumTest
630 * @tc.type Function
631 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_700, testing::ext::TestSize.Level1)632 HWTEST_F(ContactAbilityTest, contact_Insert_test_700, testing::ext::TestSize.Level1)
633 {
634 HILOG_INFO("--- contact_Insert_test_700 is starting! ---");
635 std::string contactData = ContactTabName::CONTACT_DATA;
636 OHOS::DataShare::DataShareValuesBucket values;
637 int64_t rawContactId = RawContactInsert("yanshao", values);
638 HILOG_INFO("contact_Insert_test_700 : rawContactId = %{public}ld", rawContactId);
639 EXPECT_GT(rawContactId, 0);
640 values.Clear();
641
642 int64_t contactDataIdOne = ContactDataInsert(rawContactId, "contact_event", "19960229", "", values);
643 HILOG_INFO("contact_Insert_test_700 : contactDataIdOne = %{public}ld", contactDataIdOne);
644 EXPECT_GT(contactDataIdOne, 0);
645 OHOS::DataShare::DataSharePredicates predicates;
646 predicates.EqualTo("id", std::to_string(contactDataIdOne));
647 QueryAndExpectResult(contactData, predicates, values, "contact_Insert_test_700");
648 values.Clear();
649
650 int64_t contactDataIdTwo = ContactDataInsert(rawContactId, "relation", "Secretary", "", values);
651 HILOG_INFO("contact_Insert_test_700 : contactDataIdTwo = %{public}ld", contactDataIdTwo);
652 EXPECT_GT(contactDataIdTwo, 0);
653 OHOS::DataShare::DataSharePredicates predicates2;
654 predicates2.EqualTo("id", std::to_string(contactDataIdTwo));
655 QueryAndExpectResult(contactData, predicates2, values, "contact_Insert_test_700");
656 values.Clear();
657
658 int64_t contactDataIdThree = ContactDataInsert(rawContactId, "contact_misc", "1314", "", values);
659 HILOG_INFO("contact_Insert_test_700 : contactDataIdThree = %{public}ld", contactDataIdThree);
660 EXPECT_GT(contactDataIdThree, 0);
661 OHOS::DataShare::DataSharePredicates predicates3;
662 predicates3.EqualTo("id", std::to_string(contactDataIdThree));
663 QueryAndExpectResult(contactData, predicates3, values, "contact_Insert_test_700");
664 values.Clear();
665 ClearContacts();
666 }
667
668 /*
669 * @tc.number contact_Insert_test_800
670 * @tc.name Add all details of a single contact and verify whether the insertion is successful
671 * (name, mobile number, company, position, nickname, email, home, remarks, aim, birthday, website,
672 * assistant, group, phone ring)
673 * @tc.desc New ability to contact detailed data
674 * @tc.level Level1
675 * @tc.size MediumTest
676 * @tc.type Function
677 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_800, testing::ext::TestSize.Level1)678 HWTEST_F(ContactAbilityTest, contact_Insert_test_800, testing::ext::TestSize.Level1)
679 {
680 HILOG_INFO("--- contact_Insert_test_800 is starting! ---");
681 OHOS::DataShare::DataShareValuesBucket rawValuesBucket;
682 int64_t rawContactId = RawContactInsert("insert_detail_contactdata", rawValuesBucket);
683 EXPECT_GT(rawContactId, 0);
684
685 std::vector<std::string> columns;
686 std::vector<std::string> columnQuery;
687 columnQuery.push_back("detail_info");
688 GetDetailsContactDataColumns(columns);
689
690 OHOS::DataShare::DataShareValuesBucket valuesBucket;
691
692 std::string randomStr = "";
693 std::string tableName = ContactTabName::CONTACT_DATA;
694 int columnSize = columns.size();
695 for (int i = 0; i < columnSize; i++) {
696 randomStr = columns[i] + std::to_string(ContactsRand());
697 valuesBucket.Put("raw_contact_id", rawContactId);
698 valuesBucket.Put("content_type", columns[i]);
699 valuesBucket.Put("detail_info", randomStr);
700 int contactDataId = ContactDataInsertValues(valuesBucket);
701 EXPECT_GT(contactDataId, 0);
702
703 OHOS::DataShare::DataSharePredicates predicates;
704 predicates.EqualTo("id", std::to_string(contactDataId));
705 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
706 ContactQuery(tableName, columnQuery, predicates);
707 int rowCount = -1;
708 resultSet->GetRowCount(rowCount);
709 EXPECT_EQ(1, rowCount);
710 CheckResultSet(valuesBucket, resultSet, "contact_Insert_test_800");
711 valuesBucket.Clear();
712 }
713 ClearContacts();
714 }
715
716 /*
717 * @tc.number contact_Insert_test_900
718 * @tc.name Add multiple contact details and verify that the insertion was successful
719 * @tc.desc New ability to contact detailed data
720 * @tc.level Level1
721 * @tc.size MediumTest
722 * @tc.type Function
723 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_900, testing::ext::TestSize.Level1)724 HWTEST_F(ContactAbilityTest, contact_Insert_test_900, testing::ext::TestSize.Level1)
725 {
726 HILOG_INFO("--- contact_Insert_test_900 is starting! ---");
727 std::string contactData = ContactTabName::CONTACT_DATA;
728 OHOS::DataShare::DataShareValuesBucket values;
729 int64_t rawContactId = RawContactInsert("xiaoming", values);
730 EXPECT_GT(rawContactId, 0);
731 values.Clear();
732
733 int64_t contactDataIdOne = ContactDataInsert(rawContactId, "name", "xiaoming", "", values);
734 EXPECT_GT(contactDataIdOne, 0);
735 OHOS::DataShare::DataSharePredicates predicates;
736 predicates.EqualTo("id", std::to_string(contactDataIdOne));
737 QueryAndExpectResult(contactData, predicates, values, "contact_Insert_test_900");
738 values.Clear();
739
740 int64_t contactDataIdTwo = ContactDataInsert(rawContactId, "organization", "tiantianxaingshang", "Test", values);
741 EXPECT_GT(contactDataIdTwo, 0);
742 OHOS::DataShare::DataSharePredicates predicates2;
743 predicates2.EqualTo("id", std::to_string(contactDataIdTwo));
744 QueryAndExpectResult(contactData, predicates2, values, "contact_Insert_test_900");
745 values.Clear();
746
747 rawContactId = RawContactInsert("lihong", values);
748 HILOG_INFO("contact_Insert_test_900 : rawContactId = %{public}ld", rawContactId);
749 EXPECT_GT(rawContactId, 0);
750 values.Clear();
751
752 int64_t contactDataIdThree = ContactDataInsert(rawContactId, "name", "lihong", "", values);
753 HILOG_INFO("contact_Insert_test_900 : contactDataIdThree = %{public}ld", contactDataIdThree);
754 EXPECT_GT(contactDataIdThree, 0);
755 OHOS::DataShare::DataSharePredicates predicates3;
756 predicates3.EqualTo("id", std::to_string(contactDataIdThree));
757 QueryAndExpectResult(contactData, predicates3, values, "contact_Insert_test_900");
758 values.Clear();
759
760 int64_t contactDataIdFour = ContactDataInsert(rawContactId, "organization", "tiantianxaingshang", "Test", values);
761 HILOG_INFO("contact_Insert_test_900 : contactDataIdFour = %{public}ld", contactDataIdFour);
762 EXPECT_GT(contactDataIdFour, 0);
763 OHOS::DataShare::DataSharePredicates predicates4;
764 predicates4.EqualTo("id", std::to_string(contactDataIdFour));
765 QueryAndExpectResult(contactData, predicates4, values, "contact_Insert_test_900");
766 values.Clear();
767 ClearContacts();
768 }
769
770 /*
771 * @tc.number contact_Insert_test_1000
772 * @tc.name Add a full field data to the contact_data table and verify that the insertion was successful
773 * @tc.desc Added ability to contact_data
774 * @tc.level Level1
775 * @tc.size MediumTest
776 * @tc.type Function
777 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_1000, testing::ext::TestSize.Level1)778 HWTEST_F(ContactAbilityTest, contact_Insert_test_1000, testing::ext::TestSize.Level1)
779 {
780 HILOG_INFO("-----contact_Insert_test_1000 is starting!-----");
781 std::vector<std::string> columnsInt;
782 std::vector<std::string> columnsStr;
783 std::vector<std::string> columns;
784 std::string contactData = ContactTabName::CONTACT_DATA;
785 GetAllContactDataColumns(columnsInt, columnsStr);
786 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
787 OHOS::DataShare::DataShareValuesBucket rawContactValues;
788 int64_t rawContactId = RawContactInsert("feimaomao", rawContactValues);
789 valuesBucket.Put("raw_contact_id", rawContactId);
790 // type 6 is name
791 valuesBucket.Put("type_id", 6);
792 int ContactDataId = ContactDataInsertValues(valuesBucket);
793 EXPECT_GT(ContactDataId, 0);
794
795 MergeColumns(columns, columnsInt, columnsStr);
796 OHOS::DataShare::DataSharePredicates predicates;
797 predicates.EqualTo("raw_contact_id", std::to_string(rawContactId));
798 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(contactData, columns, predicates);
799 CheckResultSet(valuesBucket, resultSet, "contact_Insert_test_1000");
800 // resultSet count 1
801 int rowCount = -1;
802 resultSet->GetRowCount(rowCount);
803 EXPECT_EQ(1, rowCount);
804 CheckResultSet(valuesBucket, resultSet, "contact_Insert_test_1000");
805 ClearContacts();
806 }
807
808 /*
809 * @tc.number contact_Update_test_1100
810 * @tc.name Modify several basic information of the contact, and verify whether the modification is successful
811 * (including name, name Pinyin, Pinyin name, company, position and favorite)
812 * @tc.desc Contacts basic data table update ability
813 * @tc.level Level1
814 * @tc.size MediumTest
815 * @tc.type Function
816 */
HWTEST_F(ContactAbilityTest, contact_Update_test_1100, testing::ext::TestSize.Level1)817 HWTEST_F(ContactAbilityTest, contact_Update_test_1100, testing::ext::TestSize.Level1)
818 {
819 HILOG_INFO("--- contact_Update_test_1100 is starting! ---");
820 OHOS::DataShare::DataShareValuesBucket values;
821 std::vector<std::string> vectorValue;
822 vectorValue.push_back("zhangming");
823 vectorValue.push_back("tiantianxaingshang");
824 vectorValue.push_back("Test");
825 vectorValue.push_back("zhangming||zm");
826 int64_t rawContactId = RawContactExpandInsert(vectorValue, 1, values);
827 HILOG_INFO("contact_Update_test_1100 : rawContactId = %{public}ld", rawContactId);
828 EXPECT_GT(rawContactId, 0);
829
830 OHOS::DataShare::DataShareValuesBucket updateValues;
831 updateValues.Put("display_name", "dongming");
832 OHOS::DataShare::DataSharePredicates predicates;
833 predicates.EqualTo("id", std::to_string(rawContactId));
834 std::string rawContacts = ContactTabName::RAW_CONTACT;
835 int updateCode = ContactUpdate(rawContacts, updateValues, predicates);
836 EXPECT_EQ(updateCode, 0);
837 QueryAndExpectResult(rawContacts, predicates, updateValues, "contact_Update_test_1100");
838
839 updateValues.Clear();
840 updateValues.Put("company", "XXXX");
841 updateCode = ContactUpdate(rawContacts, updateValues, predicates);
842 EXPECT_EQ(updateCode, 0);
843 QueryAndExpectResult(rawContacts, predicates, updateValues, "contact_Update_test_1100");
844
845 updateValues.Clear();
846 updateValues.Put("position", "Secretary");
847 updateCode = ContactUpdate(rawContacts, updateValues, predicates);
848 EXPECT_EQ(updateCode, 0);
849 QueryAndExpectResult(rawContacts, predicates, updateValues, "contact_Update_test_1100");
850
851 updateValues.Clear();
852 updateValues.Put("favorite", "0");
853 updateCode = ContactUpdate(rawContacts, updateValues, predicates);
854 EXPECT_EQ(updateCode, 0);
855 QueryAndExpectResult(rawContacts, predicates, updateValues, "contact_Update_test_1100");
856
857 updateValues.Clear();
858 updateValues.Put("phonetic_name", "dongming||dm");
859 updateCode = ContactUpdate(rawContacts, updateValues, predicates);
860 EXPECT_EQ(updateCode, 0);
861 QueryAndExpectResult(rawContacts, predicates, updateValues, "contact_Update_test_1100");
862 ClearContacts();
863 }
864
865 /*
866 * @tc.number contact_Update_test_1200
867 * @tc.name Modify the basic information of multiple contacts and verify whether the modification is successful
868 * @tc.desc Contacts basic data table update ability
869 * @tc.level Level1
870 * @tc.size MediumTest
871 * @tc.type Function
872 */
HWTEST_F(ContactAbilityTest, contact_Update_test_1200, testing::ext::TestSize.Level1)873 HWTEST_F(ContactAbilityTest, contact_Update_test_1200, testing::ext::TestSize.Level1)
874 {
875 HILOG_INFO("--- contact_Update_test_1200 is starting! ---");
876 OHOS::DataShare::DataShareValuesBucket values;
877 int64_t rawContactIdOne = RawContactInsert("zhangming", values);
878 EXPECT_GT(rawContactIdOne, 0);
879 values.Clear();
880
881 int64_t rawContactIdTwo = RawContactInsert("ligang", values);
882 EXPECT_GT(rawContactIdTwo, 0);
883 values.Clear();
884
885 int64_t rawContactIdThree = RawContactInsert("wanghong", values);
886 EXPECT_GT(rawContactIdThree, 0);
887 values.Clear();
888
889 OHOS::DataShare::DataShareValuesBucket updateValues;
890 updateValues.Put("display_name", "dongming");
891 OHOS::DataShare::DataSharePredicates predicates;
892 predicates.EqualTo("id", std::to_string(rawContactIdOne));
893 std::string rawContacts = ContactTabName::RAW_CONTACT;
894 int updateCode = ContactUpdate(rawContacts, updateValues, predicates);
895 EXPECT_EQ(updateCode, 0);
896 QueryAndExpectResult(rawContacts, predicates, updateValues, "contact_Update_test_1200");
897
898 updateValues.Clear();
899 updateValues.Put("display_name", std::string("laoliu"));
900 OHOS::DataShare::DataSharePredicates predicates2;
901 predicates2.EqualTo("id", std::to_string(rawContactIdThree));
902 updateCode = ContactUpdate(rawContacts, updateValues, predicates2);
903 EXPECT_EQ(updateCode, 0);
904 QueryAndExpectResult(rawContacts, predicates2, updateValues, "contact_Update_test_1200");
905 ClearContacts();
906 }
907
908 /*
909 * @tc.number contact_Update_test_1300
910 * @tc.name Update the full field data of the raw_contact table and verify whether the modification is successful
911 * @tc.desc Support all raw_contact update capability
912 * @tc.level Level1
913 * @tc.size MediumTest
914 * @tc.type Function
915 */
HWTEST_F(ContactAbilityTest, contact_Update_test_1300, testing::ext::TestSize.Level1)916 HWTEST_F(ContactAbilityTest, contact_Update_test_1300, testing::ext::TestSize.Level1)
917 {
918 HILOG_INFO("-----contact_Update_test_1300 is starting!-----");
919 std::vector<std::string> columns;
920 std::vector<std::string> columnsInt;
921 std::vector<std::string> columnsStr;
922 std::string rawContacts = ContactTabName::RAW_CONTACT;
923 GetAllRawContactColumns(columnsInt, columnsStr);
924 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
925 int rawId = RawContactInsertValues(valuesBucket);
926 EXPECT_GT(rawId, 0);
927
928 MergeColumns(columns, columnsInt, columnsStr);
929 OHOS::DataShare::DataSharePredicates predicates;
930 predicates.EqualTo("id", std::to_string(rawId));
931 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetOne = ContactQuery(rawContacts, columns, predicates);
932 CheckResultSet(valuesBucket, resultSetOne, "contact_Update_test_1300");
933
934 OHOS::DataShare::DataShareValuesBucket upDateValuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
935 int upDateCode = ContactUpdate(rawContacts, upDateValuesBucket, predicates);
936 EXPECT_EQ(upDateCode, 0);
937 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(rawContacts, columns, predicates);
938
939 // resultSet count 1
940 int rowCount = -1;
941 resultSet->GetRowCount(rowCount);
942 EXPECT_EQ(1, rowCount);
943 CheckResultSet(upDateValuesBucket, resultSet, "contact_Update_test_1300");
944 ClearContacts();
945 }
946
947 /*
948 * @tc.number contact_Update_test_1400
949 * @tc.name Modify the details of a single contact and verify whether the modification is successful
950 * (name, company, position and email address)
951 * @tc.desc The ability to update the contact detail data table
952 * @tc.level Level1
953 * @tc.size MediumTest
954 * @tc.type Function
955 */
HWTEST_F(ContactAbilityTest, contact_Update_test_1400, testing::ext::TestSize.Level1)956 HWTEST_F(ContactAbilityTest, contact_Update_test_1400, testing::ext::TestSize.Level1)
957 {
958 HILOG_INFO("--- contact_Update_test_1400 is starting! ---");
959 OHOS::DataShare::DataShareValuesBucket values;
960 int64_t rawContactId = RawContactInsert("ligang", values);
961 EXPECT_GT(rawContactId, 0);
962 values.Clear();
963
964 OHOS::DataShare::DataShareValuesBucket valuesOne;
965 int64_t contactDataIdOne = ContactDataInsert(rawContactId, "name", "ligang", "", valuesOne);
966 EXPECT_GT(contactDataIdOne, 0);
967
968 OHOS::DataShare::DataShareValuesBucket valuesTwo;
969 int64_t contactDataIdTwo = ContactDataInsert(rawContactId, "organization", "tiantianxaingshang", "Test", valuesTwo);
970 EXPECT_GT(contactDataIdTwo, 0);
971
972 OHOS::DataShare::DataShareValuesBucket valuesThree;
973 int64_t contactDataIdThree = ContactDataInsert(rawContactId, "email", "8523@163.com", "", valuesThree);
974 EXPECT_GT(contactDataIdThree, 0);
975
976 OHOS::DataShare::DataShareValuesBucket updateValues;
977 updateValues.Put("detail_info", "dongming");
978 OHOS::DataShare::DataSharePredicates predicates;
979 predicates.EqualTo("id", std::to_string(contactDataIdOne));
980 std::string contactData = ContactTabName::CONTACT_DATA;
981 int updateCode = ContactUpdate(contactData, updateValues, predicates);
982 EXPECT_EQ(updateCode, 0);
983 QueryAndExpectResult(contactData, predicates, updateValues, "contact_Update_test_1400");
984
985 updateValues.Clear();
986 updateValues.Put("detail_info", "vivo");
987 updateValues.Put("position", "Developer");
988 OHOS::DataShare::DataSharePredicates predicates2;
989 predicates2.EqualTo("id", std::to_string(contactDataIdTwo));
990 updateCode = ContactUpdate(contactData, updateValues, predicates2);
991 EXPECT_EQ(updateCode, 0);
992 QueryAndExpectResult(contactData, predicates2, updateValues, "contact_Update_test_1400");
993
994 updateValues.Clear();
995 updateValues.Put("detail_info", "1220369@qq.com");
996 OHOS::DataShare::DataSharePredicates predicates3;
997 predicates3.EqualTo("id", std::to_string(contactDataIdThree));
998 updateCode = ContactUpdate(contactData, updateValues, predicates3);
999 EXPECT_EQ(updateCode, 0);
1000 QueryAndExpectResult(contactData, predicates3, updateValues, "contact_Update_test_1400");
1001 ClearContacts();
1002 }
1003
1004 /*
1005 * @tc.number contact_Update_test_1500
1006 * @tc.name Modify the details of a single contact and verify that the modification is successful
1007 * (mobile phone number, address and nickname)
1008 * @tc.desc The ability to update the contact detail data table
1009 * @tc.level Level1
1010 * @tc.size MediumTest
1011 * @tc.type Function
1012 */
HWTEST_F(ContactAbilityTest, contact_Update_test_1500, testing::ext::TestSize.Level1)1013 HWTEST_F(ContactAbilityTest, contact_Update_test_1500, testing::ext::TestSize.Level1)
1014 {
1015 HILOG_INFO("--- contact_Update_test_1500 is starting! ---");
1016 OHOS::DataShare::DataShareValuesBucket rawContactValues;
1017 int64_t rawContactId = RawContactInsert("xiaomi", rawContactValues);
1018 EXPECT_GT(rawContactId, 0);
1019
1020 OHOS::DataShare::DataShareValuesBucket contactDataValueOne;
1021 int64_t contactDataIdOne = ContactDataInsert(rawContactId, "phone", "1665230", "", contactDataValueOne);
1022 EXPECT_GT(contactDataIdOne, 0);
1023
1024 OHOS::DataShare::DataShareValuesBucket contactDataValueTwo;
1025 int64_t contactDataIdTwo = ContactDataInsert(rawContactId, "nickname", "xiaomi", "", contactDataValueTwo);
1026 EXPECT_GT(contactDataIdTwo, 0);
1027
1028 OHOS::DataShare::DataShareValuesBucket contactDataValueThree;
1029 int64_t contactDataIdThree =
1030 ContactDataInsert(rawContactId, "postal_address", "BeiJingFir", "", contactDataValueThree);
1031 EXPECT_GT(contactDataIdThree, 0);
1032
1033 OHOS::DataShare::DataShareValuesBucket updateValues;
1034 updateValues.Put("detail_info", "33996652");
1035 OHOS::DataShare::DataSharePredicates predicates;
1036 predicates.EqualTo("id", std::to_string(contactDataIdOne));
1037 std::string contactData = ContactTabName::CONTACT_DATA;
1038 int updateCode = ContactUpdate(contactData, updateValues, predicates);
1039 HILOG_INFO("contact_Update_test_1500: updateCode = %{public}d", updateCode);
1040 EXPECT_EQ(updateCode, 0);
1041 QueryAndExpectResult(contactData, predicates, updateValues, "contact_Update_test_1500");
1042
1043 updateValues.Clear();
1044 updateValues.Put("detail_info", "mimi");
1045 OHOS::DataShare::DataSharePredicates predicates2;
1046 predicates2.EqualTo("id", std::to_string(contactDataIdTwo));
1047 updateCode = ContactUpdate(contactData, updateValues, predicates2);
1048 EXPECT_EQ(updateCode, 0);
1049 QueryAndExpectResult(contactData, predicates2, updateValues, "contact_Update_test_1500");
1050
1051 updateValues.Clear();
1052 updateValues.Put("detail_info", "NanJIngGulou");
1053 OHOS::DataShare::DataSharePredicates predicates3;
1054 predicates3.EqualTo("id", std::to_string(contactDataIdThree));
1055 updateCode = ContactUpdate(contactData, updateValues, predicates3);
1056 EXPECT_EQ(updateCode, 0);
1057 QueryAndExpectResult(contactData, predicates3, updateValues, "contact_Update_test_1500");
1058 ClearContacts();
1059 }
1060
1061 /*
1062 * @tc.number contact_Update_test_1600
1063 * @tc.name Modify the details of individual contacts and verify whether the modification is successful
1064 * (remarks, goals and birthdays)
1065 * @tc.desc The ability to update the contact detail data table
1066 * @tc.level Level1
1067 * @tc.size MediumTest
1068 * @tc.type Function
1069 */
HWTEST_F(ContactAbilityTest, contact_Update_test_1600, testing::ext::TestSize.Level1)1070 HWTEST_F(ContactAbilityTest, contact_Update_test_1600, testing::ext::TestSize.Level1)
1071 {
1072 HILOG_INFO("--- contact_Update_test_1600 is starting! ---");
1073 OHOS::DataShare::DataShareValuesBucket rawContactValues;
1074 int64_t rawContactId = RawContactInsert("xiaocai", rawContactValues);
1075 EXPECT_GT(rawContactId, 0);
1076
1077 OHOS::DataShare::DataShareValuesBucket contactDataValueOne;
1078 int64_t contactDataIdOne = ContactDataInsert(rawContactId, "note", "dalao", "", contactDataValueOne);
1079 EXPECT_GT(contactDataIdOne, 0);
1080
1081 OHOS::DataShare::DataShareValuesBucket contactDataValueTwo;
1082 int64_t contactDataIdTwo = ContactDataInsert(rawContactId, "im", "aaaaaa", "", contactDataValueTwo);
1083 EXPECT_GT(contactDataIdTwo, 0);
1084
1085 OHOS::DataShare::DataShareValuesBucket contactDataValueThree;
1086 int64_t contactDataIdThree =
1087 ContactDataInsert(rawContactId, "contact_event", "19820314", "", contactDataValueThree);
1088 EXPECT_GT(contactDataIdThree, 0);
1089
1090 OHOS::DataShare::DataShareValuesBucket updateValues;
1091 updateValues.Put("detail_info", "God");
1092 OHOS::DataShare::DataSharePredicates predicates;
1093 predicates.EqualTo("id", std::to_string(contactDataIdOne));
1094 std::string contactData = ContactTabName::CONTACT_DATA;
1095 int updateCode = ContactUpdate(contactData, updateValues, predicates);
1096 EXPECT_EQ(updateCode, 0);
1097 QueryAndExpectResult(contactData, predicates, updateValues, "contact_Update_test_1600");
1098
1099 updateValues.Clear();
1100 updateValues.Put("detail_info", "bcade");
1101 OHOS::DataShare::DataSharePredicates predicates2;
1102 predicates2.EqualTo("id", std::to_string(contactDataIdTwo));
1103 updateCode = ContactUpdate(contactData, updateValues, predicates2);
1104 HILOG_INFO("contact_Update_test_1600: updateCode = %{public}d", updateCode);
1105 EXPECT_EQ(updateCode, 0);
1106 QueryAndExpectResult(contactData, predicates2, updateValues, "contact_Update_test_1600");
1107
1108 updateValues.Clear();
1109 updateValues.Put("detail_info", "19820328");
1110 OHOS::DataShare::DataSharePredicates predicates3;
1111 predicates3.EqualTo("id", std::to_string(contactDataIdThree));
1112 updateCode = ContactUpdate(contactData, updateValues, predicates3);
1113 HILOG_INFO("contact_Update_test_1600: updateCode = %{public}d", updateCode);
1114 EXPECT_EQ(updateCode, 0);
1115 QueryAndExpectResult(contactData, predicates3, updateValues, "contact_Update_test_1600");
1116 ClearContacts();
1117 }
1118
1119 /*
1120 * @tc.number contact_Update_test_1700
1121 * @tc.name Modify the details of a single contact and verify that the modification was successful
1122 * (URL, assistant, and group)
1123 * @tc.desc The ability to update the contact detail data table
1124 * @tc.level Level1
1125 * @tc.size MediumTest
1126 * @tc.type Function
1127 */
HWTEST_F(ContactAbilityTest, contact_Update_test_1700, testing::ext::TestSize.Level1)1128 HWTEST_F(ContactAbilityTest, contact_Update_test_1700, testing::ext::TestSize.Level1)
1129 {
1130 HILOG_INFO("--- contact_Update_test_1700 is starting! ---");
1131 OHOS::DataShare::DataShareValuesBucket rawContactValues;
1132 int64_t rawContactId = RawContactInsert("xiaocai", rawContactValues);
1133 EXPECT_GT(rawContactId, 0);
1134
1135 OHOS::DataShare::DataShareValuesBucket contactValuesOne;
1136 int64_t contactDataIdOne = ContactDataInsert(rawContactId, "website", "www.aaa.com", "", contactValuesOne);
1137 EXPECT_GT(contactDataIdOne, 0);
1138
1139 OHOS::DataShare::DataShareValuesBucket contactValuesTwo;
1140 int64_t contactDataIdTwo = ContactDataInsert(rawContactId, "relation", "fuzi", "", contactValuesTwo);
1141 EXPECT_GT(contactDataIdTwo, 0);
1142
1143 OHOS::DataShare::DataShareValuesBucket contactValuesThree;
1144 int64_t contactDataIdThree = ContactDataInsert(rawContactId, "group_membership", "1", "", contactValuesThree);
1145 EXPECT_GT(contactDataIdThree, 0);
1146
1147 OHOS::DataShare::DataShareValuesBucket updateValues;
1148 updateValues.Put("detail_info", "www.bbb.com");
1149 OHOS::DataShare::DataSharePredicates predicates;
1150 predicates.EqualTo("id", std::to_string(contactDataIdOne));
1151 std::string contactData = ContactTabName::CONTACT_DATA;
1152 int updateCode = ContactUpdate(contactData, updateValues, predicates);
1153 EXPECT_EQ(updateCode, 0);
1154 QueryAndExpectResult(contactData, predicates, updateValues, "contact_Update_test_1700");
1155
1156 updateValues.Clear();
1157 updateValues.Put("detail_info", "laozhang");
1158 OHOS::DataShare::DataSharePredicates predicates2;
1159 predicates2.EqualTo("id", std::to_string(contactDataIdTwo));
1160 updateCode = ContactUpdate(contactData, updateValues, predicates2);
1161 HILOG_INFO("contact_Update_test_1700: updateCode = %{public}d", updateCode);
1162 EXPECT_EQ(updateCode, 0);
1163 QueryAndExpectResult(contactData, predicates2, updateValues, "contact_Update_test_1700");
1164
1165 updateValues.Clear();
1166 updateValues.Put("detail_info", "2");
1167 OHOS::DataShare::DataSharePredicates predicates3;
1168 predicates3.EqualTo("id", std::to_string(contactDataIdThree));
1169 updateCode = ContactUpdate(contactData, updateValues, predicates3);
1170 HILOG_INFO("contact_Update_test_1700: updateCode = %{public}d", updateCode);
1171 EXPECT_EQ(updateCode, 0);
1172 QueryAndExpectResult(contactData, predicates3, updateValues, "contact_Update_test_1700");
1173 ClearContacts();
1174 }
1175
1176 /*
1177 * @tc.number contact_Update_test_1800
1178 * @tc.name Modify the details of a single contact and verify that the modification was successful (phone ringing)
1179 * @tc.desc The ability to update the contact detail data table
1180 * @tc.level Level1
1181 * @tc.size MediumTest
1182 * @tc.type Function
1183 */
HWTEST_F(ContactAbilityTest, contact_Update_test_1800, testing::ext::TestSize.Level1)1184 HWTEST_F(ContactAbilityTest, contact_Update_test_1800, testing::ext::TestSize.Level1)
1185 {
1186 HILOG_INFO("--- contact_Update_test_1800 is starting! ---");
1187 OHOS::DataShare::DataShareValuesBucket rawContactValues;
1188 int64_t rawContactId = RawContactInsert("xiaocai", rawContactValues);
1189 EXPECT_GT(rawContactId, 0);
1190
1191 OHOS::DataShare::DataShareValuesBucket contactDataValues;
1192 int64_t contactDataIdOne = ContactDataInsert(rawContactId, "contact_misc", "111", "", contactDataValues);
1193 EXPECT_GT(contactDataIdOne, 0);
1194
1195 OHOS::DataShare::DataShareValuesBucket updateValues;
1196 updateValues.Put("detail_info", "222");
1197 OHOS::DataShare::DataSharePredicates predicates;
1198 predicates.EqualTo("id", std::to_string(contactDataIdOne));
1199 std::string contactData = ContactTabName::CONTACT_DATA;
1200 int updateCode = ContactUpdate(contactData, updateValues, predicates);
1201 HILOG_INFO("contact_Update_test_1800: updateCode = %{public}d", updateCode);
1202 EXPECT_EQ(updateCode, 0);
1203 QueryAndExpectResult(contactData, predicates, updateValues, "contact_Update_test_1800");
1204 ClearContacts();
1205 }
1206
1207 /*
1208 * @tc.number contact_Update_test_1900
1209 * @tc.name Modify multiple contact details and verify whether the modification is successful
1210 * @tc.desc The ability to update the contact detail data table
1211 * @tc.level Level1
1212 * @tc.size MediumTest
1213 * @tc.type Function
1214 */
HWTEST_F(ContactAbilityTest, contact_Update_test_1900, testing::ext::TestSize.Level1)1215 HWTEST_F(ContactAbilityTest, contact_Update_test_1900, testing::ext::TestSize.Level1)
1216 {
1217 HILOG_INFO("--- contact_Update_test_1900 is starting! ---");
1218 OHOS::DataShare::DataShareValuesBucket rawContactValues;
1219 int64_t rawContactIdOne = RawContactInsert("ligang", rawContactValues);
1220 EXPECT_GT(rawContactIdOne, 0);
1221 OHOS::DataShare::DataShareValuesBucket contactValues;
1222 int64_t contactDataId = ContactDataInsert(rawContactIdOne, "name", "ligang", "", contactValues);
1223 EXPECT_GT(contactDataId, 0);
1224 contactValues.Clear();
1225
1226 contactDataId = ContactDataInsert(rawContactIdOne, "organization", "tiantianxaingshang", "Test", contactValues);
1227 EXPECT_GT(contactDataId, 0);
1228 contactValues.Clear();
1229
1230 rawContactValues.Clear();
1231 int64_t rawContactIdTwo = RawContactInsert("zhangming", rawContactValues);
1232 EXPECT_GT(rawContactIdTwo, 0);
1233
1234 contactDataId = ContactDataInsert(rawContactIdTwo, "name", "zhangming", "", contactValues);
1235 EXPECT_GT(contactDataId, 0);
1236 contactValues.Clear();
1237
1238 contactDataId = ContactDataInsert(rawContactIdTwo, "organization", "tiantianxaingshang", "Test", contactValues);
1239 EXPECT_GT(contactDataId, 0);
1240
1241 OHOS::DataShare::DataShareValuesBucket updateValues;
1242 updateValues.Put("detail_info", "lixiang");
1243 OHOS::DataShare::DataSharePredicates predicates;
1244 predicates.EqualTo("raw_contact_id", std::to_string(rawContactIdOne));
1245 predicates.And();
1246 // type 6 is phone
1247 predicates.EqualTo("type_id", "6");
1248 std::string contactData = ContactTabName::CONTACT_DATA;
1249 int updateCode = ContactUpdate(contactData, updateValues, predicates);
1250 EXPECT_EQ(updateCode, 0);
1251 QueryAndExpectResult(contactData, predicates, updateValues, "contact_Update_test_1900");
1252
1253 updateValues.Clear();
1254 updateValues.Put("detail_info", "zhangsan");
1255 OHOS::DataShare::DataSharePredicates predicates2;
1256 predicates2.EqualTo("raw_contact_id", std::to_string(rawContactIdTwo));
1257 predicates2.And();
1258 // type 6 is phone
1259 predicates2.EqualTo("type_id", "6");
1260 updateCode = ContactUpdate(contactData, updateValues, predicates2);
1261 HILOG_INFO("contact_Update_test_1900: updateCode = %{public}d", updateCode);
1262 EXPECT_EQ(updateCode, 0);
1263 QueryAndExpectResult(contactData, predicates2, updateValues, "contact_Update_test_1900");
1264 ClearContacts();
1265 }
1266
1267 /*
1268 * @tc.number contact_Update_test_2000
1269 * @tc.name Update the full field data of the contact_data table and verify whether the modification is successful
1270 * @tc.desc Update ability to contact_data
1271 * @tc.level Level1
1272 * @tc.size MediumTest
1273 * @tc.type Function
1274 */
HWTEST_F(ContactAbilityTest, contact_Update_test_2000, testing::ext::TestSize.Level1)1275 HWTEST_F(ContactAbilityTest, contact_Update_test_2000, testing::ext::TestSize.Level1)
1276 {
1277 HILOG_INFO("-----contact_Update_test_2000 is starting!-----");
1278 std::vector<std::string> columnsInt;
1279 std::vector<std::string> columnsStr;
1280 std::vector<std::string> columns;
1281 std::string tableName = ContactTabName::CONTACT_DATA;
1282 GetAllContactDataColumns(columnsInt, columnsStr);
1283 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
1284 OHOS::DataShare::DataShareValuesBucket rawContactValues;
1285 int64_t rawContactId = RawContactInsert("feimaotui", rawContactValues);
1286 valuesBucket.Put("raw_contact_id", rawContactId);
1287 // type_id 6 is name
1288 valuesBucket.Put("type_id", 6);
1289 int ContactDataId = ContactDataInsertValues(valuesBucket);
1290 EXPECT_GT(ContactDataId, 0);
1291
1292 MergeColumns(columns, columnsInt, columnsStr);
1293 OHOS::DataShare::DataSharePredicates predicates;
1294 predicates.EqualTo("raw_contact_id", std::to_string(rawContactId));
1295 OHOS::DataShare::DataShareValuesBucket upDateValuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
1296
1297 int upDateCode = ContactUpdate(tableName, upDateValuesBucket, predicates);
1298 EXPECT_EQ(upDateCode, 0);
1299
1300 bool isValid = false;
1301 int versionCode = valuesBucket.Get("version", isValid);
1302 versionCode += 1;
1303 upDateValuesBucket.Put("version", versionCode);
1304 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(tableName, columns, predicates);
1305
1306 // resultSet count 1
1307 int rowCount = -1;
1308 resultSet->GetRowCount(rowCount);
1309 EXPECT_EQ(1, rowCount);
1310 CheckResultSet(upDateValuesBucket, resultSet, "contact_Update_test_2000");
1311 ClearContacts();
1312 }
1313
1314 /*
1315 * @tc.number contact_Update_test_2100
1316 * @tc.name Update all contact details and verify that the modification was successful
1317 * @tc.desc New ability to contact detailed data
1318 * @tc.level Level1
1319 * @tc.size MediumTest
1320 * @tc.type Function
1321 */
HWTEST_F(ContactAbilityTest, contact_Update_test_2100, testing::ext::TestSize.Level1)1322 HWTEST_F(ContactAbilityTest, contact_Update_test_2100, testing::ext::TestSize.Level1)
1323 {
1324 HILOG_INFO("--- contact_Update_test_2100 is starting! ---");
1325 OHOS::DataShare::DataShareValuesBucket rawValuesBucket;
1326 int64_t rawContactId = RawContactInsert("update_detail_contactdata", rawValuesBucket);
1327 EXPECT_GT(rawContactId, 0);
1328
1329 std::vector<std::string> columns;
1330 std::vector<std::string> columnQuery;
1331 columnQuery.push_back("detail_info");
1332 GetDetailsContactDataColumns(columns);
1333
1334 OHOS::DataShare::DataShareValuesBucket valuesBucket;
1335 OHOS::DataShare::DataShareValuesBucket upDateValuesBucket;
1336
1337 std::string randomStr = "";
1338 std::string updateStrValue = "";
1339 std::string tableName = ContactTabName::CONTACT_DATA;
1340 int columnSize = columns.size();
1341 for (int i = 0; i < columnSize; i++) {
1342 randomStr = columns[i] + std::to_string(ContactsRand());
1343 valuesBucket.Put("raw_contact_id", rawContactId);
1344 valuesBucket.Put("content_type", columns[i]);
1345 valuesBucket.Put("detail_info", randomStr);
1346 int contactDataId = ContactDataInsertValues(valuesBucket);
1347 EXPECT_GT(contactDataId, 0);
1348
1349 OHOS::DataShare::DataSharePredicates predicates;
1350 predicates.EqualTo("id", std::to_string(contactDataId));
1351 updateStrValue = "update_all" + randomStr;
1352 upDateValuesBucket.Put("detail_info", updateStrValue);
1353 int upDateCode = ContactUpdate(tableName, upDateValuesBucket, predicates);
1354 EXPECT_EQ(upDateCode, 0);
1355
1356 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
1357 ContactQuery(tableName, columnQuery, predicates);
1358 int rowCount = -1;
1359 resultSet->GetRowCount(rowCount);
1360 EXPECT_EQ(1, rowCount);
1361 CheckResultSet(upDateValuesBucket, resultSet, "contact_Update_test_2100");
1362
1363 valuesBucket.Clear();
1364 upDateValuesBucket.Clear();
1365 }
1366 ClearContacts();
1367 }
1368
1369 /*
1370 * @tc.number contact_Update_test_2200
1371 * @tc.name Add a single contact to your favorites and verify that the favorites field has changed
1372 * @tc.desc Contacts favorites and unfavorite capabilities
1373 * @tc.level Level1
1374 * @tc.size MediumTest
1375 * @tc.type Function
1376 */
HWTEST_F(ContactAbilityTest, contact_Update_test_2200, testing::ext::TestSize.Level1)1377 HWTEST_F(ContactAbilityTest, contact_Update_test_2200, testing::ext::TestSize.Level1)
1378 {
1379 HILOG_INFO("--- contact_Update_test_2200 is starting! ---");
1380 OHOS::DataShare::DataShareValuesBucket rawContactValues;
1381 int64_t rawContactId = RawContactInsert("xiaozong", rawContactValues);
1382 EXPECT_GT(rawContactId, 0);
1383
1384 OHOS::DataShare::DataShareValuesBucket updateValues;
1385 updateValues.Put("favorite", 1);
1386 OHOS::DataShare::DataSharePredicates predicates;
1387 predicates.EqualTo("id", std::to_string(rawContactId));
1388 std::string rawContacts = ContactTabName::RAW_CONTACT;
1389 int updateCode = ContactUpdate(rawContacts, updateValues, predicates);
1390 EXPECT_EQ(updateCode, 0);
1391 QueryAndExpectResult(rawContacts, predicates, updateValues, "contact_Update_test_2200");
1392 ClearContacts();
1393 }
1394
1395 /*
1396 * @tc.number contact_Update_test_2300
1397 * @tc.name Add multiple contacts to favorites and verify that the favorites field is changed
1398 * @tc.desc Contacts favorites and unfavorite capabilities
1399 * @tc.level Level1
1400 * @tc.size MediumTest
1401 * @tc.type Function
1402 */
HWTEST_F(ContactAbilityTest, contact_Update_test_2300, testing::ext::TestSize.Level1)1403 HWTEST_F(ContactAbilityTest, contact_Update_test_2300, testing::ext::TestSize.Level1)
1404 {
1405 HILOG_INFO("--- contact_Update_test_2300 is starting! ---");
1406 OHOS::DataShare::DataShareValuesBucket rawContactValues;
1407 int64_t rawContactIdOne = RawContactInsert("xiaowang", rawContactValues);
1408 EXPECT_GT(rawContactIdOne, 0);
1409
1410 rawContactValues.Clear();
1411 int64_t rawContactIdTwo = RawContactInsert("xiaozhou", rawContactValues);
1412 EXPECT_GT(rawContactIdTwo, 0);
1413 rawContactValues.Clear();
1414 int64_t rawContactIdThree = RawContactInsert("laowei", rawContactValues);
1415 EXPECT_GT(rawContactIdThree, 0);
1416
1417 OHOS::DataShare::DataShareValuesBucket updateValues;
1418 updateValues.Put("favorite", 1);
1419 OHOS::DataShare::DataSharePredicates predicates;
1420 predicates.EqualTo("id", std::to_string(rawContactIdOne));
1421 predicates.Or();
1422 predicates.EqualTo("id", std::to_string(rawContactIdTwo));
1423 predicates.Or();
1424 predicates.EqualTo("id", std::to_string(rawContactIdThree));
1425 std::string rawContacts = ContactTabName::RAW_CONTACT;
1426 int updateCode = ContactUpdate(rawContacts, updateValues, predicates);
1427 EXPECT_EQ(updateCode, 0);
1428
1429 OHOS::DataShare::DataSharePredicates predicates2;
1430 predicates2.EqualTo("id", std::to_string(rawContactIdOne));
1431 QueryAndExpectResult(rawContacts, predicates2, updateValues, "contact_Update_test_2300");
1432 OHOS::DataShare::DataSharePredicates predicates3;
1433 predicates3.EqualTo("id", std::to_string(rawContactIdTwo));
1434 QueryAndExpectResult(rawContacts, predicates3, updateValues, "contact_Update_test_2300");
1435 OHOS::DataShare::DataSharePredicates predicates4;
1436 predicates4.EqualTo("id", std::to_string(rawContactIdThree));
1437 QueryAndExpectResult(rawContacts, predicates4, updateValues, "contact_Update_test_2300");
1438 ClearContacts();
1439 }
1440
1441 /*
1442 * @tc.number contact_Update_test_2400
1443 * @tc.name Unfriend individual contacts and verify that the favorites field has changed
1444 * @tc.desc Contacts favorites and unfavorite capabilities
1445 * @tc.level Level1
1446 * @tc.size MediumTest
1447 * @tc.type Function
1448 */
HWTEST_F(ContactAbilityTest, contact_Update_test_2400, testing::ext::TestSize.Level1)1449 HWTEST_F(ContactAbilityTest, contact_Update_test_2400, testing::ext::TestSize.Level1)
1450 {
1451 HILOG_INFO("--- contact_Update_test_2400 is starting! ---");
1452 OHOS::DataShare::DataShareValuesBucket values;
1453 std::vector<std::string> vectorValue;
1454 vectorValue.push_back("zhangming");
1455 vectorValue.push_back("tiantianxaingshang");
1456 vectorValue.push_back("Test");
1457 vectorValue.push_back("zhangming||zm");
1458 int64_t rawContactId = RawContactExpandInsert(vectorValue, 1, values);
1459 EXPECT_GT(rawContactId, 0);
1460
1461 OHOS::DataShare::DataShareValuesBucket updateValues;
1462 updateValues.Put("favorite", 0);
1463 OHOS::DataShare::DataSharePredicates predicates;
1464 predicates.EqualTo("id", std::to_string(rawContactId));
1465 std::string rawContacts = ContactTabName::RAW_CONTACT;
1466 int updateCode = ContactUpdate(rawContacts, updateValues, predicates);
1467 EXPECT_EQ(updateCode, 0);
1468 QueryAndExpectResult(rawContacts, predicates, updateValues, "contact_Update_test_2400");
1469 ClearContacts();
1470 }
1471
1472 /*
1473 * @tc.number contact_Update_test_2500
1474 * @tc.name Remove favorites from multiple contacts and verify that the favorites field has changed
1475 * @tc.desc Contacts favorites and unfavorite capabilities
1476 * @tc.level Level1
1477 * @tc.size MediumTest
1478 * @tc.type Function
1479 */
HWTEST_F(ContactAbilityTest, contact_Update_test_2500, testing::ext::TestSize.Level1)1480 HWTEST_F(ContactAbilityTest, contact_Update_test_2500, testing::ext::TestSize.Level1)
1481 {
1482 HILOG_INFO("--- contact_Update_test_2500 is starting! ---");
1483 OHOS::DataShare::DataShareValuesBucket values;
1484 std::vector<std::string> vectorValue;
1485 vectorValue.push_back("zhangming");
1486 vectorValue.push_back("tiantianxaingshang");
1487 vectorValue.push_back("Test");
1488 vectorValue.push_back("zhangming||zm");
1489 int64_t rawContactId = RawContactExpandInsert(vectorValue, 1, values);
1490 EXPECT_GT(rawContactId, 0);
1491
1492 vectorValue.clear();
1493 values.Clear();
1494 vectorValue.push_back("laozhou");
1495 vectorValue.push_back("tiantianxaingshang");
1496 vectorValue.push_back("Test");
1497 vectorValue.push_back("laozhou||lz");
1498 int64_t rawContactIdTwo = RawContactExpandInsert(vectorValue, 1, values);
1499 EXPECT_GT(rawContactIdTwo, 0);
1500
1501 vectorValue.clear();
1502 values.Clear();
1503 vectorValue.push_back("abiao");
1504 vectorValue.push_back("tiantianxaingshang");
1505 vectorValue.push_back("Test");
1506 vectorValue.push_back("abiao||ab");
1507 int64_t rawContactIdThree = RawContactExpandInsert(vectorValue, 1, values);
1508 HILOG_INFO("contact_Update_test_2500 : rawContactIdThree = %{public}ld", rawContactIdThree);
1509 EXPECT_GT(rawContactIdThree, 0);
1510
1511 OHOS::DataShare::DataShareValuesBucket updateValues;
1512 updateValues.Put("favorite", 0);
1513 OHOS::DataShare::DataSharePredicates predicates;
1514 predicates.EqualTo("id", std::to_string(rawContactId));
1515 predicates.Or();
1516 predicates.EqualTo("id", std::to_string(rawContactIdTwo));
1517 predicates.Or();
1518 predicates.EqualTo("id", std::to_string(rawContactIdThree));
1519 std::string rawContacts = ContactTabName::RAW_CONTACT;
1520 int updateCode = ContactUpdate(rawContacts, updateValues, predicates);
1521 EXPECT_EQ(updateCode, 0);
1522
1523 OHOS::DataShare::DataSharePredicates predicates2;
1524 predicates2.EqualTo("id", std::to_string(rawContactId));
1525 QueryAndExpectResult(rawContacts, predicates2, updateValues, "contact_Update_test_2500");
1526
1527 OHOS::DataShare::DataSharePredicates predicates3;
1528 predicates3.EqualTo("id", std::to_string(rawContactIdTwo));
1529 QueryAndExpectResult(rawContacts, predicates3, updateValues, "contact_Update_test_2500");
1530
1531 OHOS::DataShare::DataSharePredicates predicates4;
1532 predicates4.EqualTo("id", std::to_string(rawContactIdThree));
1533 QueryAndExpectResult(rawContacts, predicates4, updateValues, "contact_Update_test_2500");
1534 ClearContacts();
1535 }
1536
1537 /*
1538 * @tc.number contact_Insert_test_2600
1539 * @tc.name Add a single record to the blocklist and verify that the insertion was successful
1540 * @tc.desc The ability to add and remove contacts from the blocklist
1541 * @tc.level Level1
1542 * @tc.size MediumTest
1543 * @tc.type Function
1544 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_2600, testing::ext::TestSize.Level1)1545 HWTEST_F(ContactAbilityTest, contact_Insert_test_2600, testing::ext::TestSize.Level1)
1546 {
1547 HILOG_INFO("--- contact_Insert_test_2600 is starting! ---");
1548 OHOS::DataShare::DataShareValuesBucket blocklistValues;
1549 int64_t blocklistId = ContactBlocklistInsert("10086", blocklistValues);
1550 EXPECT_GT(blocklistId, 0);
1551
1552 OHOS::DataShare::DataSharePredicates predicates;
1553 predicates.EqualTo("id", std::to_string(blocklistId));
1554 std::string contactBlocklist = ContactTabName::CONTACT_BLOCKLIST;
1555 QueryAndExpectResult(contactBlocklist, predicates, blocklistValues, "contact_Insert_test_2600");
1556 ClearContacts();
1557 }
1558
1559 /*
1560 * @tc.number contact_Insert_test_2700
1561 * @tc.name Add multiple records to the blocklist and verify whether the insertion is successful
1562 * @tc.desc The ability to add and remove contacts from the blocklist
1563 * @tc.level Level1
1564 * @tc.size MediumTest
1565 * @tc.type Function
1566 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_2700, testing::ext::TestSize.Level1)1567 HWTEST_F(ContactAbilityTest, contact_Insert_test_2700, testing::ext::TestSize.Level1)
1568 {
1569 HILOG_INFO("--- contact_Insert_test_2700 is starting! ---");
1570 std::string contactBlocklist = ContactTabName::CONTACT_BLOCKLIST;
1571 OHOS::DataShare::DataShareValuesBucket blocklistValues;
1572 int64_t blocklistIdOne = ContactBlocklistInsert("188520", blocklistValues);
1573 EXPECT_GT(blocklistIdOne, 0);
1574 OHOS::DataShare::DataSharePredicates predicates;
1575 predicates.EqualTo("id", std::to_string(blocklistIdOne));
1576 QueryAndExpectResult(contactBlocklist, predicates, blocklistValues, "contact_Insert_test_2700");
1577
1578 blocklistValues.Clear();
1579 OHOS::DataShare::DataSharePredicates predicates2;
1580 int64_t blocklistIdTwo = ContactBlocklistInsert("130269", blocklistValues);
1581 EXPECT_GT(blocklistIdTwo, 0);
1582 predicates2.EqualTo("id", std::to_string(blocklistIdTwo));
1583 QueryAndExpectResult(contactBlocklist, predicates2, blocklistValues, "contact_Insert_test_2700");
1584
1585 blocklistValues.Clear();
1586 OHOS::DataShare::DataSharePredicates predicates3;
1587 int64_t blocklistIdThree = ContactBlocklistInsert("772501", blocklistValues);
1588 EXPECT_GT(blocklistIdThree, 0);
1589 predicates3.EqualTo("id", std::to_string(blocklistIdThree));
1590 QueryAndExpectResult(contactBlocklist, predicates3, blocklistValues, "contact_Insert_test_2700");
1591 ClearContacts();
1592 }
1593
1594 /*
1595 * @tc.number contact_Insert_test_2800
1596 * @tc.name Add a full field data to the contact_blocklist table and verify whether the insertion is successful
1597 * @tc.desc Added ability to ContactBlocklist
1598 * @tc.level Level1
1599 * @tc.size MediumTest
1600 * @tc.type Function
1601 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_2800, testing::ext::TestSize.Level1)1602 HWTEST_F(ContactAbilityTest, contact_Insert_test_2800, testing::ext::TestSize.Level1)
1603 {
1604 HILOG_INFO("-----contact_Insert_test_2800 is starting!-----");
1605 std::vector<std::string> columnsInt;
1606 std::vector<std::string> columnsStr;
1607 std::vector<std::string> columns;
1608 std::string tableName = ContactTabName::CONTACT_BLOCKLIST;
1609 GetAllContactBlocklistColumns(columnsInt, columnsStr);
1610 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
1611 int contactBlockId = ContactBlocklistInsertValues(valuesBucket);
1612 EXPECT_GT(contactBlockId, 0);
1613
1614 MergeColumns(columns, columnsInt, columnsStr);
1615 OHOS::DataShare::DataSharePredicates predicates;
1616 predicates.EqualTo("id", std::to_string(contactBlockId));
1617 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(tableName, columns, predicates);
1618 // resultSet count 1
1619 int rowCount = -1;
1620 resultSet->GetRowCount(rowCount);
1621 EXPECT_EQ(1, rowCount);
1622 CheckResultSet(valuesBucket, resultSet, "contact_Insert_test_2800");
1623 ClearContacts();
1624 }
1625
1626 /*
1627 * @tc.number contact_Delete_test_2900
1628 * @tc.name Delete a contact from the blocklist and verify whether the deletion is successful
1629 * @tc.desc The ability to add and remove contacts from the blocklist
1630 * @tc.level Level1
1631 * @tc.size MediumTest
1632 * @tc.type Function
1633 */
HWTEST_F(ContactAbilityTest, contact_Delete_test_2900, testing::ext::TestSize.Level1)1634 HWTEST_F(ContactAbilityTest, contact_Delete_test_2900, testing::ext::TestSize.Level1)
1635 {
1636 HILOG_INFO("--- contact_Delete_test_2900 is starting! ---");
1637 OHOS::DataShare::DataShareValuesBucket blocklistValues;
1638 int64_t blocklistId = ContactBlocklistInsert("147852369", blocklistValues);
1639 EXPECT_GT(blocklistId, 0);
1640
1641 OHOS::DataShare::DataSharePredicates predicates;
1642 predicates.EqualTo("id", std::to_string(blocklistId));
1643 std::string contactBlocklist = ContactTabName::CONTACT_BLOCKLIST;
1644 int deleteCode = ContactDelete(contactBlocklist, predicates);
1645 EXPECT_EQ(deleteCode, 0);
1646 std::vector<std::string> columns;
1647 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
1648 ContactQuery(contactBlocklist, columns, predicates);
1649 int rowCount = 0;
1650 resultSet->GetRowCount(rowCount);
1651 EXPECT_EQ(0, rowCount);
1652 resultSet->Close();
1653 ClearContacts();
1654 }
1655
1656 /*
1657 * @tc.number contact_Delete_test_3000
1658 * @tc.name Delete multiple contacts from the blocklist and verify whether the deletion is successful
1659 * @tc.desc The ability to add and remove contacts from the blocklist
1660 * @tc.level Level1
1661 * @tc.size MediumTest
1662 * @tc.type Function
1663 */
HWTEST_F(ContactAbilityTest, contact_Delete_test_3000, testing::ext::TestSize.Level1)1664 HWTEST_F(ContactAbilityTest, contact_Delete_test_3000, testing::ext::TestSize.Level1)
1665 {
1666 HILOG_INFO("--- contact_Delete_test_3000 is starting! ---");
1667 OHOS::DataShare::DataShareValuesBucket blocklistValues;
1668 int64_t blocklistIdOne = ContactBlocklistInsert("111228855", blocklistValues);
1669 EXPECT_GT(blocklistIdOne, 0);
1670
1671 blocklistValues.Clear();
1672 int64_t blocklistIdTwo = ContactBlocklistInsert("11335566", blocklistValues);
1673 EXPECT_GT(blocklistIdTwo, 0);
1674
1675 blocklistValues.Clear();
1676 int64_t blocklistIdThree = ContactBlocklistInsert("9933220011", blocklistValues);
1677 EXPECT_GT(blocklistIdThree, 0);
1678
1679 OHOS::DataShare::DataSharePredicates predicates;
1680 predicates.EqualTo("id", std::to_string(blocklistIdOne));
1681 predicates.Or();
1682 predicates.EqualTo("id", std::to_string(blocklistIdTwo));
1683 predicates.Or();
1684 predicates.EqualTo("id", std::to_string(blocklistIdThree));
1685 std::string contactBlocklist = ContactTabName::CONTACT_BLOCKLIST;
1686 int deleteCode = ContactDelete(contactBlocklist, predicates);
1687 EXPECT_EQ(deleteCode, 0);
1688
1689 std::vector<std::string> columns;
1690 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
1691 ContactQuery(contactBlocklist, columns, predicates);
1692 int rowCount = 0;
1693 resultSet->GetRowCount(rowCount);
1694 EXPECT_EQ(0, rowCount);
1695 resultSet->Close();
1696 ClearContacts();
1697 }
1698
1699 /*
1700 * @tc.number contact_Delete_test_3100
1701 * @tc.name Delete a full field data of contact_blocklist table and verify whether the deletion is successful
1702 * @tc.desc ContactBlocklist deletion capability
1703 * @tc.level Level1
1704 * @tc.size MediumTest
1705 * @tc.type Function
1706 */
HWTEST_F(ContactAbilityTest, contact_Delete_test_3100, testing::ext::TestSize.Level1)1707 HWTEST_F(ContactAbilityTest, contact_Delete_test_3100, testing::ext::TestSize.Level1)
1708 {
1709 HILOG_INFO("-----contact_Delete_test_3100 is starting!-----");
1710 // insert
1711 std::vector<std::string> columns;
1712 std::vector<std::string> columnsInt;
1713 std::vector<std::string> columnsStr;
1714 GetAllContactBlocklistColumns(columnsInt, columnsStr);
1715 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
1716 int contacBlockId = ContactBlocklistInsertValues(valuesBucket);
1717 EXPECT_GT(contacBlockId, 0);
1718
1719 // test end delete data
1720 OHOS::DataShare::DataSharePredicates predicates;
1721 predicates.EqualTo("id", std::to_string(contacBlockId));
1722 std::string tableName = ContactTabName::CONTACT_BLOCKLIST;
1723 int deleteCode = ContactDelete(tableName, predicates);
1724 EXPECT_EQ(deleteCode, 0);
1725
1726 MergeColumns(columns, columnsInt, columnsStr);
1727 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetDeleteQuery =
1728 ContactQuery(tableName, columns, predicates);
1729 int rowCount = -1;
1730 resultSetDeleteQuery->GetRowCount(rowCount);
1731 EXPECT_EQ(0, rowCount);
1732 ClearContacts();
1733 }
1734
1735 /*
1736 * @tc.number contact_Insert_test_3200
1737 * @tc.name Join a single contact to the group and verify whether the join is successful
1738 * @tc.desc Ability to add and remove contacts from groups
1739 * @tc.level Level1
1740 * @tc.size MediumTest
1741 * @tc.type Function
1742 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_3200, testing::ext::TestSize.Level1)1743 HWTEST_F(ContactAbilityTest, contact_Insert_test_3200, testing::ext::TestSize.Level1)
1744 {
1745 HILOG_INFO("--- contact_Insert_test_3200 is staring! ---");
1746 OHOS::DataShare::DataShareValuesBucket rawContactValues;
1747 int64_t rawContactId = RawContactInsert("xiaoli", rawContactValues);
1748 EXPECT_GT(rawContactId, 0);
1749
1750 OHOS::DataShare::DataShareValuesBucket groupValues;
1751 int64_t groupId = GroupsInsert("TestFirstGroup", groupValues);
1752 EXPECT_GT(groupId, 0);
1753 OHOS::DataShare::DataShareValuesBucket contactDataValue;
1754 int64_t contactDataId =
1755 ContactDataInsert(rawContactId, "group_membership", std::to_string(groupId), "", contactDataValue);
1756 EXPECT_GT(contactDataId, 0);
1757 OHOS::DataShare::DataSharePredicates predicates;
1758 predicates.EqualTo("id", std::to_string(contactDataId));
1759 std::string contactData = ContactTabName::CONTACT_DATA;
1760 QueryAndExpectResult(contactData, predicates, contactDataValue, "contact_Insert_test_3200");
1761 ClearContacts();
1762 }
1763
1764 /*
1765 * @tc.number contact_Insert_test_3300
1766 * @tc.name Multiple contacts join the group and verify whether the joining is successful
1767 * @tc.desc Ability to add and remove contacts from groups
1768 * @tc.level Level1
1769 * @tc.size MediumTest
1770 * @tc.type Function
1771 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_3300, testing::ext::TestSize.Level1)1772 HWTEST_F(ContactAbilityTest, contact_Insert_test_3300, testing::ext::TestSize.Level1)
1773 {
1774 HILOG_INFO("--- contact_Insert_test_3300 is staring! ---");
1775 OHOS::DataShare::DataShareValuesBucket groupValues;
1776 int64_t groupIdOne = GroupsInsert("TestSecondGroup", groupValues);
1777 EXPECT_GT(groupIdOne, 0);
1778 groupValues.Clear();
1779
1780 int64_t groupIdTwo = GroupsInsert("DeveloperFirstGroup", groupValues);
1781 EXPECT_GT(groupIdTwo, 0);
1782
1783 OHOS::DataShare::DataShareValuesBucket rawContactValues;
1784 int64_t rawContactIdOne = RawContactInsert("xiaoli", rawContactValues);
1785 EXPECT_GT(rawContactIdOne, 0);
1786 rawContactValues.Clear();
1787
1788 int64_t rawContactIdTwo = RawContactInsert("BossCai", rawContactValues);
1789 EXPECT_GT(rawContactIdTwo, 0);
1790
1791 OHOS::DataShare::DataShareValuesBucket contactDataValuesOne;
1792 int64_t contactDataIdOne =
1793 ContactDataInsert(rawContactIdOne, "group_membership", std::to_string(groupIdOne), "", contactDataValuesOne);
1794 EXPECT_GT(contactDataIdOne, 0);
1795 std::string contactData = ContactTabName::CONTACT_DATA;
1796 OHOS::DataShare::DataSharePredicates predicates;
1797 predicates.EqualTo("id", std::to_string(contactDataIdOne));
1798 QueryAndExpectResult(contactData, predicates, contactDataValuesOne, "contact_Insert_test_3300");
1799
1800 OHOS::DataShare::DataShareValuesBucket contactDataValuesTwo;
1801 int64_t contactDataIdTwo =
1802 ContactDataInsert(rawContactIdTwo, "group_membership", std::to_string(groupIdTwo), "", contactDataValuesTwo);
1803 EXPECT_GT(contactDataIdTwo, 0);
1804 OHOS::DataShare::DataSharePredicates predicates2;
1805 predicates2.EqualTo("id", std::to_string(contactDataIdTwo));
1806 QueryAndExpectResult(contactData, predicates2, contactDataValuesTwo, "contact_Insert_test_3300");
1807 ClearContacts();
1808 }
1809
1810 /*
1811 * @tc.number contact_Insert_test_3400
1812 * @tc.name Add a full field data to the groups table and verify whether the insertion is successful
1813 * @tc.desc Added ability to groups
1814 * @tc.level Level1
1815 * @tc.size MediumTest
1816 * @tc.type Function
1817 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_3400, testing::ext::TestSize.Level1)1818 HWTEST_F(ContactAbilityTest, contact_Insert_test_3400, testing::ext::TestSize.Level1)
1819 {
1820 HILOG_INFO("-----contact_Insert_test_3400 is starting!-----");
1821 std::vector<std::string> columnsInt;
1822 std::vector<std::string> columnsStr;
1823 std::vector<std::string> columns;
1824 std::string group = ContactTabName::GROUPS;
1825 GetAllGroupsColumns(columnsInt, columnsStr);
1826 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
1827 int rawId = GroupsInsertValues(valuesBucket);
1828 EXPECT_GT(rawId, 0);
1829
1830 MergeColumns(columns, columnsInt, columnsStr);
1831 OHOS::DataShare::DataSharePredicates predicates;
1832 predicates.EqualTo("id", std::to_string(rawId));
1833 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(group, columns, predicates);
1834 // resultSet count 1
1835 int rowCount = -1;
1836 resultSet->GetRowCount(rowCount);
1837 EXPECT_EQ(1, rowCount);
1838 CheckResultSet(valuesBucket, resultSet, "contact_Insert_test_3400");
1839 ClearContacts();
1840 }
1841
1842 /*
1843 * @tc.number contact_Delete_test_3500
1844 * @tc.name Delete a single contact from the group and verify that the deletion was successful
1845 * @tc.desc Ability to add and remove contacts from groups
1846 * @tc.level Level1
1847 * @tc.size MediumTest
1848 * @tc.type Function
1849 */
HWTEST_F(ContactAbilityTest, contact_Delete_test_3500, testing::ext::TestSize.Level1)1850 HWTEST_F(ContactAbilityTest, contact_Delete_test_3500, testing::ext::TestSize.Level1)
1851 {
1852 HILOG_INFO("--- contact_Delete_test_3500 is starting! ---");
1853 OHOS::DataShare::DataShareValuesBucket groupValues;
1854 int64_t groupId = GroupsInsert("CEO", groupValues);
1855 EXPECT_GT(groupId, 0);
1856
1857 OHOS::DataShare::DataShareValuesBucket rawContactValues;
1858 int64_t rawContactId = RawContactInsert("xiaoli", rawContactValues);
1859 EXPECT_GT(rawContactId, 0);
1860
1861 OHOS::DataShare::DataShareValuesBucket contactDataValues;
1862 int64_t contactDataId =
1863 ContactDataInsert(rawContactId, "group_membership", std::to_string(groupId), "", contactDataValues);
1864 EXPECT_GT(contactDataId, 0);
1865
1866 std::string contactData = ContactTabName::CONTACT_DATA;
1867 OHOS::DataShare::DataSharePredicates predicates;
1868 predicates.EqualTo("raw_contact_id", std::to_string(rawContactId));
1869 predicates.And();
1870 // type_id 9 is group_membership
1871 predicates.EqualTo("type_id", "9");
1872 int deleteCode = ContactDelete(contactData, predicates);
1873 EXPECT_EQ(deleteCode, 0);
1874 OHOS::DataShare::DataSharePredicates predicates2;
1875 predicates2.EqualTo("id", std::to_string(contactDataId));
1876 std::vector<std::string> columns;
1877 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(contactData, columns, predicates2);
1878 int rowCount = 0;
1879 resultSet->GetRowCount(rowCount);
1880 EXPECT_EQ(0, rowCount);
1881 resultSet->Close();
1882 ClearContacts();
1883 }
1884
1885 /*
1886 * @tc.number contact_Delete_test_3600
1887 * @tc.name Delete multiple contacts from the group and verify that the deletion was successful
1888 * @tc.desc Ability to add and remove contacts from groups
1889 * @tc.level Level1
1890 * @tc.size MediumTest
1891 * @tc.type Function
1892 */
HWTEST_F(ContactAbilityTest, contact_Delete_test_3600, testing::ext::TestSize.Level1)1893 HWTEST_F(ContactAbilityTest, contact_Delete_test_3600, testing::ext::TestSize.Level1)
1894 {
1895 HILOG_INFO("--- contact_Delete_test_3600 is starting! ---");
1896 OHOS::DataShare::DataShareValuesBucket groupValues;
1897 int64_t groupIdOne = GroupsInsert("Test", groupValues);
1898 HILOG_INFO("contact_Delete_test_3600: groupIdOne = %{public}ld", groupIdOne);
1899 EXPECT_GT(groupIdOne, 0);
1900
1901 groupValues.Clear();
1902 int64_t groupIdTwo = GroupsInsert("Developer", groupValues);
1903 HILOG_INFO("contact_Delete_test_3600: groupIdTwo = %{public}ld", groupIdTwo);
1904 EXPECT_GT(groupIdTwo, 0);
1905 OHOS::DataShare::DataShareValuesBucket rawContactValues;
1906 int64_t rawContactIdOne = RawContactInsert("xiaoli", rawContactValues);
1907 EXPECT_GT(rawContactIdOne, 0);
1908
1909 rawContactValues.Clear();
1910 int64_t rawContactIdTwo = RawContactInsert("xiaoyuan", rawContactValues);
1911 EXPECT_GT(rawContactIdTwo, 0);
1912
1913 OHOS::DataShare::DataShareValuesBucket contactDataValues;
1914 int64_t contactDataIdOne =
1915 ContactDataInsert(rawContactIdOne, "group_membership", std::to_string(groupIdOne), "", contactDataValues);
1916 EXPECT_GT(contactDataIdOne, 0);
1917
1918 contactDataValues.Clear();
1919 int64_t contactDataIdTwo =
1920 ContactDataInsert(rawContactIdTwo, "group_membership", std::to_string(groupIdTwo), "", contactDataValues);
1921 EXPECT_GT(contactDataIdTwo, 0);
1922
1923 std::string contactData = ContactTabName::CONTACT_DATA;
1924 OHOS::DataShare::DataSharePredicates predicates;
1925 predicates.EqualTo("id", std::to_string(contactDataIdOne));
1926 predicates.Or();
1927 predicates.EqualTo("id", std::to_string(contactDataIdTwo));
1928 int deleteCode = ContactDelete(contactData, predicates);
1929 EXPECT_EQ(deleteCode, 0);
1930 OHOS::DataShare::DataSharePredicates predicates2;
1931 predicates2.EqualTo("id", std::to_string(contactDataIdOne));
1932 std::vector<std::string> columns;
1933 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(contactData, columns, predicates2);
1934 int rowCount = 0;
1935 resultSet->GetRowCount(rowCount);
1936 EXPECT_EQ(0, rowCount);
1937 resultSet->Close();
1938
1939 OHOS::DataShare::DataSharePredicates predicates3;
1940 predicates3.EqualTo("id", std::to_string(contactDataIdTwo));
1941 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetTwo = ContactQuery(contactData, columns, predicates3);
1942 int rowCountTwo = 0;
1943 resultSetTwo->GetRowCount(rowCountTwo);
1944 EXPECT_EQ(0, rowCountTwo);
1945 resultSetTwo->Close();
1946 ClearContacts();
1947 }
1948
1949 /*
1950 * @tc.number contact_Delete_test_3700
1951 * @tc.name Delete the full field data of a groups table and verify whether the deletion is successful
1952 * @tc.desc Groups deletion capability
1953 * @tc.level Level1
1954 * @tc.size MediumTest
1955 * @tc.type Function
1956 */
HWTEST_F(ContactAbilityTest, contact_Delete_test_3700, testing::ext::TestSize.Level1)1957 HWTEST_F(ContactAbilityTest, contact_Delete_test_3700, testing::ext::TestSize.Level1)
1958 {
1959 HILOG_INFO("-----contact_Delete_test_3700 is starting!-----");
1960 // insert
1961 std::vector<std::string> columns;
1962 std::vector<std::string> columnsInt;
1963 std::vector<std::string> columnsStr;
1964 GetAllGroupsColumns(columnsInt, columnsStr);
1965 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
1966 int groupId = GroupsInsertValues(valuesBucket);
1967 EXPECT_GT(groupId, 0);
1968
1969 // test end delete data
1970 OHOS::DataShare::DataSharePredicates predicates;
1971 predicates.EqualTo("id", std::to_string(groupId));
1972 EXPECT_GT(groupId, 0);
1973 std::string tableName = ContactTabName::GROUPS;
1974 int deleteCode = ContactDelete(tableName, predicates);
1975 EXPECT_EQ(deleteCode, 0);
1976
1977 MergeColumns(columns, columnsInt, columnsStr);
1978 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetDeleteQuery =
1979 ContactQuery(tableName, columns, predicates);
1980 int rowCount = -1;
1981 resultSetDeleteQuery->GetRowCount(rowCount);
1982 EXPECT_EQ(0, rowCount);
1983 ClearContacts();
1984 }
1985
1986 /*
1987 * @tc.number contact_Query_test_3800
1988 * @tc.name Insert contact information and query contact information according to the returned ID
1989 * @tc.desc The ability to query the basic information of a single contact
1990 * @tc.level Level1
1991 * @tc.size MediumTest
1992 * @tc.type Function
1993 */
HWTEST_F(ContactAbilityTest, contact_Query_test_3800, testing::ext::TestSize.Level1)1994 HWTEST_F(ContactAbilityTest, contact_Query_test_3800, testing::ext::TestSize.Level1)
1995 {
1996 HILOG_INFO("--- contact_Query_test_3800 is starting! ---");
1997 std::vector<std::string> columns;
1998 columns.push_back("display_name");
1999 columns.push_back("company");
2000 columns.push_back("position");
2001 columns.push_back("favorite");
2002 columns.push_back("phonetic_name");
2003 OHOS::DataShare::DataShareValuesBucket valuesBucket;
2004 valuesBucket.Put("display_name", "xiaoyuan");
2005 valuesBucket.Put("company", "tiantianxiangshang");
2006 valuesBucket.Put("position", "Test");
2007 valuesBucket.Put("favorite", 1);
2008 valuesBucket.Put("phonetic_name", "xiaoyuanxy");
2009
2010 int64_t rawContactId = RawContactInsertValues(valuesBucket);
2011 EXPECT_GT(rawContactId, 0);
2012 OHOS::DataShare::DataSharePredicates predicates;
2013 predicates.EqualTo("id", std::to_string(rawContactId));
2014 std::string rawContacts = ContactTabName::RAW_CONTACT;
2015 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(rawContacts, columns, predicates);
2016
2017 // resultSet count 1
2018 int rowCount = -1;
2019 resultSet->GetRowCount(rowCount);
2020 EXPECT_EQ(1, rowCount);
2021 CheckResultSet(valuesBucket, resultSet, "contact_Query_test_3800");
2022 ClearContacts();
2023 }
2024
2025 /*
2026 * @tc.number contact_Query_test_3900
2027 * @tc.name Insert multiple contact information and query the contact information according to the returned ID
2028 * @tc.desc The ability to query the basic information of multiple contacts
2029 * @tc.level Level1
2030 * @tc.size MediumTest
2031 * @tc.type Function
2032 */
HWTEST_F(ContactAbilityTest, contact_Query_test_3900, testing::ext::TestSize.Level1)2033 HWTEST_F(ContactAbilityTest, contact_Query_test_3900, testing::ext::TestSize.Level1)
2034 {
2035 HILOG_INFO("--- contact_Query_test_3900 is starting! ---");
2036 OHOS::DataShare::DataShareValuesBucket valuesBucketOne;
2037 valuesBucketOne.Put("display_name", "xiaohei");
2038 valuesBucketOne.Put("company", "tiantianxiangshang");
2039 valuesBucketOne.Put("position", "Test");
2040 valuesBucketOne.Put("favorite", 1);
2041 valuesBucketOne.Put("phonetic_name", "xiaohei||xh");
2042 int64_t rawContactIdOne = RawContactInsertValues(valuesBucketOne);
2043 EXPECT_GT(rawContactIdOne, 0);
2044
2045 OHOS::DataShare::DataShareValuesBucket valuesBucketTwo;
2046 valuesBucketTwo.Put("display_name", "xiaobai");
2047 valuesBucketTwo.Put("company", "tiantianxiangshang");
2048 valuesBucketTwo.Put("position", "Test");
2049 valuesBucketTwo.Put("favorite", 1);
2050 valuesBucketTwo.Put("phonetic_name", "xiaohei||xh");
2051 int64_t rawContactIdTwo = RawContactInsertValues(valuesBucketTwo);
2052 EXPECT_GT(rawContactIdTwo, 0);
2053
2054 OHOS::DataShare::DataShareValuesBucket valuesBucketThr;
2055 valuesBucketThr.Put("display_name", "xiaocai");
2056 valuesBucketThr.Put("company", "tiantianxiangshang");
2057 valuesBucketThr.Put("position", "Test");
2058 valuesBucketThr.Put("favorite", 1);
2059 valuesBucketThr.Put("phonetic_name", "xiaohei||xh");
2060 int64_t rawContactIdThr = RawContactInsertValues(valuesBucketThr);
2061 EXPECT_GT(rawContactIdThr, 0);
2062
2063 std::vector<std::string> columns;
2064 columns.push_back("display_name");
2065 columns.push_back("company");
2066 columns.push_back("position");
2067 columns.push_back("favorite");
2068 columns.push_back("phonetic_name");
2069 OHOS::DataShare::DataSharePredicates predicates;
2070 predicates.EqualTo("id", std::to_string(rawContactIdOne));
2071 predicates.Or();
2072 predicates.EqualTo("id", std::to_string(rawContactIdTwo));
2073 predicates.Or();
2074 predicates.EqualTo("id", std::to_string(rawContactIdThr));
2075 std::string rawContacts = ContactTabName::RAW_CONTACT;
2076 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(rawContacts, columns, predicates);
2077 std::vector<OHOS::DataShare::DataShareValuesBucket> listValue;
2078 listValue.push_back(valuesBucketOne);
2079 listValue.push_back(valuesBucketTwo);
2080 listValue.push_back(valuesBucketThr);
2081 CheckResultSetList(listValue, resultSet, "contact_Query_test_3900");
2082 ClearContacts();
2083 }
2084
2085 /*
2086 * @tc.number contact_Query_test_4000
2087 * @tc.name Query the basic information of all contacts in the raw_contact table
2088 * @tc.desc The ability to query the basic information of all contacts
2089 * @tc.level Level1
2090 * @tc.size MediumTest
2091 * @tc.type Function
2092 */
HWTEST_F(ContactAbilityTest, contact_Query_test_4000, testing::ext::TestSize.Level1)2093 HWTEST_F(ContactAbilityTest, contact_Query_test_4000, testing::ext::TestSize.Level1)
2094 {
2095 HILOG_INFO("--- contact_Query_test_4000 is starting! ---");
2096 std::string tag("contact_Query_test_4000");
2097 OHOS::DataShare::DataShareValuesBucket valuesBucketOne;
2098 valuesBucketOne.Put("display_name", "xiaohsaaei");
2099 valuesBucketOne.Put("company", "tiantianxiadsjjnngshang");
2100 valuesBucketOne.Put("position", "Tests");
2101 valuesBucketOne.Put("favorite", 1);
2102 valuesBucketOne.Put("phonetic_name", "xiaohssei||x00h");
2103 RawContactInsertValues(valuesBucketOne);
2104 RawContactInsertValues(valuesBucketOne);
2105 std::vector<std::string> columns;
2106 columns.push_back("id");
2107 columns.push_back("display_name");
2108 columns.push_back("company");
2109 columns.push_back("position");
2110 OHOS::DataShare::DataSharePredicates predicates;
2111 predicates.GreaterThan("id", "0");
2112 predicates.EqualTo("is_deleted", "0");
2113 std::string rawContacts = ContactTabName::RAW_CONTACT;
2114 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(rawContacts, columns, predicates);
2115 // resultSet count
2116 int rowCount = -1;
2117 resultSet->GetRowCount(rowCount);
2118 EXPECT_GT(rowCount, 1);
2119 ClearContacts();
2120 }
2121
2122 /*
2123 * @tc.number contact_Query_test_4100
2124 * @tc.name Insert all contact information and query
2125 * @tc.desc The ability to query all information of a single contact
2126 * @tc.level Level1
2127 * @tc.size MediumTest
2128 * @tc.type Function
2129 */
HWTEST_F(ContactAbilityTest, contact_Query_test_4100, testing::ext::TestSize.Level1)2130 HWTEST_F(ContactAbilityTest, contact_Query_test_4100, testing::ext::TestSize.Level1)
2131 {
2132 HILOG_INFO("-----contact_Query_test_4100 is starting!-----");
2133 std::vector<std::string> columnsInt;
2134 std::vector<std::string> columnsStr;
2135 std::vector<std::string> columns;
2136 std::string contactData = ContactTabName::CONTACT_DATA;
2137 GetAllContactDataColumns(columnsInt, columnsStr);
2138 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
2139 OHOS::DataShare::DataShareValuesBucket rawContactValues;
2140 rawContactValues.Put("favorite", "1");
2141 int64_t rawContactId = RawContactInsert("feimaomao4100", rawContactValues);
2142 valuesBucket.Put("raw_contact_id", rawContactId);
2143 // type 6 is name
2144 valuesBucket.Put("type_id", 6);
2145 int ContactDataId = ContactDataInsertValues(valuesBucket);
2146 EXPECT_GT(ContactDataId, 0);
2147
2148 MergeColumns(columns, columnsInt, columnsStr);
2149 OHOS::DataShare::DataSharePredicates predicates;
2150 predicates.EqualTo("raw_contact_id", std::to_string(rawContactId));
2151 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(contactData, columns, predicates);
2152 CheckResultSet(valuesBucket, resultSet, "contact_Query_test_4100");
2153 // resultSet count 1
2154 int rowCount = -1;
2155 resultSet->GetRowCount(rowCount);
2156 EXPECT_EQ(1, rowCount);
2157 CheckResultSet(valuesBucket, resultSet, "contact_Query_test_4100");
2158 ClearContacts();
2159 }
2160
2161 /*
2162 * @tc.number contact_Query_test_4200
2163 * @tc.name Add a group and add two new contacts to the group to query the members of the group
2164 * @tc.desc Query group member ability
2165 * @tc.level Level1
2166 * @tc.size MediumTest
2167 * @tc.type Function
2168 */
HWTEST_F(ContactAbilityTest, contact_Query_test_4200, testing::ext::TestSize.Level1)2169 HWTEST_F(ContactAbilityTest, contact_Query_test_4200, testing::ext::TestSize.Level1)
2170 {
2171 HILOG_INFO("--- contact_Query_test_4200 is starting! ---");
2172 std::string tag("contact_Query_test_4200");
2173 OHOS::DataShare::DataShareValuesBucket valuesBucketGroup;
2174 int64_t groupId = GroupsInsert("dongshihui", valuesBucketGroup);
2175 EXPECT_GT(groupId, 0);
2176
2177 OHOS::DataShare::DataShareValuesBucket rawContactValuesBucket;
2178 int64_t rawContactId = RawContactInsert("licheng", rawContactValuesBucket);
2179 EXPECT_GT(rawContactId, 0);
2180 OHOS::DataShare::DataShareValuesBucket valuesBucketOne;
2181 int64_t contactDataId =
2182 ContactDataInsert(rawContactId, "group_membership", std::to_string(groupId), "", valuesBucketOne);
2183 EXPECT_GT(contactDataId, 0);
2184
2185 rawContactValuesBucket.Clear();
2186 rawContactId = RawContactInsert("xiaoyuan", rawContactValuesBucket);
2187 EXPECT_GT(rawContactId, 0);
2188 OHOS::DataShare::DataShareValuesBucket valuesBucketTwo;
2189 contactDataId = ContactDataInsert(rawContactId, "group_membership", std::to_string(groupId), "", valuesBucketTwo);
2190 EXPECT_GT(contactDataId, 0);
2191
2192 std::vector<std::string> columns;
2193 columns.push_back("detail_info");
2194 OHOS::DataShare::DataSharePredicates predicates;
2195 predicates.EqualTo("detail_info", std::to_string(groupId));
2196 predicates.And();
2197 // type_id 9 is group_membership
2198 predicates.EqualTo("type_id", "9");
2199 std::string contactData = ContactTabName::CONTACT_DATA;
2200 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(contactData, columns, predicates);
2201 int rowCount = -1;
2202 resultSet->GetRowCount(rowCount);
2203 EXPECT_EQ(2, rowCount);
2204 std::vector<OHOS::DataShare::DataShareValuesBucket> listValue;
2205 listValue.push_back(valuesBucketOne);
2206 listValue.push_back(valuesBucketTwo);
2207 CheckResultSetList(listValue, resultSet, "contact_Query_test_4200");
2208 ClearContacts();
2209 }
2210
2211 /*
2212 * @tc.number contact_Query_test_4300
2213 * @tc.name Query favorite contacts
2214 * @tc.desc Query the ability of favorite contacts
2215 * @tc.level Level1
2216 * @tc.size MediumTest
2217 * @tc.type Function
2218 */
HWTEST_F(ContactAbilityTest, contact_Query_test_4300, testing::ext::TestSize.Level1)2219 HWTEST_F(ContactAbilityTest, contact_Query_test_4300, testing::ext::TestSize.Level1)
2220 {
2221 HILOG_INFO("--- contact_Query_test_4300 is starting! ---");
2222 OHOS::DataShare::DataShareValuesBucket valuesBucket;
2223 valuesBucket.Put("display_name", "xiaoyuan");
2224 valuesBucket.Put("company", "tiantianxiangshang");
2225 valuesBucket.Put("position", "Test");
2226 valuesBucket.Put("favorite", 1);
2227 valuesBucket.Put("phonetic_name", "xiaoyuanxy");
2228
2229 int64_t rawContactId = RawContactInsertValues(valuesBucket);
2230 EXPECT_GT(rawContactId, 0);
2231
2232 std::vector<std::string> columns;
2233 columns.push_back("display_name");
2234 columns.push_back("company");
2235 columns.push_back("position");
2236 OHOS::DataShare::DataSharePredicates predicates;
2237 predicates.EqualTo("favorite", "1");
2238 predicates.And();
2239 predicates.EqualTo("is_deleted", "0");
2240 predicates.And();
2241 predicates.EqualTo("id", std::to_string(rawContactId));
2242
2243 std::string rawContacts = ContactTabName::RAW_CONTACT;
2244 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(rawContacts, columns, predicates);
2245
2246 int rowCount = -1;
2247 resultSet->GetRowCount(rowCount);
2248 EXPECT_EQ(1, rowCount);
2249 CheckResultSet(valuesBucket, resultSet, "contact_Query_test_4300");
2250 ClearContacts();
2251 }
2252
2253 /*
2254 * @tc.number contact_Query_test_4400
2255 * @tc.name Query recent contacts
2256 * @tc.desc Query recent contact ability
2257 * @tc.level Level1
2258 * @tc.size MediumTest
2259 * @tc.type Function
2260 */
HWTEST_F(ContactAbilityTest, contact_Query_test_4400, testing::ext::TestSize.Level1)2261 HWTEST_F(ContactAbilityTest, contact_Query_test_4400, testing::ext::TestSize.Level1)
2262 {
2263 HILOG_INFO("--- contact_Query_test_4400 is starting! ---");
2264 OHOS::DataShare::DataShareValuesBucket rawContactValuesBucket;
2265 int64_t rawContactId = RawContactLastContactedInsert("wangwu", 60, rawContactValuesBucket);
2266 EXPECT_GT(rawContactId, 0);
2267
2268 std::vector<std::string> columns;
2269 columns.push_back("id");
2270 columns.push_back("display_name");
2271 columns.push_back("lastest_contacted_time");
2272 OHOS::DataShare::DataSharePredicates predicates;
2273 predicates.EqualTo("lastest_contacted_time", "60");
2274 predicates.And();
2275 predicates.EqualTo("is_deleted", "0");
2276 std::string rawContacts = ContactTabName::RAW_CONTACT;
2277 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(rawContacts, columns, predicates);
2278
2279 int rowCount = -1;
2280 resultSet->GetRowCount(rowCount);
2281 EXPECT_EQ(1, rowCount);
2282 CheckResultSet(rawContactValuesBucket, resultSet, "contact_Query_test_4400");
2283 ClearContacts();
2284 }
2285
2286 /*
2287 * @tc.number contact_Query_test_4500
2288 * @tc.name Query the recently deleted contacts in the deleted contacts table
2289 * @tc.desc Ability to query recently deleted contacts
2290 * @tc.level Level1
2291 * @tc.size MediumTest
2292 * @tc.type Function
2293 */
HWTEST_F(ContactAbilityTest, contact_Query_test_4500, testing::ext::TestSize.Level1)2294 HWTEST_F(ContactAbilityTest, contact_Query_test_4500, testing::ext::TestSize.Level1)
2295 {
2296 HILOG_INFO("--- contact_Query_test_4500 is starting! ---");
2297 OHOS::DataShare::DataShareValuesBucket rawContactValues;
2298 int64_t rawContactId = RawContactInsert("xiaobai", rawContactValues);
2299 EXPECT_GT(rawContactId, 0);
2300
2301 OHOS::DataShare::DataSharePredicates predicates;
2302 predicates.EqualTo("id", std::to_string(rawContactId));
2303 std::string rawContacts = ContactTabName::RAW_CONTACT;
2304 int deleteCode = ContactDelete(rawContacts, predicates);
2305 EXPECT_EQ(deleteCode, 0);
2306
2307 sleep(SLEEP_TIME);
2308 std::vector<std::string> columns;
2309 columns.push_back("display_name");
2310 OHOS::DataShare::DataSharePredicates predicates2;
2311 predicates2.EqualTo("raw_contact_id", std::to_string(rawContactId));
2312 std::string deletedRawContact = ContactTabName::DELETED_RAW_CONTACT;
2313 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
2314 ContactQuery(deletedRawContact, columns, predicates2);
2315
2316 int rowCount = -1;
2317 resultSet->GetRowCount(rowCount);
2318 EXPECT_EQ(1, rowCount);
2319 CheckResultSet(rawContactValues, resultSet, "contact_Query_test_4500");
2320 ClearContacts();
2321 }
2322
2323 /*
2324 * @tc.number contact_Query_test_4600
2325 * @tc.name Query the mobile phone numbers of all contacts
2326 * @tc.desc Query the capabilities of all mobile phone numbers
2327 * @tc.level Level1
2328 * @tc.size MediumTest
2329 * @tc.type Function
2330 */
HWTEST_F(ContactAbilityTest, contact_Query_test_4600, testing::ext::TestSize.Level1)2331 HWTEST_F(ContactAbilityTest, contact_Query_test_4600, testing::ext::TestSize.Level1)
2332 {
2333 HILOG_INFO("--- contact_Query_test_4600 is starting! ---");
2334 std::string contactData = ContactTabName::CONTACT_DATA;
2335 OHOS::DataShare::DataSharePredicates predicates;
2336 predicates.GreaterThan("id", "0");
2337 int deleteCode = ContactDelete(contactData, predicates);
2338 EXPECT_EQ(deleteCode, 0);
2339
2340 OHOS::DataShare::DataShareValuesBucket rawContactValues;
2341 int64_t rawContactIdOne = RawContactInsert("dongming", rawContactValues);
2342 EXPECT_GT(rawContactIdOne, 0);
2343
2344 OHOS::DataShare::DataShareValuesBucket contactDataValues;
2345 int64_t contactDataId = ContactDataInsert(rawContactIdOne, "phone", "155825478", "", contactDataValues);
2346 EXPECT_GT(contactDataId, 0);
2347
2348 OHOS::DataShare::DataShareValuesBucket rawContactValuesTwo;
2349 int64_t rawContactIdTwo = RawContactInsert("xiaocai", rawContactValuesTwo);
2350 EXPECT_GT(rawContactIdTwo, 0);
2351
2352 OHOS::DataShare::DataShareValuesBucket contactDataValuesTwo;
2353 contactDataId = ContactDataInsert(rawContactIdTwo, "phone", "18853269857", "", contactDataValuesTwo);
2354 EXPECT_GT(contactDataId, 0);
2355
2356 std::vector<std::string> columns;
2357 columns.push_back("detail_info");
2358 OHOS::DataShare::DataSharePredicates predicates2;
2359 // type_id 5 is phone
2360 predicates2.EqualTo("type_id", "5");
2361 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(contactData, columns, predicates2);
2362 std::vector<OHOS::DataShare::DataShareValuesBucket> listValue;
2363 listValue.push_back(contactDataValues);
2364 listValue.push_back(contactDataValuesTwo);
2365 CheckResultSetList(listValue, resultSet, "contact_Query_test_4600");
2366 ClearContacts();
2367 }
2368
2369 /*
2370 * @tc.number contact_Query_test_4700
2371 * @tc.name Query mailbox of all contacts
2372 * @tc.desc Query all mailbox capabilities
2373 * @tc.level Level1
2374 * @tc.size MediumTest
2375 * @tc.type Function
2376 */
HWTEST_F(ContactAbilityTest, contact_Query_test_4700, testing::ext::TestSize.Level1)2377 HWTEST_F(ContactAbilityTest, contact_Query_test_4700, testing::ext::TestSize.Level1)
2378 {
2379 HILOG_INFO("--- contact_Query_test_4700 is starting! ---");
2380 std::string contactData = ContactTabName::CONTACT_DATA;
2381 OHOS::DataShare::DataSharePredicates predicates;
2382 predicates.GreaterThan("id", "0");
2383 int deleteCode = ContactDelete(contactData, predicates);
2384 EXPECT_EQ(deleteCode, 0);
2385
2386 OHOS::DataShare::DataShareValuesBucket rawContactValues;
2387 int64_t rawContactIdOne = RawContactInsert("dongming", rawContactValues);
2388 EXPECT_GT(rawContactIdOne, 0);
2389 rawContactValues.Clear();
2390
2391 int64_t rawContactIdTwo = RawContactInsert("xiaocai", rawContactValues);
2392 EXPECT_GT(rawContactIdTwo, 0);
2393
2394 OHOS::DataShare::DataShareValuesBucket contactValues;
2395 int64_t contactDataId = ContactDataInsert(rawContactIdOne, "email", "166@163.com", "", contactValues);
2396 EXPECT_GT(contactDataId, 0);
2397
2398 OHOS::DataShare::DataShareValuesBucket contactValuesTwo;
2399 contactDataId = ContactDataInsert(rawContactIdTwo, "email", "199@163.com", "", contactValuesTwo);
2400 EXPECT_GT(contactDataId, 0);
2401
2402 std::vector<std::string> columns;
2403 columns.push_back("detail_info");
2404 OHOS::DataShare::DataSharePredicates predicates2;
2405 // type_id 1 is email
2406 predicates2.EqualTo("type_id", "1");
2407 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(contactData, columns, predicates2);
2408 std::vector<OHOS::DataShare::DataShareValuesBucket> listValue;
2409 listValue.push_back(contactValues);
2410 listValue.push_back(contactValuesTwo);
2411 CheckResultSetList(listValue, resultSet, "contact_Query_test_4700");
2412 ClearContacts();
2413 }
2414
2415 /*
2416 * @tc.number contact_Query_test_4800
2417 * @tc.name Query information about a single contact
2418 * @tc.desc Ability to query data information of a single contact
2419 * @tc.level Level1
2420 * @tc.size MediumTest
2421 * @tc.type Function
2422 */
HWTEST_F(ContactAbilityTest, contact_Query_test_4800, testing::ext::TestSize.Level1)2423 HWTEST_F(ContactAbilityTest, contact_Query_test_4800, testing::ext::TestSize.Level1)
2424 {
2425 HILOG_INFO("--- contact_Query_test_4800 is starting! ---");
2426 std::string tag("contact_Query_test_4800");
2427
2428 OHOS::DataShare::DataShareValuesBucket rawContactValues;
2429 int64_t rawContactId = RawContactInsert("BossCai", rawContactValues);
2430 EXPECT_GT(rawContactId, 0);
2431
2432 OHOS::DataShare::DataShareValuesBucket contactValues;
2433 int64_t contactDataId = ContactDataInsert(rawContactId, "name", "BossCai", "", contactValues);
2434 EXPECT_GT(contactDataId, 0);
2435
2436 OHOS::DataShare::DataShareValuesBucket contactValuesTwo;
2437 contactDataId = ContactDataInsert(rawContactId, "organization", "happy500", "Test", contactValuesTwo);
2438 EXPECT_GT(contactDataId, 0);
2439
2440 std::vector<std::string> columns;
2441 columns.push_back("detail_info");
2442 columns.push_back("position");
2443 OHOS::DataShare::DataSharePredicates predicates;
2444 predicates.EqualTo("raw_contact_id", std::to_string(rawContactId));
2445 std::string contactData = ContactTabName::CONTACT_DATA;
2446 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(contactData, columns, predicates);
2447 std::vector<OHOS::DataShare::DataShareValuesBucket> listValue;
2448 listValue.push_back(contactValues);
2449 listValue.push_back(contactValuesTwo);
2450 CheckResultSetList(listValue, resultSet, "contact_Query_test_4800");
2451 ClearContacts();
2452 }
2453
2454 /*
2455 * @tc.number contact_Delete_test_4900
2456 * @tc.name Query the deleted contact according to the original contact ID
2457 * @tc.desc Ability to delete contact data from the basic raw data table and record basic raw data
2458 * @tc.level Level1
2459 * @tc.size MediumTest
2460 * @tc.type Function
2461 */
HWTEST_F(ContactAbilityTest, contact_Delete_test_4900, testing::ext::TestSize.Level1)2462 HWTEST_F(ContactAbilityTest, contact_Delete_test_4900, testing::ext::TestSize.Level1)
2463 {
2464 HILOG_INFO("--- contact_Delete_test_4900 is starting! ---");
2465 OHOS::DataShare::DataShareValuesBucket rawContactValues;
2466 int64_t rawContactId = RawContactInsert("xiaoli", rawContactValues);
2467 HILOG_INFO("rawContactId= %{public}ld", rawContactId);
2468 EXPECT_GT(rawContactId, 0);
2469
2470 OHOS::DataShare::DataSharePredicates predicates;
2471 predicates.EqualTo("id", std::to_string(rawContactId));
2472 std::string rawContacts = ContactTabName::RAW_CONTACT;
2473 int deleteCode = ContactDelete(rawContacts, predicates);
2474 EXPECT_EQ(deleteCode, 0);
2475
2476 sleep(SLEEP_TIME);
2477 std::vector<std::string> columns;
2478 columns.push_back("raw_contact_id");
2479 columns.push_back("display_name");
2480 std::string deletedRawContact = ContactTabName::DELETED_RAW_CONTACT;
2481 OHOS::DataShare::DataSharePredicates predicates2;
2482 predicates2.EqualTo("raw_contact_id", std::to_string(rawContactId));
2483 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
2484 ContactQuery(deletedRawContact, columns, predicates2);
2485
2486 int rowCount = -1;
2487 resultSet->GetRowCount(rowCount);
2488 EXPECT_EQ(1, rowCount);
2489 rawContactValues.Put("raw_contact_id", rawContactId);
2490 CheckResultSet(rawContactValues, resultSet, "contact_Delete_test_4900");
2491 ClearContacts();
2492 }
2493
2494 /*
2495 * @tc.number contact_Delete_test_5000
2496 * @tc.name Delete a single full field data in the raw_contact table
2497 * @tc.desc Raw contact deletion capability
2498 * @tc.level Level1
2499 * @tc.size MediumTest
2500 * @tc.type Function
2501 */
HWTEST_F(ContactAbilityTest, contact_Delete_test_5000, testing::ext::TestSize.Level1)2502 HWTEST_F(ContactAbilityTest, contact_Delete_test_5000, testing::ext::TestSize.Level1)
2503 {
2504 HILOG_INFO("-----contact_Delete_test_5000 is starting!-----");
2505 // insert
2506 std::vector<std::string> columnsInt;
2507 std::vector<std::string> columnsStr;
2508 GetAllRawContactColumns(columnsInt, columnsStr);
2509 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
2510 int rawId = RawContactInsertValues(valuesBucket);
2511 EXPECT_GT(rawId, 0);
2512
2513 // test end delete data
2514 OHOS::DataShare::DataSharePredicates predicates;
2515 predicates.EqualTo("id", std::to_string(rawId));
2516 EXPECT_GT(rawId, 0);
2517 std::string rawContacts = ContactTabName::RAW_CONTACT;
2518 int deleteCode = ContactDelete(rawContacts, predicates);
2519 EXPECT_EQ(deleteCode, 0);
2520 std::vector<std::string> columns;
2521 columns.push_back("is_deleted");
2522 OHOS::DataShare::DataShareValuesBucket valuesBucketDelete;
2523 valuesBucketDelete.Put("is_deleted", 1);
2524 QueryAndExpectResult(rawContacts, predicates, valuesBucketDelete, "contact_Delete_test_5000");
2525 ClearContacts();
2526 }
2527
2528 /*
2529 * @tc.number contact_Delete_test_5100
2530 * @tc.name Query the details of the newly deleted contact
2531 * @tc.desc Ability to delete contact data from the detailed data table and record detailed data
2532 * @tc.level Level1
2533 * @tc.size MediumTest
2534 * @tc.type Function
2535 */
HWTEST_F(ContactAbilityTest, contact_Delete_test_5100, testing::ext::TestSize.Level1)2536 HWTEST_F(ContactAbilityTest, contact_Delete_test_5100, testing::ext::TestSize.Level1)
2537 {
2538 HILOG_INFO("--- contact_Delete_test_5100 is starting! ---");
2539 OHOS::DataShare::DataShareValuesBucket rawContactValues;
2540 int64_t rawContactId = RawContactInsert("siyuan", rawContactValues);
2541 EXPECT_GT(rawContactId, 0);
2542
2543 OHOS::DataShare::DataShareValuesBucket contactValue;
2544 int64_t contactDataId = ContactDataInsert(rawContactId, "organization", "tiantianxaingshang", "Test", contactValue);
2545 EXPECT_GT(contactDataId, 0);
2546
2547 OHOS::DataShare::DataSharePredicates predicates;
2548 predicates.EqualTo("id", std::to_string(rawContactId));
2549 std::string rawContacts = ContactTabName::RAW_CONTACT;
2550 int deleteCode = ContactDelete(rawContacts, predicates);
2551 EXPECT_EQ(deleteCode, 0);
2552
2553 sleep(SLEEP_TIME);
2554 std::vector<std::string> columns;
2555 columns.push_back("raw_contact_id");
2556 columns.push_back("display_name");
2557 std::string deletedRawContact = ContactTabName::DELETED_RAW_CONTACT;
2558 OHOS::DataShare::DataSharePredicates predicates2;
2559 predicates2.EqualTo("raw_contact_id", std::to_string(rawContactId));
2560 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
2561 ContactQuery(deletedRawContact, columns, predicates2);
2562
2563 int rowCount = -1;
2564 resultSet->GetRowCount(rowCount);
2565 EXPECT_EQ(1, rowCount);
2566 rawContactValues.Put("raw_contact_id", rawContactId);
2567 CheckResultSet(rawContactValues, resultSet, "contact_Delete_test_5100");
2568 ClearContacts();
2569 }
2570
2571 /*
2572 * @tc.number contact_Delete_test_5200
2573 * @tc.name Delete a single full field data in the contact_data table
2574 * @tc.desc Deleted ability to contact_data
2575 * @tc.level Level1
2576 * @tc.size MediumTest
2577 * @tc.type Function
2578 */
HWTEST_F(ContactAbilityTest, contact_Delete_test_5200, testing::ext::TestSize.Level1)2579 HWTEST_F(ContactAbilityTest, contact_Delete_test_5200, testing::ext::TestSize.Level1)
2580 {
2581 HILOG_INFO("-----contact_Delete_test_5200 is starting!-----");
2582 std::vector<std::string> columnsInt;
2583 std::vector<std::string> columnsStr;
2584 std::vector<std::string> columns;
2585 std::string tableName = ContactTabName::CONTACT_DATA;
2586 GetAllContactDataColumns(columnsInt, columnsStr);
2587 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
2588 OHOS::DataShare::DataShareValuesBucket rawContactValues;
2589 int64_t rawContactId = RawContactInsert("feimaotui", rawContactValues);
2590 valuesBucket.Put("raw_contact_id", rawContactId);
2591 // type id 6 is name
2592 valuesBucket.Put("type_id", 6);
2593 int ContactDataId = ContactDataInsertValues(valuesBucket);
2594 EXPECT_GT(ContactDataId, 0);
2595
2596 OHOS::DataShare::DataSharePredicates predicates;
2597 predicates.EqualTo("raw_contact_id", std::to_string(rawContactId));
2598 int deleteCode = ContactDelete(tableName, predicates);
2599 EXPECT_EQ(deleteCode, 0);
2600
2601 MergeColumns(columns, columnsInt, columnsStr);
2602 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetDeleteQuery =
2603 ContactQuery(tableName, columns, predicates);
2604 // resultSet count 0
2605 int rowCount = -1;
2606 resultSetDeleteQuery->GetRowCount(rowCount);
2607 EXPECT_EQ(0, rowCount);
2608 ClearContacts();
2609 }
2610
2611 /*
2612 * @tc.number contact_Delete_test_5300
2613 * @tc.name Query deleted basic data
2614 * @tc.desc Ability to delete and record basic data of a single contact
2615 * @tc.level Level1
2616 * @tc.size MediumTest
2617 * @tc.type Function
2618 */
HWTEST_F(ContactAbilityTest, contact_Delete_test_5300, testing::ext::TestSize.Level1)2619 HWTEST_F(ContactAbilityTest, contact_Delete_test_5300, testing::ext::TestSize.Level1)
2620 {
2621 HILOG_INFO("--- contact_Delete_test_5300 is starting! ---");
2622 OHOS::DataShare::DataShareValuesBucket rawContactValues;
2623 int64_t rawContactId = RawContactInsert("xiaohong", rawContactValues);
2624 EXPECT_GT(rawContactId, 0);
2625
2626 OHOS::DataShare::DataSharePredicates predicates;
2627 predicates.EqualTo("name_raw_contact_id", std::to_string(rawContactId));
2628 std::string contact = ContactTabName::CONTACT;
2629 int deleteCode = ContactDelete(contact, predicates);
2630 EXPECT_EQ(deleteCode, 0);
2631
2632 sleep(SLEEP_TIME);
2633 std::vector<std::string> columns;
2634 columns.push_back("raw_contact_id");
2635 columns.push_back("display_name");
2636 OHOS::DataShare::DataSharePredicates predicates2;
2637 predicates2.EqualTo("raw_contact_id", std::to_string(rawContactId));
2638 std::string deletedRawContact = ContactTabName::DELETED_RAW_CONTACT;
2639 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
2640 ContactQuery(deletedRawContact, columns, predicates2);
2641
2642 int rowCount = -1;
2643 resultSet->GetRowCount(rowCount);
2644 EXPECT_EQ(1, rowCount);
2645 rawContactValues.Put("raw_contact_id", rawContactId);
2646 CheckResultSet(rawContactValues, resultSet, "contact_Delete_test_5300");
2647 ClearContacts();
2648 }
2649
2650 /*
2651 * @tc.number contact_BatchInsert_test_5400
2652 * @tc.name Add basic contact information in batch and verify whether the insertion is successful
2653 * @tc.desc Bulk increase capacity of address book
2654 * @tc.level Level1
2655 * @tc.size MediumTest
2656 * @tc.type Function
2657 */
HWTEST_F(ContactAbilityTest, contact_BatchInsert_test_5400, testing::ext::TestSize.Level1)2658 HWTEST_F(ContactAbilityTest, contact_BatchInsert_test_5400, testing::ext::TestSize.Level1)
2659 {
2660 HILOG_INFO("--- contact_BatchInsert_test_5400 is starting! ---");
2661 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
2662 OHOS::DataShare::DataShareValuesBucket rawContactValuesOne;
2663 rawContactValuesOne.Put("display_name", std::string("zhangming"));
2664 rawContactValuesOne.Put("company", std::string("tiantainxiangzuo4200000000"));
2665 rawContactValuesOne.Put("position", std::string("Test"));
2666
2667 OHOS::DataShare::DataShareValuesBucket rawContactValuesTwo;
2668 rawContactValuesTwo.Put("display_name", std::string("ligang"));
2669 rawContactValuesTwo.Put("company", std::string("tiantainxiangzuo4200000000"));
2670 rawContactValuesTwo.Put("position", std::string("Developer"));
2671
2672 OHOS::DataShare::DataShareValuesBucket rawContactValuesThree;
2673 rawContactValuesThree.Put("display_name", std::string("wanghong"));
2674 rawContactValuesThree.Put("company", std::string("tiantainxiangzuo4200000000"));
2675 rawContactValuesThree.Put("position", std::string("manage"));
2676
2677 std::vector<OHOS::DataShare::DataShareValuesBucket> listAddBluk;
2678 listAddBluk.push_back(rawContactValuesOne);
2679 listAddBluk.push_back(rawContactValuesTwo);
2680 listAddBluk.push_back(rawContactValuesThree);
2681
2682 int batchInserCode = contactsDataAbility.BatchInsert(uriRawContact, listAddBluk);
2683 EXPECT_EQ(batchInserCode, 0);
2684
2685 std::string rawContacts = ContactTabName::RAW_CONTACT;
2686 OHOS::DataShare::DataSharePredicates predicates;
2687 predicates.EqualTo("company", "tiantainxiangzuo4200000000");
2688 predicates.And();
2689 predicates.EqualTo("is_deleted", "0");
2690 predicates.OrderByAsc("id");
2691 std::vector<std::string> columns;
2692 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(rawContacts, columns, predicates);
2693 int rowCount = 0;
2694 int queryCount = 3;
2695 resultSet->GetRowCount(rowCount);
2696 EXPECT_EQ(queryCount, rowCount);
2697 CheckResultSetList(listAddBluk, resultSet, "contact_BatchInsert_test_5400");
2698 ClearContacts();
2699 }
2700
2701 /*
2702 * @tc.number contact_BatchInsert_test_5500
2703 * @tc.name Batch add contact details and verify that the insertion was successful
2704 * @tc.desc Bulk increase capacity of address book
2705 * @tc.level Level1
2706 * @tc.size MediumTest
2707 * @tc.type Function
2708 */
HWTEST_F(ContactAbilityTest, contact_BatchInsert_test_5500, testing::ext::TestSize.Level1)2709 HWTEST_F(ContactAbilityTest, contact_BatchInsert_test_5500, testing::ext::TestSize.Level1)
2710 {
2711 HILOG_INFO("--- contact_BatchInsert_test_5500 is starting! ---");
2712
2713 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
2714 OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA);
2715 OHOS::DataShare::DataShareValuesBucket rawContactValues;
2716 rawContactValues.Put("display_name", "zhangming");
2717 int64_t rawContactId = contactsDataAbility.Insert(uriRawContact, rawContactValues);
2718 EXPECT_GT(rawContactId, 0);
2719
2720 std::vector<OHOS::DataShare::DataShareValuesBucket> listAddBluk = GetBatchList(rawContactId);
2721 int batchInserCode = contactsDataAbility.BatchInsert(uriContactData, listAddBluk);
2722 EXPECT_EQ(batchInserCode, 0);
2723
2724 std::string contactData = ContactTabName::CONTACT_DATA;
2725 OHOS::DataShare::DataSharePredicates predicates;
2726 // type_id 1 is email
2727 predicates.EqualTo("type_id", "1");
2728 predicates.And();
2729 predicates.EqualTo("raw_contact_id", std::to_string(rawContactId));
2730 std::vector<std::string> columns;
2731 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(contactData, columns, predicates);
2732 int rowCount = 0;
2733 resultSet->GetRowCount(rowCount);
2734 EXPECT_EQ(1, rowCount);
2735 int indexTwo = 2;
2736 CheckResultSet(listAddBluk[indexTwo], resultSet, "contact_BatchInsert_test_5500");
2737 OHOS::DataShare::DataSharePredicates predicates2;
2738 // type 5 is phone
2739 predicates2.EqualTo("type_id", "5");
2740 predicates2.And();
2741 predicates2.EqualTo("raw_contact_id", std::to_string(rawContactId));
2742 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetFour =
2743 ContactQuery(contactData, columns, predicates2);
2744 int rowCountFour = 0;
2745 resultSetFour->GetRowCount(rowCountFour);
2746 EXPECT_EQ(1, rowCountFour);
2747 int indexThree = 3;
2748 CheckResultSet(listAddBluk[indexThree], resultSetFour, "contact_BatchInsert_test_5500");
2749 ClearContacts();
2750 }
2751
GetBatchList(int64_t rawContactId)2752 std::vector<OHOS::DataShare::DataShareValuesBucket> ContactAbilityTest::GetBatchList(int64_t rawContactId)
2753 {
2754 OHOS::DataShare::DataShareValuesBucket contactDataValuesOne;
2755 contactDataValuesOne.Put("raw_contact_id", rawContactId);
2756 contactDataValuesOne.Put("content_type", "name");
2757 contactDataValuesOne.Put("detail_info", "zhangming");
2758 OHOS::DataShare::DataShareValuesBucket contactDataValuesTwo;
2759 contactDataValuesTwo.Put("raw_contact_id", rawContactId);
2760 contactDataValuesTwo.Put("content_type", "organization");
2761 contactDataValuesTwo.Put("detail_info", "tiantianxaingshang");
2762 contactDataValuesTwo.Put("position", "Test");
2763 OHOS::DataShare::DataShareValuesBucket contactDataValuesThree;
2764 contactDataValuesThree.Put("raw_contact_id", rawContactId);
2765 contactDataValuesThree.Put("content_type", "email");
2766 contactDataValuesThree.Put("detail_info", "199632@163.com");
2767 OHOS::DataShare::DataShareValuesBucket contactDataValuesFour;
2768 contactDataValuesFour.Put("raw_contact_id", rawContactId);
2769 contactDataValuesFour.Put("content_type", "phone");
2770 contactDataValuesFour.Put("detail_info", "1234567898");
2771 std::vector<OHOS::DataShare::DataShareValuesBucket> listAddBluk;
2772 listAddBluk.push_back(contactDataValuesOne);
2773 listAddBluk.push_back(contactDataValuesTwo);
2774 listAddBluk.push_back(contactDataValuesThree);
2775 listAddBluk.push_back(contactDataValuesFour);
2776 return listAddBluk;
2777 }
2778
2779 /*
2780 * @tc.number contact_Delete_test_5600
2781 * @tc.name Delete contacts in batch and verify whether the deletion is successful
2782 * @tc.desc delete ability to call records in batches
2783 * @tc.level Level1
2784 * @tc.size MediumTest
2785 * @tc.type Function
2786 */
HWTEST_F(ContactAbilityTest, contact_Delete_test_5600, testing::ext::TestSize.Level1)2787 HWTEST_F(ContactAbilityTest, contact_Delete_test_5600, testing::ext::TestSize.Level1)
2788 {
2789 HILOG_INFO("--- contact_Delete_test_5600 is starting!---");
2790 int time = 10000;
2791 std::chrono::milliseconds dura(time);
2792 std::this_thread::sleep_for(dura);
2793 OHOS::DataShare::DataShareValuesBucket rawValuesBucket;
2794 int64_t rawContactIdOne = RawContactInsert("update_detail_contactdata", rawValuesBucket);
2795 EXPECT_GT(rawContactIdOne, 0);
2796 int64_t rawContactIdTwo = RawContactInsert("update_contactdata", rawValuesBucket);
2797 EXPECT_GT(rawContactIdTwo, 0);
2798
2799 OHOS::DataShare::DataSharePredicates predicates;
2800 predicates.GreaterThan("id", "0");
2801 std::shared_ptr<OHOS::DataShare::DataSharePredicates> executePredicates =
2802 std::make_shared<OHOS::DataShare::DataSharePredicates>(predicates);
2803 std::shared_ptr<Uri> uri = std::make_shared<Uri>(ContactsUri::RAW_CONTACT);
2804 std::shared_ptr<OHOS::DataShare::DataShareOperation> operation =
2805 OHOS::DataShare::DataShareOperation::NewDeleteBuilder(uri)
2806 ->WithPredicatesBackReference(0, 0)
2807 ->WithPredicates(executePredicates)
2808 ->WithInterruptionAllowed(true)
2809 ->Build();
2810 std::vector<std::shared_ptr<OHOS::DataShare::DataShareOperation>> executeBatchOperations;
2811 executeBatchOperations.push_back(operation);
2812 InitAbility();
2813 std::vector<std::shared_ptr<OHOS::DataShare::DataShareResult>> dataShareResult =
2814 contactsDataAbility.ExecuteBatch(executeBatchOperations);
2815 EXPECT_EQ(0, dataShareResult[0]->GetCount());
2816 std::string tableName = ContactTabName::CONTACT_DATA;
2817 std::vector<std::string> columnQuery;
2818 columnQuery.push_back("detail_info");
2819 predicates.EqualTo("is_deleted", "0");
2820 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(tableName, columnQuery, predicates);
2821 int rowCount = 0;
2822 resultSet->GetRowCount(rowCount);
2823 EXPECT_EQ(0, rowCount);
2824 ClearContacts();
2825 }
2826
2827 /*
2828 * @tc.number contact_Update_test_5700
2829 * @tc.name Batch favorite / cancel favorite contacts
2830 * @tc.desc Batch collection and uncollection capabilities
2831 * @tc.level Level1
2832 * @tc.size MediumTest
2833 * @tc.type Function
2834 */
HWTEST_F(ContactAbilityTest, contact_Update_test_5700, testing::ext::TestSize.Level1)2835 HWTEST_F(ContactAbilityTest, contact_Update_test_5700, testing::ext::TestSize.Level1)
2836 {
2837 HILOG_INFO("--- contact_Update_test_5700 is starting! ---");
2838
2839 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
2840 OHOS::DataShare::DataShareValuesBucket rawContactValuesOne;
2841 rawContactValuesOne.Put("display_name", "zhangmingming");
2842 rawContactValuesOne.Put("favorite", 1);
2843 OHOS::DataShare::DataShareValuesBucket rawContactValuesTwo;
2844 rawContactValuesTwo.Put("display_name", "yuanmoumou");
2845 rawContactValuesTwo.Put("favorite", 1);
2846 OHOS::DataShare::DataShareValuesBucket rawContactValuesThree;
2847 rawContactValuesThree.Put("display_name", "xiaofenren");
2848 rawContactValuesThree.Put("favorite", 1);
2849
2850 std::vector<OHOS::DataShare::DataShareValuesBucket> listAddBluk;
2851 listAddBluk.push_back(rawContactValuesOne);
2852 listAddBluk.push_back(rawContactValuesTwo);
2853 listAddBluk.push_back(rawContactValuesThree);
2854 int batchInserCode = contactsDataAbility.BatchInsert(uriRawContact, listAddBluk);
2855 HILOG_INFO("contact_Update_test_5700 : batchInserCode = %{public}d", batchInserCode);
2856 EXPECT_EQ(batchInserCode, 0);
2857 OHOS::DataShare::DataShareValuesBucket updateValues;
2858 updateValues.Put("favorite", 0);
2859 OHOS::DataShare::DataSharePredicates predicates;
2860 predicates.EqualTo("display_name", "zhangmingming");
2861 predicates.Or();
2862 predicates.EqualTo("display_name", "yuanmoumou");
2863 std::string rawContacts = ContactTabName::RAW_CONTACT;
2864 int updateCode = ContactUpdate(rawContacts, updateValues, predicates);
2865 HILOG_INFO("contact_Update_test_5700: updateCode = %{public}d", updateCode);
2866 EXPECT_EQ(updateCode, 0);
2867
2868 OHOS::DataShare::DataSharePredicates predicates2;
2869 predicates2.EqualTo("display_name", "zhangmingming");
2870 QueryAndExpectResult(rawContacts, predicates2, updateValues, "contact_Update_test_5700");
2871
2872 OHOS::DataShare::DataSharePredicates predicates3;
2873 predicates3.EqualTo("display_name", "xiaofenren");
2874 QueryAndExpectResult(rawContacts, predicates3, rawContactValuesThree, "contact_Update_test_5700");
2875 ClearContacts();
2876 }
2877
2878 /*
2879 * @tc.number contact_Update_test_5800
2880 * @tc.name Update the contact in batch and verify whether the modification is successful
2881 * @tc.desc update ability to call records in batches
2882 * @tc.level Level1
2883 * @tc.size MediumTest
2884 * @tc.type Function
2885 */
HWTEST_F(ContactAbilityTest, contact_Update_test_5800, testing::ext::TestSize.Level1)2886 HWTEST_F(ContactAbilityTest, contact_Update_test_5800, testing::ext::TestSize.Level1)
2887 {
2888 HILOG_INFO("--- contact_Update_test_5800 is starting!---");
2889 OHOS::DataShare::DataShareValuesBucket rawValuesBucket;
2890 int64_t rawContactIdOne = RawContactInsert("update_detail_contactdata", rawValuesBucket);
2891 EXPECT_GT(rawContactIdOne, 0);
2892 int64_t rawContactIdTwo = RawContactInsert("update_contactdata", rawValuesBucket);
2893 EXPECT_GT(rawContactIdTwo, 0);
2894
2895 OHOS::DataShare::DataSharePredicates predicates;
2896 predicates.EqualTo("id", std::to_string(rawContactIdOne));
2897 predicates.Or();
2898 predicates.EqualTo("id", std::to_string(rawContactIdTwo));
2899 std::shared_ptr<OHOS::DataShare::DataShareValuesBucket> values =
2900 std::make_shared<OHOS::DataShare::DataShareValuesBucket>(rawValuesBucket);
2901 std::shared_ptr<OHOS::DataShare::DataSharePredicates> executePredicates =
2902 std::make_shared<OHOS::DataShare::DataSharePredicates>(predicates);
2903 std::shared_ptr<Uri> uri = std::make_shared<Uri>(ContactsUri::RAW_CONTACT);
2904 std::shared_ptr<OHOS::DataShare::DataShareOperation> operation =
2905 OHOS::DataShare::DataShareOperation::NewUpdateBuilder(uri)
2906 ->WithValuesBucket(values)
2907 ->WithPredicatesBackReference(0, 0)
2908 ->WithPredicates(executePredicates)
2909 ->WithInterruptionAllowed(true)
2910 ->Build();
2911 std::vector<std::shared_ptr<OHOS::DataShare::DataShareOperation>> executeBatchOperations;
2912 executeBatchOperations.push_back(operation);
2913 InitAbility();
2914 std::vector<std::shared_ptr<OHOS::DataShare::DataShareResult>> dataShareResult =
2915 contactsDataAbility.ExecuteBatch(executeBatchOperations);
2916 EXPECT_EQ(0, dataShareResult[0]->GetCount());
2917 std::string tableName = ContactTabName::RAW_CONTACT;
2918 std::vector<std::string> columnQuery;
2919 columnQuery.push_back("display_name");
2920 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(tableName, columnQuery, predicates);
2921 int rowCount = 0;
2922 resultSet->GetRowCount(rowCount);
2923 EXPECT_EQ(2, rowCount);
2924 std::vector<OHOS::DataShare::DataShareValuesBucket> listValue;
2925 listValue.push_back(rawValuesBucket);
2926 listValue.push_back(rawValuesBucket);
2927 CheckResultSetList(listValue, resultSet, "contact_Update_test_5800");
2928 ClearContacts();
2929 }
2930
2931 /*
2932 * @tc.number contact_BatchInsertAndDelete_test_5900
2933 * @tc.name Batch add / delete contact blocklist
2934 * @tc.desc Ability to add and remove contacts from the blocklist in batches
2935 * @tc.level Level1
2936 * @tc.size MediumTest
2937 * @tc.type Function
2938 */
HWTEST_F(ContactAbilityTest, contact_BatchInsertAndDelete_test_5900, testing::ext::TestSize.Level1)2939 HWTEST_F(ContactAbilityTest, contact_BatchInsertAndDelete_test_5900, testing::ext::TestSize.Level1)
2940 {
2941 HILOG_INFO("--- contact_BatchInsertAndDelete_test_5900 is starting! ---");
2942 OHOS::Uri uriContactBlocklist(ContactsUri::BLOCKLIST);
2943 OHOS::DataShare::DataShareValuesBucket contactBlocklistValuesOne;
2944 OHOS::Contacts::RandomNumberUtils randomNumberUtils;
2945 std::string phoneNumber = randomNumberUtils.Generating(9);
2946 contactBlocklistValuesOne.Put("phone_number", phoneNumber);
2947 OHOS::DataShare::DataShareValuesBucket contactBlocklistValuesTwo;
2948 contactBlocklistValuesTwo.Put("phone_number", phoneNumber);
2949 OHOS::DataShare::DataShareValuesBucket contactBlocklistValuesThree;
2950 contactBlocklistValuesThree.Put("phone_number", phoneNumber);
2951
2952 std::vector<OHOS::DataShare::DataShareValuesBucket> listAddBluk;
2953 listAddBluk.push_back(contactBlocklistValuesOne);
2954 listAddBluk.push_back(contactBlocklistValuesTwo);
2955 listAddBluk.push_back(contactBlocklistValuesThree);
2956 int batchInsertCode = contactsDataAbility.BatchInsert(uriContactBlocklist, listAddBluk);
2957 EXPECT_EQ(batchInsertCode, 0);
2958
2959 OHOS::DataShare::DataSharePredicates predicates;
2960 predicates.EqualTo("phone_number", std::string(phoneNumber));
2961 predicates.Or();
2962 predicates.EqualTo("phone_number", std::string(phoneNumber));
2963 std::string contactBlocklist = ContactTabName::CONTACT_BLOCKLIST;
2964 int deleteCode = ContactDelete(contactBlocklist, predicates);
2965 EXPECT_EQ(deleteCode, 0);
2966 std::vector<std::string> columns;
2967 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
2968 ContactQuery(contactBlocklist, columns, predicates);
2969 int rowCount = 0;
2970 resultSet->GetRowCount(rowCount);
2971 EXPECT_EQ(0, rowCount);
2972 ClearContacts();
2973 }
2974
2975 /*
2976 * @tc.number contact_BatchInsertAndDelete_test_6000
2977 * @tc.name Batch add contacts to the group, and then delete contacts from the group
2978 * @tc.desc Ability to join or remove contacts from groups in bulk
2979 * @tc.level Level1
2980 * @tc.size MediumTest
2981 * @tc.type Function
2982 */
HWTEST_F(ContactAbilityTest, contact_BatchInsertAndDelete_test_6000, testing::ext::TestSize.Level1)2983 HWTEST_F(ContactAbilityTest, contact_BatchInsertAndDelete_test_6000, testing::ext::TestSize.Level1)
2984 {
2985 HILOG_INFO("--- contact_BatchInsertAndDelete_test_6000 is staring! ---");
2986 OHOS::DataShare::DataShareValuesBucket valuesGroup;
2987 int64_t groupIdOne = GroupsInsert("TestFourth", valuesGroup);
2988 EXPECT_GT(groupIdOne, 0);
2989
2990 valuesGroup.Clear();
2991 int64_t groupIdTwo = GroupsInsert("TestFifth", valuesGroup);
2992 EXPECT_GT(groupIdTwo, 0);
2993
2994 valuesGroup.Clear();
2995 OHOS::DataShare::DataShareValuesBucket rawContactValues;
2996 int64_t rawContactId = RawContactInsert("xiaocheng", rawContactValues);
2997 EXPECT_GT(rawContactId, 0);
2998
2999 OHOS::Uri uriContactData(ContactsUri::CONTACT_DATA);
3000 OHOS::DataShare::DataShareValuesBucket contactDataValuesOne;
3001 contactDataValuesOne.Put("raw_contact_id", rawContactId);
3002 contactDataValuesOne.Put("content_type", std::string("group_membership"));
3003 contactDataValuesOne.Put("detail_info", std::to_string(groupIdOne));
3004 OHOS::DataShare::DataShareValuesBucket contactDataValuesTwo;
3005 contactDataValuesTwo.Put("raw_contact_id", rawContactId);
3006 contactDataValuesTwo.Put("content_type", std::string("group_membership"));
3007 contactDataValuesTwo.Put("detail_info", std::to_string(groupIdTwo));
3008
3009 std::vector<OHOS::DataShare::DataShareValuesBucket> listAddBluk;
3010 listAddBluk.push_back(contactDataValuesOne);
3011 listAddBluk.push_back(contactDataValuesTwo);
3012 int batchInserCode = contactsDataAbility.BatchInsert(uriContactData, listAddBluk);
3013 EXPECT_EQ(batchInserCode, 0);
3014
3015 OHOS::DataShare::DataSharePredicates predicates;
3016 predicates.EqualTo("raw_contact_id", std::to_string(rawContactId));
3017 predicates.And();
3018 predicates.EqualTo("detail_info", std::to_string(groupIdOne));
3019 std::string contactData = ContactTabName::CONTACT_DATA;
3020 int deleteCode = ContactDelete(contactData, predicates);
3021 EXPECT_EQ(deleteCode, 0);
3022
3023 std::vector<std::string> columns;
3024 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(contactData, columns, predicates);
3025 int rowCount = 0;
3026 resultSet->GetRowCount(rowCount);
3027 EXPECT_EQ(0, rowCount);
3028 ClearContacts();
3029 }
3030
3031 /*
3032 * @tc.number abnormal_contact_Insert_test_6100
3033 * @tc.name When inserting a contact, pass in a non-existent field or table name
3034 * @tc.desc Exception use case
3035 * @tc.level Level1
3036 * @tc.size MediumTest
3037 * @tc.type Function
3038 */
HWTEST_F(ContactAbilityTest, abnormal_contact_Insert_test_6100, testing::ext::TestSize.Level1)3039 HWTEST_F(ContactAbilityTest, abnormal_contact_Insert_test_6100, testing::ext::TestSize.Level1)
3040 {
3041 HILOG_INFO("--- abnormal_contact_Insert_test_6100 is starting! ---");
3042
3043 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
3044 OHOS::Uri errorUri(ContactsUri::ERROR_URI);
3045
3046 OHOS::DataShare::DataShareValuesBucket rawContactValues;
3047 rawContactValues.Put("display_names", "liming");
3048 int64_t rawontactId = contactsDataAbility.Insert(uriRawContact, rawContactValues);
3049 HILOG_INFO("abnormal_contact_Insert_test_6100 : rawontactId = %{public}ld", rawontactId);
3050 EXPECT_EQ(rawontactId, -1);
3051
3052 rawContactValues.Clear();
3053 rawContactValues.Put("display_name", "liming");
3054 rawontactId = contactsDataAbility.Insert(errorUri, rawContactValues);
3055 EXPECT_EQ(rawontactId, -1);
3056 ClearContacts();
3057 }
3058
3059 /*
3060 * @tc.number abnormal_contact_Insert_test_6200
3061 * @tc.name Verification of required fields(type_id) in contact_data table
3062 * @tc.desc Added ability to contact_data
3063 * @tc.level Level1
3064 * @tc.size MediumTest
3065 * @tc.type Function
3066 */
HWTEST_F(ContactAbilityTest, abnormal_contact_Insert_test_6200, testing::ext::TestSize.Level1)3067 HWTEST_F(ContactAbilityTest, abnormal_contact_Insert_test_6200, testing::ext::TestSize.Level1)
3068 {
3069 HILOG_INFO("-----abnormal_contact_Insert_test_6200 is starting!-----");
3070 std::vector<std::string> columnsInt;
3071 std::vector<std::string> columnsStr;
3072 std::vector<std::string> columns;
3073 std::string contactData = ContactTabName::CONTACT_DATA;
3074 GetAllContactDataColumns(columnsInt, columnsStr);
3075 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
3076 OHOS::DataShare::DataShareValuesBucket rawValuesBucket;
3077 int64_t rawContactId = RawContactInsert("lock_type_id", rawValuesBucket);
3078 valuesBucket.Put("raw_contact_id", rawContactId);
3079 int ContactDataId = ContactDataInsertValues(valuesBucket);
3080 EXPECT_EQ(ContactDataId, -1);
3081
3082 MergeColumns(columns, columnsInt, columnsStr);
3083 OHOS::DataShare::DataSharePredicates predicates;
3084 predicates.EqualTo("raw_contact_id", std::to_string(rawContactId));
3085 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(contactData, columns, predicates);
3086
3087 // resultSet count 0
3088 int rowCount = -1;
3089 resultSet->GetRowCount(rowCount);
3090 EXPECT_EQ(0, rowCount);
3091 CheckResultSet(valuesBucket, resultSet, "abnormal_contact_Insert_test_6200");
3092 ClearContacts();
3093 }
3094
3095 /*
3096 * @tc.number abnormal_contact_Insert_test_6300
3097 * @tc.name Verification of required fields(raw_contact_id) in contact_data table
3098 * @tc.desc Added ability to contact_data
3099 * @tc.level Level1
3100 * @tc.size MediumTest
3101 *
3102 * @tc.type Function
3103 */
HWTEST_F(ContactAbilityTest, abnormal_contact_Insert_test_6300, testing::ext::TestSize.Level1)3104 HWTEST_F(ContactAbilityTest, abnormal_contact_Insert_test_6300, testing::ext::TestSize.Level1)
3105 {
3106 HILOG_INFO("-----abnormal_contact_Insert_test_6300 is starting!-----");
3107 std::vector<std::string> columnsInt;
3108 std::vector<std::string> columnsStr;
3109 std::vector<std::string> columns;
3110 std::string contactData = ContactTabName::CONTACT_DATA;
3111 GetAllContactDataColumns(columnsInt, columnsStr);
3112 OHOS::DataShare::DataShareValuesBucket valuesBucket = GetAllColumnsValues(columnsInt, columnsStr);
3113 OHOS::DataShare::DataShareValuesBucket rawValuesBucket;
3114 int64_t rawContactId = RawContactInsert("lock_raw_contact_id", rawValuesBucket);
3115 valuesBucket.Put("type_id", 6);
3116 int ContactDataId = ContactDataInsertValues(valuesBucket);
3117 EXPECT_EQ(ContactDataId, -1);
3118
3119 MergeColumns(columns, columnsInt, columnsStr);
3120 OHOS::DataShare::DataSharePredicates predicates;
3121 predicates.EqualTo("raw_contact_id", std::to_string(rawContactId));
3122 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(contactData, columns, predicates);
3123
3124 // resultSet count 0
3125 int rowCount = -1;
3126 resultSet->GetRowCount(rowCount);
3127 EXPECT_EQ(0, rowCount);
3128 CheckResultSet(valuesBucket, resultSet, "abnormal_contact_Insert_test_6300");
3129 ClearContacts();
3130 }
3131
3132 /*
3133 * @tc.number abnormal_contact_Update_test_6400
3134 * @tc.name When modifying, an incorrect field or table name or non-existent value is passed in
3135 * @tc.desc Exception use case
3136 * @tc.level Level1
3137 * @tc.size MediumTest
3138 * @tc.type Function
3139 */
HWTEST_F(ContactAbilityTest, abnormal_contact_Update_test_6400, testing::ext::TestSize.Level1)3140 HWTEST_F(ContactAbilityTest, abnormal_contact_Update_test_6400, testing::ext::TestSize.Level1)
3141 {
3142 HILOG_INFO("--- abnormal_contact_Update_test_6400 is starting! ---");
3143 OHOS::Uri errorUri(ContactsUri::ERROR_URI);
3144 OHOS::DataShare::DataShareValuesBucket rawContactValues;
3145 int64_t rawContactId = RawContactInsert("zhangming", rawContactValues);
3146 HILOG_INFO("abnormal_contact_Update_test_6400 : rawContactId = %{public}ld", rawContactId);
3147 EXPECT_GT(rawContactId, 0);
3148
3149 OHOS::DataShare::DataShareValuesBucket updateValues;
3150 updateValues.Put("display_names", "dongming");
3151 OHOS::DataShare::DataSharePredicates predicates;
3152 predicates.EqualTo("id", std::to_string(rawContactId));
3153 std::string rawContacts = ContactTabName::RAW_CONTACT;
3154 int updateCode = ContactUpdate(rawContacts, updateValues, predicates);
3155 HILOG_INFO("abnormal_contact_Update_test_6400: updateCode = %{public}d", updateCode);
3156 EXPECT_EQ(updateCode, -1);
3157 QueryAndExpectResult(rawContacts, predicates, rawContactValues, "abnormal_contact_Update_test_6400");
3158
3159 updateValues.Clear();
3160 updateValues.Put("display_name", "dongming");
3161 OHOS::DataShare::DataSharePredicates predicates2;
3162 predicates2.EqualTo("id", std::to_string(rawContactId));
3163 updateCode = contactsDataAbility.Update(errorUri, predicates2, updateValues);
3164 HILOG_INFO("abnormal_contact_Update_test_6400: updateCode = %{public}d", updateCode);
3165 EXPECT_EQ(updateCode, -1);
3166 QueryAndExpectResult(rawContacts, predicates2, rawContactValues, "abnormal_contact_Update_test_6400");
3167
3168 OHOS::DataShare::DataSharePredicates predicates3;
3169 predicates3.EqualTo("id", "100000");
3170 updateCode = ContactUpdate(rawContacts, updateValues, predicates3);
3171 HILOG_INFO("abnormal_contact_Update_test_6400: updateCode = %{public}d", updateCode);
3172 EXPECT_EQ(updateCode, 0);
3173 ClearContacts();
3174 }
3175
3176 /*
3177 * @tc.number abnormal_contact_Query_test_6500
3178 * @tc.name A wrong field was passed in when querying
3179 * @tc.desc Exception use case
3180 * @tc.level Level1
3181 * @tc.size MediumTest
3182 * @tc.type Function
3183 */
HWTEST_F(ContactAbilityTest, abnormal_contact_Query_test_6500, testing::ext::TestSize.Level1)3184 HWTEST_F(ContactAbilityTest, abnormal_contact_Query_test_6500, testing::ext::TestSize.Level1)
3185 {
3186 HILOG_INFO("--- abnormal_contact_Query_test_6500 is starting! ---");
3187 OHOS::DataShare::DataShareValuesBucket rawContactValues;
3188 int64_t rawContactId = RawContactInsert("dongming", rawContactValues);
3189 EXPECT_GT(rawContactId, 0);
3190
3191 std::vector<std::string> columns;
3192 columns.push_back("display_names");
3193 OHOS::DataShare::DataSharePredicates predicates;
3194 predicates.EqualTo("id", std::to_string(rawContactId));
3195 std::string rawContacts = ContactTabName::RAW_CONTACT;
3196 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = ContactQuery(rawContacts, columns, predicates);
3197
3198 int rowCount = -2;
3199 resultSet->GetRowCount(rowCount);
3200 EXPECT_EQ(-1, rowCount);
3201 ClearContacts();
3202 }
3203
3204 /*
3205 * @tc.number abnormal_contact_Query_test_6600
3206 * @tc.name Pass in a non-existent table name when querying
3207 * @tc.desc Exception use case
3208 * @tc.level Level1
3209 * @tc.size MediumTest
3210 * @tc.type Function
3211 */
HWTEST_F(ContactAbilityTest, abnormal_contact_Query_test_6600, testing::ext::TestSize.Level1)3212 HWTEST_F(ContactAbilityTest, abnormal_contact_Query_test_6600, testing::ext::TestSize.Level1)
3213 {
3214 HILOG_INFO("--- abnormal_contact_Query_test_6600 is starting! ---");
3215 std::string tag("abnormal_contact_Query_test_6600");
3216
3217 OHOS::Uri errorUri(ContactsUri::ERROR_URI);
3218
3219 std::vector<std::string> columns;
3220 columns.push_back("id");
3221 columns.push_back("display_name");
3222 OHOS::DataShare::DataSharePredicates predicates;
3223 predicates.GreaterThan("id", "0");
3224 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
3225 contactsDataAbility.Query(errorUri, predicates, columns);
3226 EXPECT_EQ(resultSet, nullptr);
3227 ClearContacts();
3228 }
3229
3230 /*
3231 * @tc.number abnormal_contact_Delete_test_6700
3232 * @tc.name When deleting, pass in an incorrect field or table name or a non-existent value
3233 * @tc.desc Exception use case
3234 * @tc.level Level1
3235 * @tc.size MediumTest
3236 * @tc.type Function
3237 */
HWTEST_F(ContactAbilityTest, abnormal_contact_Delete_test_6700, testing::ext::TestSize.Level1)3238 HWTEST_F(ContactAbilityTest, abnormal_contact_Delete_test_6700, testing::ext::TestSize.Level1)
3239 {
3240 HILOG_INFO("-------abnormal_contact_Delete_test_6700 is starting!-------");
3241 OHOS::Uri errorUri(ContactsUri::ERROR_URI);
3242 OHOS::DataShare::DataShareValuesBucket values;
3243 int64_t rawContactId = RawContactInsert("zhangming", values);
3244 EXPECT_GT(rawContactId, 0);
3245
3246 OHOS::DataShare::DataSharePredicates predicates;
3247 predicates.EqualTo("ids", std::to_string(rawContactId));
3248 std::string rawContacts = ContactTabName::RAW_CONTACT;
3249 int deleteCode = ContactDelete(rawContacts, predicates);
3250 EXPECT_EQ(deleteCode, -1);
3251
3252 OHOS::DataShare::DataSharePredicates predicatesQuery;
3253 predicatesQuery.EqualTo("id", std::to_string(rawContactId));
3254 std::vector<std::string> columns;
3255 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
3256 ContactQuery(rawContacts, columns, predicatesQuery);
3257 int rowCount = 0;
3258 resultSet->GetRowCount(rowCount);
3259 EXPECT_EQ(1, rowCount);
3260 resultSet->Close();
3261
3262 OHOS::DataShare::DataSharePredicates predicates2;
3263 predicates2.EqualTo("id", std::to_string(rawContactId));
3264 deleteCode = contactsDataAbility.Delete(errorUri, predicates2);
3265 EXPECT_EQ(deleteCode, -1);
3266 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetUri =
3267 ContactQuery(rawContacts, columns, predicatesQuery);
3268 int rowCountUri = 0;
3269 resultSetUri->GetRowCount(rowCountUri);
3270 EXPECT_EQ(1, rowCountUri);
3271 resultSetUri->Close();
3272
3273 OHOS::DataShare::DataSharePredicates predicates3;
3274 predicates3.EqualTo("id", "10000000");
3275 deleteCode = ContactDelete(rawContacts, predicates3);
3276 EXPECT_EQ(deleteCode, -1);
3277
3278 OHOS::DataShare::DataSharePredicates predicates4;
3279 predicates4.EqualTo("id", std::to_string(rawContactId));
3280 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetId =
3281 ContactQuery(rawContacts, columns, predicatesQuery);
3282 int rowCountId = 0;
3283 resultSetId->GetRowCount(rowCountId);
3284 EXPECT_EQ(1, rowCountId);
3285 resultSetId->Close();
3286 ClearContacts();
3287 }
3288
3289 /*
3290 * @tc.number abnormal_contact_BatchInsert_test_6800
3291 * @tc.name When adding contacts in batches, some of them failed, check the processing logic
3292 * @tc.desc Exception use case
3293 * @tc.level Level1
3294 * @tc.size MediumTest
3295 * @tc.type Function
3296 */
HWTEST_F(ContactAbilityTest, abnormal_contact_BatchInsert_test_6800, testing::ext::TestSize.Level1)3297 HWTEST_F(ContactAbilityTest, abnormal_contact_BatchInsert_test_6800, testing::ext::TestSize.Level1)
3298 {
3299 HILOG_INFO("--- abnormal_contact_BatchInsert_test_6800 is starting! ---");
3300 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
3301 OHOS::DataShare::DataShareValuesBucket rawContactValues;
3302 std::vector<OHOS::DataShare::DataShareValuesBucket> listAddBluk;
3303 int batchInserCode = 0;
3304 for (int i = 0; i < 10; i++) {
3305 listAddBluk.clear();
3306 for (int j = 10 * i + 1; j <= 10 * (i + 1); j++) {
3307 rawContactValues.Clear();
3308 std::string name("zhangming");
3309 name.append(std::to_string(j));
3310 if (j == 14 || j == 27 || j == 57) {
3311 rawContactValues.Put("display_names", name);
3312 } else {
3313 rawContactValues.Put("display_name", name);
3314 }
3315 listAddBluk.push_back(rawContactValues);
3316 }
3317 batchInserCode = contactsDataAbility.BatchInsert(uriRawContact, listAddBluk);
3318 HILOG_INFO("abnormal_contact_BatchInsert_test_6800 : batchInserCode = %{public}d", batchInserCode);
3319 if (batchInserCode == 0) {
3320 HILOG_INFO("abnormal_contact_BatchInsert_test_6800 batch insert success!");
3321 } else {
3322 HILOG_INFO("abnormal_contact_BatchInsert_test_6800 batch insert fail!");
3323 EXPECT_EQ(batchInserCode, -1);
3324 }
3325 }
3326 OHOS::DataShare::DataSharePredicates predicates;
3327 predicates.NotEqualTo("id", "0");
3328 predicates.And();
3329 predicates.EqualTo("is_deleted", "0");
3330 contactsDataAbility.Delete(uriRawContact, predicates);
3331 int time = 20000;
3332 std::chrono::milliseconds dura(time);
3333 std::this_thread::sleep_for(dura);
3334 OHOS::DataShare::DataSharePredicates predicates2;
3335 OHOS::Uri uriRawContactComplete(ContactsUri::DELETED_RAW_CONTACT);
3336 predicates2.NotEqualTo("id", "0");
3337 contactsDataAbility.Delete(uriRawContactComplete, predicates2);
3338 }
3339
3340 /*
3341 * @tc.number abnormal_contact_BatchInsert_test_6900
3342 * @tc.name When adding contacts in batch, item 500 fails. Check the subsequent processing logic
3343 * @tc.desc Exception use case
3344 * @tc.level Level1
3345 * @tc.size MediumTest
3346 * @tc.type Function
3347 */
HWTEST_F(ContactAbilityTest, abnormal_contact_BatchInsert_test_6900, testing::ext::TestSize.Level1)3348 HWTEST_F(ContactAbilityTest, abnormal_contact_BatchInsert_test_6900, testing::ext::TestSize.Level1)
3349 {
3350 HILOG_INFO("--- abnormal_contact_BatchInsert_test_6900 is starting! ---");
3351 OHOS::Uri uriRawContact(ContactsUri::RAW_CONTACT);
3352 OHOS::DataShare::DataShareValuesBucket rawContactValues;
3353 std::vector<OHOS::DataShare::DataShareValuesBucket> listAddBluk;
3354 for (int i = 0; i < 1000; i++) {
3355 rawContactValues.Clear();
3356 std::string name("xiaoyuan");
3357 name.append(std::to_string(i));
3358 if (i == 500) {
3359 rawContactValues.Put("display_names", name);
3360 } else {
3361 rawContactValues.Put("display_name", name);
3362 }
3363 listAddBluk.push_back(rawContactValues);
3364 }
3365 int batchInserCode = contactsDataAbility.BatchInsert(uriRawContact, listAddBluk);
3366 HILOG_INFO("abnormal_contact_BatchInsert_test_6900 : batchInserCode = %{public}d", batchInserCode);
3367 if (batchInserCode == 0) {
3368 HILOG_INFO("abnormal_contact_BatchInsert_test_6900 batch insert success!");
3369 } else {
3370 HILOG_INFO("abnormal_contact_BatchInsert_test_6900 batch insert fail!");
3371 EXPECT_EQ(batchInserCode, -1);
3372 }
3373 OHOS::DataShare::DataSharePredicates predicates;
3374 predicates.NotEqualTo("id", "0");
3375 predicates.And();
3376 predicates.EqualTo("is_deleted", "0");
3377 contactsDataAbility.Delete(uriRawContact, predicates);
3378 int time = 20000;
3379 std::chrono::milliseconds dura(time);
3380 std::this_thread::sleep_for(dura);
3381 OHOS::DataShare::DataSharePredicates predicates2;
3382 OHOS::Uri uriRawContactComplete(ContactsUri::DELETED_RAW_CONTACT);
3383 predicates2.NotEqualTo("id", "0");
3384 contactsDataAbility.Delete(uriRawContactComplete, predicates2);
3385 }
3386
3387 /*
3388 * @tc.number contact_async_insert_test_7000
3389 * @tc.name Add contacts async
3390 * @tc.desc Ability to join or add contacts
3391 * @tc.level Level1
3392 * @tc.size MediumTest
3393 * @tc.type Function
3394 */
HWTEST_F(ContactAbilityTest, contact_async_insert_test_7000, testing::ext::TestSize.Level1)3395 HWTEST_F(ContactAbilityTest, contact_async_insert_test_7000, testing::ext::TestSize.Level1)
3396 {
3397 HILOG_INFO("--- contact_async_insert_test_7000 is staring! ---");
3398 std::map<int, OHOS::DataShare::DataShareValuesBucket> result;
3399 std::vector<ContactAsync *> contactAsyncVector;
3400 int threadNum = 6;
3401 for (int i = 0; i < threadNum; ++i) {
3402 OHOS::DataShare::DataShareValuesBucket values;
3403 std::string name;
3404 name.append("asyncTest");
3405 name.append(std::to_string(i));
3406 values.Put("display_name", name);
3407 ContactAsync *contactAsync = new ContactAsync(values, result);
3408 std::thread asyncThread(&ContactAsync::Insert, contactAsync);
3409 contactAsyncVector.push_back(contactAsync);
3410 asyncThread.detach();
3411 }
3412 std::chrono::milliseconds dura(Time::ASYNC_SLEEP_TIME);
3413 std::this_thread::sleep_for(dura);
3414 std::vector<std::string> columns;
3415 columns.push_back("display_name");
3416 std::map<int, OHOS::DataShare::DataShareValuesBucket>::iterator it;
3417 for (it = result.begin(); it != result.end(); it++) {
3418 OHOS::DataShare::DataSharePredicates predicates;
3419 predicates.EqualTo("id", std::to_string(it->first));
3420 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
3421 ContactQuery(ContactTabName::RAW_CONTACT, columns, predicates);
3422 CheckResultSet(it->second, resultSet, "contact_async_insert_test_7000");
3423 }
3424 for (int i = 0; i < threadNum; ++i) {
3425 delete contactAsyncVector[i];
3426 }
3427 ClearContacts();
3428 }
3429
3430 /*
3431 * @tc.number contact_async_update_test_7100
3432 * @tc.name update contacts async
3433 * @tc.desc Ability to join or update contacts
3434 * @tc.level Level1
3435 * @tc.size MediumTest
3436 * @tc.type Function
3437 */
HWTEST_F(ContactAbilityTest, contact_async_update_test_7100, testing::ext::TestSize.Level1)3438 HWTEST_F(ContactAbilityTest, contact_async_update_test_7100, testing::ext::TestSize.Level1)
3439 {
3440 HILOG_INFO("--- contact_async_update_test_7100 is staring! ---");
3441 OHOS::DataShare::DataShareValuesBucket rawValuesBucket;
3442 std::vector<int64_t> rawContactId;
3443 rawContactId.push_back(RawContactInsert("async_update1", rawValuesBucket));
3444 rawValuesBucket.Clear();
3445 rawContactId.push_back(RawContactInsert("async_update2", rawValuesBucket));
3446 rawValuesBucket.Clear();
3447 rawContactId.push_back(RawContactInsert("async_update3", rawValuesBucket));
3448 rawValuesBucket.Clear();
3449 rawContactId.push_back(RawContactInsert("async_update4", rawValuesBucket));
3450 rawValuesBucket.Clear();
3451 rawContactId.push_back(RawContactInsert("async_update5", rawValuesBucket));
3452 rawValuesBucket.Clear();
3453 rawContactId.push_back(RawContactInsert("async_update6", rawValuesBucket));
3454 rawValuesBucket.Clear();
3455 std::vector<OHOS::DataShare::DataShareValuesBucket> upDateValues;
3456 OHOS::DataShare::DataSharePredicates queryPredicates;
3457 std::vector<ContactAsync *> contactAsyncVector;
3458 int size = rawContactId.size();
3459 for (int i = 0; i < size; ++i) {
3460 OHOS::DataShare::DataShareValuesBucket values;
3461 std::string name;
3462 name.append("asyncTest");
3463 values.Put("display_name", name);
3464 upDateValues.push_back(values);
3465 int id = rawContactId[i];
3466 ContactAsync *contactAsync = new ContactAsync(values, id);
3467 contactAsyncVector.push_back(contactAsync);
3468 std::thread asyncThread(&ContactAsync::Update, contactAsync);
3469 asyncThread.detach();
3470 queryPredicates.EqualTo("id", std::to_string(rawContactId[i]));
3471 if (i < size - 1) {
3472 queryPredicates.Or();
3473 }
3474 }
3475 std::chrono::milliseconds dura(Time::ASYNC_SLEEP_TIME);
3476 std::this_thread::sleep_for(dura);
3477 std::vector<std::string> columns;
3478 columns.push_back("display_name");
3479 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
3480 ContactQuery(ContactTabName::RAW_CONTACT, columns, queryPredicates);
3481 CheckResultSetList(upDateValues, resultSet, "contact_async_update_test_7100");
3482 for (int i = 0; i < size; ++i) {
3483 delete contactAsyncVector[i];
3484 }
3485 ClearContacts();
3486 }
3487
3488 /*
3489 * @tc.number contact_async_query_test_7200
3490 * @tc.name query contacts async
3491 * @tc.desc Ability to join or query
3492 * @tc.level Level1
3493 * @tc.size MediumTest
3494 * @tc.type Function
3495 */
HWTEST_F(ContactAbilityTest, contact_async_query_test_7200, testing::ext::TestSize.Level1)3496 HWTEST_F(ContactAbilityTest, contact_async_query_test_7200, testing::ext::TestSize.Level1)
3497 {
3498 HILOG_INFO("--- contact_async_query_test_7200 is staring! ---");
3499 OHOS::DataShare::DataShareValuesBucket rawValuesBucket;
3500 std::vector<int64_t> rawContactId;
3501 rawContactId.push_back(RawContactInsert("async_query1", rawValuesBucket));
3502 rawValuesBucket.Clear();
3503 rawContactId.push_back(RawContactInsert("async_query2", rawValuesBucket));
3504 rawValuesBucket.Clear();
3505 rawContactId.push_back(RawContactInsert("async_query3", rawValuesBucket));
3506 rawValuesBucket.Clear();
3507 rawContactId.push_back(RawContactInsert("async_query4", rawValuesBucket));
3508 rawValuesBucket.Clear();
3509 rawContactId.push_back(RawContactInsert("async_query5", rawValuesBucket));
3510 rawValuesBucket.Clear();
3511 rawContactId.push_back(RawContactInsert("async_query6", rawValuesBucket));
3512 rawValuesBucket.Clear();
3513 std::vector<ContactAsync *> contactAsyncVector;
3514 std::vector<std::shared_ptr<OHOS::DataShare::DataShareResultSet>> resultSetVector;
3515 int threadNum = 6;
3516 for (int i = 0; i < threadNum; ++i) {
3517 ContactAsync *contactAsync = new ContactAsync(resultSetVector, rawContactId);
3518 contactAsyncVector.push_back(contactAsync);
3519 std::thread asyncThread(&ContactAsync::Query, contactAsync);
3520 asyncThread.detach();
3521 }
3522 int queryCount = 6;
3523 int size = resultSetVector.size();
3524 for (int i = 0; i < size; ++i) {
3525 int rowCount = 0;
3526 resultSetVector[i]->GetRowCount(rowCount);
3527 EXPECT_EQ(queryCount, rowCount);
3528 resultSetVector[i]->Close();
3529 }
3530 for (int i = 0; i < size; ++i) {
3531 delete contactAsyncVector[i];
3532 }
3533 ClearContacts();
3534 }
3535
3536 /*
3537 * @tc.number contact_async_delete_test_7300
3538 * @tc.name delete contacts async
3539 * @tc.desc Ability to join or delete contacts
3540 * @tc.level Level1
3541 * @tc.size MediumTest
3542 * @tc.type Function
3543 */
HWTEST_F(ContactAbilityTest, contact_async_delete_test_7300, testing::ext::TestSize.Level1)3544 HWTEST_F(ContactAbilityTest, contact_async_delete_test_7300, testing::ext::TestSize.Level1)
3545 {
3546 HILOG_INFO("--- contact_async_delete_test_7300 is staring! ---");
3547 OHOS::DataShare::DataShareValuesBucket rawValuesBucket;
3548 std::vector<int64_t> rawContactId;
3549 rawContactId.push_back(RawContactInsert("async_update1", rawValuesBucket));
3550 rawValuesBucket.Clear();
3551 rawContactId.push_back(RawContactInsert("async_update2", rawValuesBucket));
3552 rawValuesBucket.Clear();
3553 rawContactId.push_back(RawContactInsert("async_update3", rawValuesBucket));
3554 rawValuesBucket.Clear();
3555 rawContactId.push_back(RawContactInsert("async_update4", rawValuesBucket));
3556 rawValuesBucket.Clear();
3557 rawContactId.push_back(RawContactInsert("async_update5", rawValuesBucket));
3558 rawValuesBucket.Clear();
3559 rawContactId.push_back(RawContactInsert("async_update6", rawValuesBucket));
3560 rawValuesBucket.Clear();
3561 int size = rawContactId.size();
3562 OHOS::DataShare::DataSharePredicates predicates;
3563 predicates.BeginWrap();
3564 std::vector<ContactAsync *> contactAsyncVector;
3565 for (int i = 0; i < size; ++i) {
3566 int id = rawContactId[i];
3567 ContactAsync *contactAsync = new ContactAsync(id);
3568 contactAsyncVector.push_back(contactAsync);
3569 std::thread asyncThread(&ContactAsync::Delete, contactAsync);
3570 asyncThread.detach();
3571 predicates.EqualTo("id", std::to_string(id));
3572 if (i < size - 1) {
3573 predicates.Or();
3574 }
3575 }
3576 predicates.EndWrap();
3577 predicates.And();
3578 predicates.EqualTo("is_deleted", "0");
3579 std::chrono::milliseconds dura(Time::ASYNC_SLEEP_TIME);
3580 std::this_thread::sleep_for(dura);
3581 std::vector<std::string> columns;
3582 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
3583 ContactQuery(ContactTabName::RAW_CONTACT, columns, predicates);
3584 int rowCount = 0;
3585 resultSet->GetRowCount(rowCount);
3586 EXPECT_EQ(0, rowCount);
3587 resultSet->Close();
3588 for (int i = 0; i < size; ++i) {
3589 delete contactAsyncVector[i];
3590 }
3591 ClearContacts();
3592 }
3593
3594 /*
3595 * @tc.number contact_Insert_test_7400
3596 * @tc.name Add the basic information of a single contact and verify text whether the insertion is successful
3597 * @tc.desc New capabilities for basic contact data
3598 * @tc.level Level1
3599 * @tc.size MediumTest
3600 * @tc.type Function
3601 */
HWTEST_F(ContactAbilityTest, contact_Insert_test_7400, testing::ext::TestSize.Level1)3602 HWTEST_F(ContactAbilityTest, contact_Insert_test_7400, testing::ext::TestSize.Level1)
3603 {
3604 HILOG_INFO("--- contact_Insert_test_7400 is starting! ---");
3605 OHOS::DataShare::DataShareValuesBucket values;
3606 int size = 20000;
3607 std::string name;
3608 for (int i = 0; i < size; ++i) {
3609 name.append("l");
3610 }
3611 int64_t rawContactId = RawContactInsert(name, values);
3612 HILOG_INFO("contact_Insert_test_7400 : rawContactId = %{public}ld", rawContactId);
3613 EXPECT_GT(rawContactId, 0);
3614 OHOS::DataShare::DataSharePredicates predicates;
3615 predicates.EqualTo("id", std::to_string(rawContactId));
3616 std::string rawContacts = ContactTabName::RAW_CONTACT;
3617 QueryAndExpectResult(rawContacts, predicates, values, "contact_Insert_test_7400");
3618 ClearContacts();
3619 }
3620
3621 /*
3622 * @tc.number contact_Delete_Recover_test_7500
3623 * @tc.name recover deleted basic data
3624 * @tc.desc Ability to recover record basic data of a single contact
3625 * @tc.level Level1
3626 * @tc.size MediumTest
3627 * @tc.type Function
3628 */
HWTEST_F(ContactAbilityTest, contact_Delete_Recover_test_7500, testing::ext::TestSize.Level1)3629 HWTEST_F(ContactAbilityTest, contact_Delete_Recover_test_7500, testing::ext::TestSize.Level1)
3630 {
3631 HILOG_INFO("--- contact_Delete_Recover_test_7500 is starting! ---");
3632 OHOS::DataShare::DataShareValuesBucket rawContactValues;
3633 int64_t rawContactId = RawContactInsert("xiaohongDelete", rawContactValues);
3634 EXPECT_GT(rawContactId, 0);
3635
3636 OHOS::DataShare::DataSharePredicates predicates;
3637 predicates.EqualTo("name_raw_contact_id", std::to_string(rawContactId));
3638 std::string contact = ContactTabName::CONTACT;
3639 int deleteCode = ContactDelete(contact, predicates);
3640 EXPECT_EQ(deleteCode, 0);
3641 int time = 2000;
3642 std::chrono::milliseconds dura(time);
3643 std::this_thread::sleep_for(dura);
3644
3645 OHOS::DataShare::DataShareValuesBucket updateValues;
3646 updateValues.Put("is_deleted", "0");
3647 std::string rawContacts = ContactTabName::RAW_CONTACT;
3648 OHOS::DataShare::DataSharePredicates predicatesUpdate;
3649 predicatesUpdate.EqualTo("id", std::to_string(rawContactId));
3650 int updateCode = ContactUpdate(rawContacts, updateValues, predicatesUpdate);
3651 HILOG_INFO("contact_Delete_Recover_test_7500 : updateCode = %{public}d", updateCode);
3652 EXPECT_EQ(updateCode, 0);
3653
3654 OHOS::DataShare::DataSharePredicates predicatesDelete;
3655 predicatesDelete.EqualTo("raw_contact_id", std::to_string(rawContactId));
3656 int deleteCodeOne = ContactDelete(ContactTabName::DELETED_RAW_CONTACT_RECORD, predicatesDelete);
3657 EXPECT_EQ(deleteCodeOne, 0);
3658
3659 OHOS::DataShare::DataSharePredicates predicatesQuery;
3660 predicatesQuery.EqualTo("id", std::to_string(rawContactId));
3661 predicatesQuery.And();
3662 predicatesQuery.EqualTo("is_deleted", "0");
3663 std::vector<std::string> columns;
3664 std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
3665 ContactQuery(ContactTabName::RAW_CONTACT, columns, predicatesQuery);
3666 int rowCount = 0;
3667 resultSet->GetRowCount(rowCount);
3668 EXPECT_EQ(1, rowCount);
3669 resultSet->Close();
3670 ClearContacts();
3671 }
3672 } // namespace Test
3673 } // namespace Contacts