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