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 "calllogability_test.h"
17 
18 #include "data_ability_operation_builder.h"
19 #include "random_number_utils.h"
20 
21 using namespace OHOS::Contacts;
22 
23 namespace Contacts {
24 namespace Test {
CalllogAbilityTest()25 CalllogAbilityTest::CalllogAbilityTest()
26 {
27 }
28 
~CalllogAbilityTest()29 CalllogAbilityTest::~CalllogAbilityTest()
30 {
31 }
32 
CalllogInsert(std::string phoneNumber)33 int64_t CalllogAbilityTest::CalllogInsert(std::string phoneNumber)
34 {
35     OHOS::Uri uriCalllog(CallLogUri::CALL_LOG);
36     OHOS::DataShare::DataShareValuesBucket calllogValues;
37     calllogValues.Put("phone_number", phoneNumber);
38     int64_t code = calllogAbility.Insert(uriCalllog, calllogValues);
39     calllogValues.Clear();
40     return code;
41 }
42 
CalllogUpdate( OHOS::DataShare::DataShareValuesBucket updateValues, OHOS::DataShare::DataSharePredicates predicates)43 int CalllogAbilityTest::CalllogUpdate(
44     OHOS::DataShare::DataShareValuesBucket updateValues, OHOS::DataShare::DataSharePredicates predicates)
45 {
46     OHOS::Uri uriCalllog(CallLogUri::CALL_LOG);
47     int code = calllogAbility.Update(uriCalllog, predicates, updateValues);
48     return code;
49 }
50 
CalllogDelete(OHOS::DataShare::DataSharePredicates predicates)51 int CalllogAbilityTest::CalllogDelete(OHOS::DataShare::DataSharePredicates predicates)
52 {
53     OHOS::Uri uriCalllog(CallLogUri::CALL_LOG);
54     int code = calllogAbility.Delete(uriCalllog, predicates);
55     return code;
56 }
57 
CalllogQuery( std::vector<std::string> columns, OHOS::DataShare::DataSharePredicates predicates)58 std::shared_ptr<OHOS::DataShare::DataShareResultSet> CalllogAbilityTest::CalllogQuery(
59     std::vector<std::string> columns, OHOS::DataShare::DataSharePredicates predicates)
60 {
61     OHOS::Uri uriCalllog(CallLogUri::CALL_LOG);
62     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
63         calllogAbility.Query(uriCalllog, predicates, columns);
64     return resultSet;
65 }
66 
CalllogInsertValues(OHOS::DataShare::DataShareValuesBucket &values)67 int64_t CalllogAbilityTest::CalllogInsertValues(OHOS::DataShare::DataShareValuesBucket &values)
68 {
69     OHOS::Uri uriCalllog(CallLogUri::CALL_LOG);
70     int64_t code = calllogAbility.Insert(uriCalllog, values);
71     return code;
72 }
73 
CalllogInsertValue(std::string displayName, OHOS::DataShare::DataShareValuesBucket &values)74 int64_t CalllogAbilityTest::CalllogInsertValue(std::string displayName, OHOS::DataShare::DataShareValuesBucket &values)
75 {
76     OHOS::Uri uriCalllog(CallLogUri::CALL_LOG);
77     values.Put("display_name", displayName);
78     int64_t code = calllogAbility.Insert(uriCalllog, values);
79     return code;
80 }
81 
GetAllValuesColumn(std::vector<std::string> &column)82 void CalllogAbilityTest::GetAllValuesColumn(std::vector<std::string> &column)
83 {
84     column.push_back("slot_id");
85     column.push_back("phone_number");
86     column.push_back("display_name");
87     column.push_back("call_direction");
88     column.push_back("voicemail_uri");
89     column.push_back("sim_type");
90     column.push_back("is_hd");
91     column.push_back("is_read");
92     column.push_back("ring_duration");
93     column.push_back("talk_duration");
94     column.push_back("format_number");
95     column.push_back("quicksearch_key");
96     column.push_back("number_type");
97     column.push_back("number_type_name");
98     column.push_back("begin_time");
99     column.push_back("end_time");
100     column.push_back("answer_state");
101     column.push_back("create_time");
102     column.push_back("number_location");
103     column.push_back("photo_id");
104     column.push_back("photo_uri");
105     column.push_back("country_iso_code");
106     column.push_back("extra1");
107     column.push_back("extra2");
108     column.push_back("extra3");
109     column.push_back("extra4");
110     column.push_back("extra5");
111     column.push_back("extra6");
112 }
113 
114 /**
115  * @brief get ValuesBucket
116  * @params columnsStart column start index
117  * @params columnsEnd column end index
118  * @return ValuesBucket
119  */
GetCallLogValues( int columnsStart, int columnsEnd, std::vector<std::string> &columns)120 OHOS::DataShare::DataShareValuesBucket CalllogAbilityTest::GetCallLogValues(
121     int columnsStart, int columnsEnd, std::vector<std::string> &columns)
122 {
123     std::string callLogTestStringValue = std::to_string(ContactsRand());
124     int number = 6;
125     RandomNumberUtils randomNumberUtils;
126     std::string phoneNumber = randomNumberUtils.Generating(number);
127     OHOS::DataShare::DataShareValuesBucket valuesBucket;
128     valuesBucket.Put("slot_id", ContactsRand());
129     valuesBucket.Put("phone_number", phoneNumber + callLogTestStringValue);
130     valuesBucket.Put("display_name", "name");
131     valuesBucket.Put("call_direction", ContactsRand());
132     valuesBucket.Put("voicemail_uri", "uri::voicemail_uri" + callLogTestStringValue);
133     valuesBucket.Put("sim_type", ContactsRand());
134     valuesBucket.Put("is_hd", ContactsRand());
135     valuesBucket.Put("is_read", ContactsRand());
136     valuesBucket.Put("ring_duration", ContactsRand());
137     valuesBucket.Put("talk_duration", ContactsRand());
138     valuesBucket.Put("format_number", "154 121" + callLogTestStringValue);
139     valuesBucket.Put("quicksearch_key", "1");
140     valuesBucket.Put("number_type", ContactsRand());
141     valuesBucket.Put("number_type_name", "numberType" + callLogTestStringValue);
142     valuesBucket.Put("begin_time", ContactsRand());
143     valuesBucket.Put("end_time", ContactsRand());
144     valuesBucket.Put("answer_state", ContactsRand());
145     valuesBucket.Put("create_time", ContactsRand());
146     valuesBucket.Put("number_location", "location" + callLogTestStringValue);
147     valuesBucket.Put("photo_id", ContactsRand());
148     valuesBucket.Put("photo_uri", "uri::photo_uri" + callLogTestStringValue);
149     valuesBucket.Put("country_iso_code", ContactsRand());
150     valuesBucket.Put("extra1", "extra1" + callLogTestStringValue);
151     valuesBucket.Put("extra2", "extra2" + callLogTestStringValue);
152     valuesBucket.Put("extra3", "extra3" + callLogTestStringValue);
153     valuesBucket.Put("extra4", "extra4" + callLogTestStringValue);
154     valuesBucket.Put("extra5", "extra5" + callLogTestStringValue);
155     valuesBucket.Put("extra6", "extra6" + callLogTestStringValue);
156     std::vector<std::string> columnsTemp;
157     GetAllValuesColumn(columnsTemp);
158     int allSize = columnsTemp.size();
159     for (int i = 0; i < allSize; i++) {
160         if (i >= columnsStart && i < columnsEnd) {
161             columns.push_back(columnsTemp[i]);
162         } else {
163             valuesBucket.Put(columnsTemp[i], "");
164         }
165     }
166     return valuesBucket;
167 }
168 
ClearCallLog()169 void CalllogAbilityTest::ClearCallLog()
170 {
171     // clear all callLog data
172     OHOS::DataShare::DataSharePredicates predicates;
173     predicates.GreaterThan("id", "0");
174     int deleteCode = CalllogDelete(predicates);
175     EXPECT_EQ(deleteCode, 0);
176 }
177 
178 /*
179  * @tc.number  calllog_Insert_test_100
180  * @tc.name    Add a single contact data and verify whether the insertion is successful
181  * @tc.desc    Added ability to call record
182  * @tc.level   Level1
183  * @tc.size    MediumTest
184  * @tc.type    Function
185  */
HWTEST_F(CalllogAbilityTest, calllog_Insert_test_100, testing::ext::TestSize.Level1)186 HWTEST_F(CalllogAbilityTest, calllog_Insert_test_100, testing::ext::TestSize.Level1)
187 {
188     HILOG_INFO("--- calllog_Insert_test_100 is starting! ---");
189     std::vector<std::string> columns;
190     OHOS::DataShare::DataShareValuesBucket valuesBucket;
191     RandomNumberUtils randomNumberUtils;
192     std::string phoneNumber = randomNumberUtils.Generating(10);
193     valuesBucket.Put("phone_number", phoneNumber);
194     columns.push_back("phone_number");
195     int rawId = CalllogInsertValues(valuesBucket);
196     EXPECT_GT(rawId, 0);
197 
198     // query insert data
199     OHOS::DataShare::DataSharePredicates predicates;
200     predicates.EqualTo("id", std::to_string(rawId));
201     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetDeleteQuery = CalllogQuery(columns, predicates);
202     // resultSet count 1
203     int rowCount = 0;
204     resultSetDeleteQuery->GetRowCount(rowCount);
205     EXPECT_EQ(1, rowCount);
206     CheckResultSet(valuesBucket, resultSetDeleteQuery, "calllog_Insert_test_100");
207     ClearCallLog();
208 }
209 
210 /*
211  * @tc.number  calllog_Insert_test_200
212  * @tc.name    Add full field data to the callog table and verify that the insertion was successful
213  * @tc.desc    Added ability to call record
214  * @tc.level   Level1
215  * @tc.size    MediumTest
216  * @tc.type    Function
217  */
HWTEST_F(CalllogAbilityTest, calllog_Insert_test_200, testing::ext::TestSize.Level1)218 HWTEST_F(CalllogAbilityTest, calllog_Insert_test_200, testing::ext::TestSize.Level1)
219 {
220     HILOG_INFO("-----calllog_Insert_test_200 is starting!-----");
221     std::vector<std::string> columns;
222     GetAllValuesColumn(columns);
223     int columnsSize = 27;
224     OHOS::DataShare::DataShareValuesBucket valuesBucket = GetCallLogValues(0, columnsSize, columns);
225     int rawId = CalllogInsertValues(valuesBucket);
226     EXPECT_GT(rawId, 0);
227     OHOS::DataShare::DataSharePredicates predicates;
228     predicates.EqualTo("id", std::to_string(rawId));
229     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates);
230     // resultSet count 1
231     int rowCount = 0;
232     resultSet->GetRowCount(rowCount);
233     EXPECT_EQ(1, rowCount);
234     CheckResultSet(valuesBucket, resultSet, "calllog_Insert_test_200");
235     OHOS::DataShare::DataSharePredicates predicates2;
236     predicates2.EqualTo("id", std::to_string(rawId));
237     // test end delete data
238     int deleteCode = CalllogDelete(predicates2);
239     EXPECT_EQ(deleteCode, 0);
240     ClearCallLog();
241 }
242 
243 /*
244  * @tc.number  calllog_Update_test_300
245  * @tc.name    Update single contact data and verify whether the update is successful
246  * @tc.desc    Support single call record update capability
247  * @tc.level   Level1
248  * @tc.size    MediumTest
249  * @tc.type    Function
250  */
HWTEST_F(CalllogAbilityTest, calllog_Update_test_300, testing::ext::TestSize.Level1)251 HWTEST_F(CalllogAbilityTest, calllog_Update_test_300, testing::ext::TestSize.Level1)
252 {
253     HILOG_INFO("--- calllog_Update_test_300 is starting! ---");
254     std::vector<std::string> columns;
255     columns.push_back("phone_number");
256     OHOS::DataShare::DataShareValuesBucket valuesBucket;
257     RandomNumberUtils randomNumberUtils;
258     std::string phoneNumber = randomNumberUtils.Generating(12);
259     valuesBucket.Put("phone_number", phoneNumber);
260     int rawId = CalllogInsertValues(valuesBucket);
261     EXPECT_GT(rawId, 0);
262 
263     OHOS::DataShare::DataShareValuesBucket updateValues;
264     std::string phoneNumber_test = randomNumberUtils.Generating(10);
265     updateValues.Put("phone_number", phoneNumber_test);
266     OHOS::DataShare::DataSharePredicates predicates;
267     predicates.EqualTo("id", std::to_string(rawId));
268     int updateCode = CalllogUpdate(updateValues, predicates);
269     EXPECT_EQ(0, updateCode);
270 
271     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetDeleteQuery = CalllogQuery(columns, predicates);
272     // resultSet count 1
273     int rowCount = 0;
274     resultSetDeleteQuery->GetRowCount(rowCount);
275     EXPECT_EQ(1, rowCount);
276     CheckResultSet(updateValues, resultSetDeleteQuery, "calllog_Update_test_300");
277     ClearCallLog();
278 }
279 
280 /*
281  * @tc.number  calllog_Update_test_400
282  * @tc.name    Update the data of all fields of callog table and verify whether the update is successful
283  * @tc.desc    Support all call log update capability
284  * @tc.level   Level1
285  * @tc.size    MediumTest
286  * @tc.type    Function
287  */
HWTEST_F(CalllogAbilityTest, calllog_Update_test_400, testing::ext::TestSize.Level1)288 HWTEST_F(CalllogAbilityTest, calllog_Update_test_400, testing::ext::TestSize.Level1)
289 {
290     HILOG_INFO("-----calllog_Update_test_400 is starting!-----");
291     std::vector<std::string> columns;
292     GetAllValuesColumn(columns);
293     int columnsSize = 27;
294     OHOS::DataShare::DataShareValuesBucket valuesBucket = GetCallLogValues(0, columnsSize, columns);
295     int rawId = CalllogInsertValues(valuesBucket);
296     OHOS::DataShare::DataSharePredicates predicates;
297     predicates.EqualTo("id", std::to_string(rawId));
298     OHOS::DataShare::DataShareValuesBucket upDateValuesBucket = GetCallLogValues(0, columnsSize, columns);
299     int upDateCode = CalllogUpdate(upDateValuesBucket, predicates);
300     EXPECT_EQ(upDateCode, 0);
301 
302     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates);
303     int rowCount = 0;
304     resultSet->GetRowCount(rowCount);
305     EXPECT_EQ(1, rowCount);
306 
307     CheckResultSet(upDateValuesBucket, resultSet, "calllog_Update_test_400");
308     OHOS::DataShare::DataSharePredicates predicates2;
309     predicates2.EqualTo("id", std::to_string(rawId));
310     // test end delete data
311     int deleteCode = CalllogDelete(predicates2);
312     EXPECT_EQ(deleteCode, 0);
313     ClearCallLog();
314 }
315 
316 /*
317  * @tc.number  calllog_Update_test_500
318  * @tc.name    Update all call records and verify that the update is successful
319  * @tc.desc    Support all call log update capability
320  * @tc.level   Level1
321  * @tc.size    MediumTest
322  * @tc.type    Function
323  */
HWTEST_F(CalllogAbilityTest, calllog_Update_test_500, testing::ext::TestSize.Level1)324 HWTEST_F(CalllogAbilityTest, calllog_Update_test_500, testing::ext::TestSize.Level1)
325 {
326     HILOG_INFO("--- calllog_Update_test_500 is starting! ---");
327     OHOS::DataShare::DataShareValuesBucket valuesBucket;
328     RandomNumberUtils randomNumberUtils;
329     std::string phoneNumber = randomNumberUtils.Generating(10);
330     valuesBucket.Put("phone_number", phoneNumber);
331     valuesBucket.Put("display_name", "testName");
332     CalllogInsertValues(valuesBucket);
333     CalllogInsertValues(valuesBucket);
334     int rawCount = 2;
335     std::vector<std::string> columns;
336     columns.push_back("ring_duration");
337     OHOS::DataShare::DataSharePredicates predicates;
338     predicates.GreaterThan("id", "0");
339     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetQuery = CalllogQuery(columns, predicates);
340     int rowCurrentCount = 0;
341     resultSetQuery->GetRowCount(rowCurrentCount);
342     resultSetQuery->Close();
343     EXPECT_EQ(rowCurrentCount, rawCount);
344 
345     // update database current data
346     OHOS::DataShare::DataShareValuesBucket updateValues;
347     updateValues.Put("ring_duration", 500);
348     predicates.GreaterThan("id", "0");
349     int updateCode = CalllogUpdate(updateValues, predicates);
350     EXPECT_EQ(updateCode, 0);
351     // check update data or dataBase
352     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetUpDateQuery = CalllogQuery(columns, predicates);
353     int rowUpDateCount = 0;
354     resultSetUpDateQuery->GetRowCount(rowUpDateCount);
355     EXPECT_EQ(rowCurrentCount, rowUpDateCount);
356     std::vector<OHOS::DataShare::DataShareValuesBucket> upValues;
357     upValues.push_back(updateValues);
358     upValues.push_back(updateValues);
359     CheckResultSetList(upValues, resultSetUpDateQuery, "calllog_Update_test_500");
360     ClearCallLog();
361 }
362 
363 /*
364  * @tc.number  calllog_Query_test_600
365  * @tc.name    Add call record data, query the data according to the returned ID and return the query result
366  * @tc.desc    Support single call record query capability
367  * @tc.level   Level1
368  * @tc.size    MediumTest
369  * @tc.type    Function
370  */
HWTEST_F(CalllogAbilityTest, calllog_Query_test_600, testing::ext::TestSize.Level1)371 HWTEST_F(CalllogAbilityTest, calllog_Query_test_600, testing::ext::TestSize.Level1)
372 {
373     HILOG_INFO("--- calllog_Query_test_600 is starting! ---");
374     std::vector<std::string> columns;
375     columns.push_back("phone_number");
376     columns.push_back("display_name");
377     columns.push_back("id");
378     OHOS::DataShare::DataShareValuesBucket valuesBucket;
379     RandomNumberUtils randomNumberUtils;
380     std::string phoneNumber = randomNumberUtils.Generating(10);
381     valuesBucket.Put("phone_number", phoneNumber);
382     valuesBucket.Put("display_name", "testName");
383     int rawId = CalllogInsertValues(valuesBucket);
384     EXPECT_GT(rawId, 0);
385     // query insert data
386     OHOS::DataShare::DataSharePredicates predicates;
387     predicates.EqualTo("id", std::to_string(rawId));
388     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetDeleteQuery = CalllogQuery(columns, predicates);
389     // resultSet count 1
390     int rowCount = 0;
391     resultSetDeleteQuery->GetRowCount(rowCount);
392     EXPECT_EQ(1, rowCount);
393     valuesBucket.Put("id", rawId);
394     CheckResultSet(valuesBucket, resultSetDeleteQuery, "calllog_Query_test_600");
395     ClearCallLog();
396 }
397 
398 /*
399  * @tc.number  calllog_Query_test_800
400  * @tc.name    Query the call record according to the combination conditions and return the query results
401  * @tc.desc    Support combination condition query call record ability
402  * @tc.level   Level1
403  * @tc.size    MediumTest
404  * @tc.type    Function
405  */
HWTEST_F(CalllogAbilityTest, calllog_Query_test_800, testing::ext::TestSize.Level1)406 HWTEST_F(CalllogAbilityTest, calllog_Query_test_800, testing::ext::TestSize.Level1)
407 {
408     HILOG_INFO("-----calllog_Query_test_800 is starting!-----");
409     int ringDuration = 9121215;
410     OHOS::DataShare::DataShareValuesBucket valuesBucket;
411     RandomNumberUtils randomNumberUtils;
412     std::string phoneNumber = randomNumberUtils.Generating(10);
413     valuesBucket.Put("phone_number", phoneNumber);
414     valuesBucket.Put("display_name", "testName");
415     valuesBucket.Put("ring_duration", ringDuration);
416     int rawId = CalllogInsertValues(valuesBucket);
417     EXPECT_GT(rawId, 0);
418 
419     std::vector<std::string> columns;
420     columns.push_back("phone_number");
421     columns.push_back("display_name");
422     columns.push_back("ring_duration");
423     columns.push_back("id");
424     OHOS::DataShare::DataSharePredicates predicates;
425     predicates.EqualTo("id", std::to_string(rawId));
426     predicates.And();
427     predicates.EqualTo("ring_duration", std::to_string(ringDuration));
428     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates);
429     // resultSet count 1
430     int rowCount = 0;
431     resultSet->GetRowCount(rowCount);
432     EXPECT_EQ(1, rowCount);
433     // add id check
434     valuesBucket.Put("id", rawId);
435     CheckResultSet(valuesBucket, resultSet, "calllog_Query_test_800");
436     ClearCallLog();
437 }
438 
439 /*
440  * @tc.number  calllog_Query_test_900
441  * @tc.name    Query all call records and return query results
442  * @tc.desc    Query all call records
443  * @tc.level   Level1
444  * @tc.size    MediumTest
445  * @tc.type    Function
446  */
HWTEST_F(CalllogAbilityTest, calllog_Query_test_900, testing::ext::TestSize.Level1)447 HWTEST_F(CalllogAbilityTest, calllog_Query_test_900, testing::ext::TestSize.Level1)
448 {
449     HILOG_INFO("-----calllog_Query_test_900 is starting!-----");
450     OHOS::DataShare::DataShareValuesBucket valuesBucket;
451     RandomNumberUtils randomNumberUtils;
452     std::string phoneNumber = randomNumberUtils.Generating(14);
453     valuesBucket.Put("phone_number", phoneNumber);
454     valuesBucket.Put("display_name", "testName");
455     CalllogInsertValues(valuesBucket);
456     CalllogInsertValues(valuesBucket);
457     CalllogInsertValues(valuesBucket);
458     CalllogInsertValues(valuesBucket);
459     std::vector<std::string> columns;
460     columns.push_back("id");
461     columns.push_back("phone_number");
462     OHOS::DataShare::DataSharePredicates predicates;
463     predicates.GreaterThan("id", "0");
464     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates);
465     int current = 4;
466     // resultSet count 4
467     int rowCount = 0;
468     resultSet->GetRowCount(rowCount);
469     EXPECT_EQ(current, rowCount);
470     resultSet->Close();
471     ClearCallLog();
472 }
473 
474 /*
475  * @tc.number  calllog_Delete_test_1000
476  * @tc.name    Delete a single call record and verify whether the deletion is successful
477  * @tc.desc    Call log deletion capability
478  * @tc.level   Level1
479  * @tc.size    MediumTest
480  * @tc.type    Function
481  */
HWTEST_F(CalllogAbilityTest, calllog_Delete_test_1000, testing::ext::TestSize.Level1)482 HWTEST_F(CalllogAbilityTest, calllog_Delete_test_1000, testing::ext::TestSize.Level1)
483 {
484     HILOG_INFO("--- calllog_Delete_test_1000 is starting! ---");
485     OHOS::DataShare::DataShareValuesBucket valuesBucket;
486     RandomNumberUtils randomNumberUtils;
487     std::string phoneNumber = randomNumberUtils.Generating(10);
488     valuesBucket.Put("phone_number", phoneNumber);
489     std::vector<std::string> columns;
490     int rawId = CalllogInsertValues(valuesBucket);
491     EXPECT_GT(rawId, 0);
492     OHOS::DataShare::DataSharePredicates predicates;
493     predicates.EqualTo("id", std::to_string(rawId));
494     int deleteCode = CalllogDelete(predicates);
495     EXPECT_EQ(deleteCode, 0);
496     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates);
497     // resultSet count
498     int rowCount = 0;
499     resultSet->GetRowCount(rowCount);
500     EXPECT_EQ(0, rowCount);
501     resultSet->Close();
502     ClearCallLog();
503 }
504 
505 /*
506  * @tc.number  calllog_Delete_test_1100
507  * @tc.name    Delete a single call record data and verify whether the deletion is successful
508  * @tc.desc    Call log deletion capability
509  * @tc.level   Level1
510  * @tc.size    MediumTest
511  * @tc.type    Function
512  */
HWTEST_F(CalllogAbilityTest, calllog_Delete_test_1100, testing::ext::TestSize.Level1)513 HWTEST_F(CalllogAbilityTest, calllog_Delete_test_1100, testing::ext::TestSize.Level1)
514 {
515     HILOG_INFO("--- calllog_Delete_test_1100 is starting! ---");
516     OHOS::DataShare::DataShareValuesBucket valuesBucket;
517     RandomNumberUtils randomNumberUtils;
518     std::string phoneNumber = randomNumberUtils.Generating(10);
519     valuesBucket.Put("phone_number", phoneNumber);
520     int rawId = CalllogInsertValues(valuesBucket);
521     EXPECT_GT(rawId, 0);
522 
523     OHOS::DataShare::DataShareValuesBucket valuesBucketTwo;
524     std::string phoneNumber_test = randomNumberUtils.Generating(11);
525     valuesBucketTwo.Put("phone_number", phoneNumber_test);
526     int rawIdTwo = CalllogInsertValues(valuesBucketTwo);
527     EXPECT_GT(rawIdTwo, 0);
528     OHOS::DataShare::DataSharePredicates predicates;
529     predicates.EqualTo("id", std::to_string(rawId));
530     predicates.Or();
531     predicates.EqualTo("id", std::to_string(rawIdTwo));
532     int deleteCode = CalllogDelete(predicates);
533     EXPECT_EQ(deleteCode, 0);
534 
535     std::vector<std::string> columns;
536     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates);
537     // resultSet count
538     int rowCount = 0;
539     resultSet->GetRowCount(rowCount);
540     EXPECT_EQ(0, rowCount);
541     resultSet->Close();
542     ClearCallLog();
543 }
544 
545 /*
546  * @tc.number  calllog_Delete_test_1200
547  * @tc.name    Delete the data of all fields in the callog table and verify whether the deletion is successful
548  * @tc.desc    Call log deletion capability
549  * @tc.level   Level1
550  * @tc.size    MediumTest
551  * @tc.type    Function
552  */
HWTEST_F(CalllogAbilityTest, calllog_Delete_test_1200, testing::ext::TestSize.Level1)553 HWTEST_F(CalllogAbilityTest, calllog_Delete_test_1200, testing::ext::TestSize.Level1)
554 {
555     HILOG_INFO("-----calllog_Delete_test_1200 is starting!-----");
556     // insert
557     std::vector<std::string> columns;
558     GetAllValuesColumn(columns);
559     int columnsSize = 27;
560     OHOS::DataShare::DataShareValuesBucket valuesBucket = GetCallLogValues(0, columnsSize, columns);
561     int rawId = CalllogInsertValues(valuesBucket);
562     EXPECT_GT(rawId, 0);
563     OHOS::DataShare::DataSharePredicates predicates;
564     predicates.EqualTo("id", std::to_string(rawId));
565     int deleteCode = CalllogDelete(predicates);
566     EXPECT_EQ(deleteCode, 0);
567 
568     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetDeleteQuery = CalllogQuery(columns, predicates);
569     int rowCount = 0;
570     resultSetDeleteQuery->GetRowCount(rowCount);
571     EXPECT_EQ(0, rowCount);
572     resultSetDeleteQuery->Close();
573     ClearCallLog();
574 }
575 
576 /*
577  * @tc.number  calllog_BatchInsert_test_1300
578  * @tc.name    Batch add call record data and verify whether the insertion is successful
579  * @tc.desc    Add ability to call records in batches
580  * @tc.level   Level1
581  * @tc.size    MediumTest
582  * @tc.type    Function
583  */
HWTEST_F(CalllogAbilityTest, calllog_BatchInsert_test_1300, testing::ext::TestSize.Level1)584 HWTEST_F(CalllogAbilityTest, calllog_BatchInsert_test_1300, testing::ext::TestSize.Level1)
585 {
586     HILOG_INFO("--- calllog_BatchInsert_test_1300 is starting!---");
587     OHOS::DataShare::DataShareValuesBucket valuesBucket;
588     int numberLen = 14;
589     RandomNumberUtils randomNumberUtils;
590     std::string phoneNumber = randomNumberUtils.Generating(numberLen);
591     valuesBucket.Put("phone_number", phoneNumber);
592     valuesBucket.Put("ring_duration", 1000);
593     OHOS::DataShare::DataShareValuesBucket valuesBucketTwo;
594     std::string phoneNumber2 = randomNumberUtils.Generating(numberLen);
595     valuesBucketTwo.Put("phone_number", phoneNumber2);
596     valuesBucketTwo.Put("ring_duration", 1200);
597     OHOS::DataShare::DataShareValuesBucket valuesBucketThree;
598     std::string phoneNumber3 = randomNumberUtils.Generating(numberLen);
599     valuesBucketThree.Put("phone_number", phoneNumber3);
600     valuesBucketThree.Put("ring_duration", 1500);
601     std::vector<OHOS::DataShare::DataShareValuesBucket> listAddValuesBucket;
602     listAddValuesBucket.push_back(valuesBucket);
603     listAddValuesBucket.push_back(valuesBucketTwo);
604     listAddValuesBucket.push_back(valuesBucketThree);
605     OHOS::Uri batchInsertUri(CallLogUri::CALL_LOG);
606 
607     int batchInsertCode = calllogAbility.BatchInsert(batchInsertUri, listAddValuesBucket);
608     EXPECT_EQ(batchInsertCode, 0);
609 
610     OHOS::DataShare::DataSharePredicates predicates;
611     std::vector<std::string> columns;
612     columns.push_back("phone_number");
613     columns.push_back("ring_duration");
614     predicates.EqualTo("phone_number", phoneNumber);
615     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates);
616     int rowCount = 0;
617     resultSet->GetRowCount(rowCount);
618     EXPECT_EQ(1, rowCount);
619 
620     CheckResultSet(valuesBucket, resultSet, "calllog_BatchInsert_test_1300");
621     OHOS::DataShare::DataSharePredicates predicates2;
622     predicates2.EqualTo("phone_number", phoneNumber2);
623     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetTwo = CalllogQuery(columns, predicates2);
624     int rowCountTwo = 0;
625     resultSetTwo->GetRowCount(rowCountTwo);
626     EXPECT_EQ(1, rowCountTwo);
627 
628     CheckResultSet(valuesBucketTwo, resultSetTwo, "calllog_BatchInsert_test_1300");
629     OHOS::DataShare::DataSharePredicates predicates3;
630     predicates3.EqualTo("phone_number", phoneNumber3);
631     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetThree = CalllogQuery(columns, predicates3);
632     int rowCountThree = 0;
633     resultSetThree->GetRowCount(rowCountThree);
634     EXPECT_EQ(1, rowCountThree);
635     CheckResultSet(valuesBucketThree, resultSetThree, "calllog_BatchInsert_test_1300");
636     ClearCallLog();
637 }
638 
639 /*
640  * @tc.number  calllog_Delete_test_1400
641  * @tc.name    Delete call record data in batch and verify whether the deletion is successful
642  * @tc.desc    delete ability to call records in batches
643  * @tc.level   Level1
644  * @tc.size    MediumTest
645  * @tc.type    Function
646  */
HWTEST_F(CalllogAbilityTest, calllog_Delete_test_1400, testing::ext::TestSize.Level1)647 HWTEST_F(CalllogAbilityTest, calllog_Delete_test_1400, testing::ext::TestSize.Level1)
648 {
649     HILOG_INFO("--- calllog_Delete_test_1400 is starting!---");
650     OHOS::DataShare::DataShareValuesBucket valuesBucketOne;
651     RandomNumberUtils randomNumberUtils;
652     std::string phoneNumber = randomNumberUtils.Generating(9);
653     valuesBucketOne.Put("phone_number", phoneNumber);
654     valuesBucketOne.Put("ring_duration", 998);
655     int rawIdOne = CalllogInsertValues(valuesBucketOne);
656     EXPECT_GT(rawIdOne, 0);
657     int rawIdTwo = CalllogInsertValues(valuesBucketOne);
658     EXPECT_GT(rawIdTwo, 0);
659 
660     OHOS::DataShare::DataSharePredicates predicates;
661     predicates.GreaterThan("id", "0");
662     int deleteCode = CalllogDelete(predicates);
663     EXPECT_EQ(deleteCode, 0);
664     std::vector<std::string> columns;
665     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetInsertQuery = CalllogQuery(columns, predicates);
666     int rowCount = 0;
667     resultSetInsertQuery->GetRowCount(rowCount);
668     EXPECT_EQ(0, rowCount);
669     ClearCallLog();
670 }
671 
672 /*
673  * @tc.number  calllog_Update_test_1500
674  * @tc.name    Batch update call record data and verify whether the update is successful
675  * @tc.desc    update ability to call records in batches
676  * @tc.level   Level1
677  * @tc.size    MediumTest
678  * @tc.type    Function
679  */
HWTEST_F(CalllogAbilityTest, calllog_Update_test_1500, testing::ext::TestSize.Level1)680 HWTEST_F(CalllogAbilityTest, calllog_Update_test_1500, testing::ext::TestSize.Level1)
681 {
682     HILOG_INFO("--- calllog_Update_test_1500 is starting!---");
683     OHOS::DataShare::DataShareValuesBucket valuesBucketOne;
684     RandomNumberUtils randomNumberUtils;
685     std::string phoneNumber = randomNumberUtils.Generating(9);
686     valuesBucketOne.Put("phone_number", phoneNumber);
687     valuesBucketOne.Put("ring_duration", 998);
688     int rawIdOne = CalllogInsertValues(valuesBucketOne);
689     EXPECT_GT(rawIdOne, 0);
690     int rawIdTwo = CalllogInsertValues(valuesBucketOne);
691     EXPECT_GT(rawIdTwo, 0);
692 
693     OHOS::DataShare::DataShareValuesBucket calllogValues;
694     std::string phoneNumber2 = randomNumberUtils.Generating(5);
695     calllogValues.Put("phone_number", phoneNumber2);
696     OHOS::DataShare::DataSharePredicates predicates;
697     predicates.EqualTo("id", std::to_string(rawIdOne));
698     predicates.Or();
699     predicates.EqualTo("id", std::to_string(rawIdTwo));
700     int updateCode = CalllogUpdate(calllogValues, predicates);
701     EXPECT_EQ(updateCode, 0);
702 
703     std::vector<std::string> columns;
704     columns.push_back("phone_number");
705     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetInsertQuery = CalllogQuery(columns, predicates);
706     int rowCount = 0;
707     resultSetInsertQuery->GetRowCount(rowCount);
708     EXPECT_EQ(2, rowCount);
709     std::vector<OHOS::DataShare::DataShareValuesBucket> listValue;
710     listValue.push_back(calllogValues);
711     listValue.push_back(calllogValues);
712     CheckResultSetList(listValue, resultSetInsertQuery, "calllog_Update_test_1500");
713     ClearCallLog();
714 }
715 
716 /*
717  * @tc.number  abnormal_calllog_Insert_test_1600
718  * @tc.name    When adding individual contact data, a non-existent field is passed in
719  * @tc.desc    Exception use case
720  * @tc.level   Level1
721  * @tc.size    MediumTest
722  * @tc.type    Function
723  */
HWTEST_F(CalllogAbilityTest, abnormal_calllog_Insert_test_1600, testing::ext::TestSize.Level1)724 HWTEST_F(CalllogAbilityTest, abnormal_calllog_Insert_test_1600, testing::ext::TestSize.Level1)
725 {
726     HILOG_INFO("-----abnormal_calllog_Insert_test_1600 is starting!-----");
727 
728     OHOS::Uri uriCalllog(CallLogUri::CALL_LOG);
729     OHOS::Uri errorUri(CallLogUri::ERROR_URI);
730     std::vector<std::string> columns;
731     columns.push_back("phone_number");
732     RandomNumberUtils randomNumberUtils;
733     std::string phoneNumber = randomNumberUtils.Generating(6);
734     OHOS::DataShare::DataShareValuesBucket calllogValues;
735     calllogValues.Put("phone_numbers", phoneNumber);
736     int calllogId = calllogAbility.Insert(uriCalllog, calllogValues);
737     EXPECT_EQ(calllogId, -1);
738     OHOS::DataShare::DataSharePredicates predicates;
739     predicates.EqualTo("phone_numbers", phoneNumber);
740     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates);
741     int rowCount = 0;
742     resultSet->GetRowCount(rowCount);
743     EXPECT_EQ(-1, rowCount);
744 
745     resultSet->Close();
746     calllogValues.Clear();
747     calllogValues.Put("phone_number", phoneNumber);
748     calllogId = calllogAbility.Insert(errorUri, calllogValues);
749     EXPECT_EQ(calllogId, -1);
750 
751     calllogValues.Clear();
752     predicates.EqualTo("phone_number", phoneNumber);
753     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetUriError = CalllogQuery(columns, predicates);
754     int rowCountUriError = 0;
755     resultSetUriError->GetRowCount(rowCountUriError);
756     EXPECT_EQ(-1, rowCountUriError);
757     resultSetUriError->Close();
758     ClearCallLog();
759 }
760 
761 /*
762  * @tc.number  abnormal_calllog_Update_test_1700
763  * @tc.name    Update a single call record and pass in non-existent fields
764  * @tc.desc    Updated ability to call record
765  * @tc.level   Level1
766  * @tc.size    MediumTest
767  * @tc.type    Function
768  */
HWTEST_F(CalllogAbilityTest, abnormal_calllog_Update_test_1700, testing::ext::TestSize.Level1)769 HWTEST_F(CalllogAbilityTest, abnormal_calllog_Update_test_1700, testing::ext::TestSize.Level1)
770 {
771     HILOG_INFO("--- abnormal_calllog_Update_test_1700 is starting! ---");
772     std::vector<std::string> columns;
773     OHOS::DataShare::DataShareValuesBucket valuesBucket;
774     RandomNumberUtils randomNumberUtils;
775     std::string phoneNumber = randomNumberUtils.Generating(10);
776     valuesBucket.Put("phone_number", phoneNumber);
777     valuesBucket.Put("display_name", "abnormal_sigle");
778     columns.push_back("phone_number");
779     columns.push_back("display_name");
780     int rawId = CalllogInsertValues(valuesBucket);
781     EXPECT_GT(rawId, 0);
782 
783     OHOS::DataShare::DataShareValuesBucket updateValues;
784     updateValues.Put("phone_number_sha", phoneNumber);
785     OHOS::DataShare::DataSharePredicates predicates;
786     predicates.EqualTo("id", std::to_string(rawId));
787     int updateCode = CalllogUpdate(updateValues, predicates);
788     EXPECT_EQ(-1, updateCode);
789 
790     // query insert data
791     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetInsertQuery = CalllogQuery(columns, predicates);
792     // resultSet count 0, update failed will delete the calllog
793     int rowCount = 0;
794     resultSetInsertQuery->GetRowCount(rowCount);
795     EXPECT_EQ(0, rowCount);
796     CheckResultSet(valuesBucket, resultSetInsertQuery, "abnormal_calllog_Update_test_1700");
797     ClearCallLog();
798 }
799 
800 /*
801  * @tc.number  abnormal_calllog_Update_test_1800
802  * @tc.name    Update all call records and pass in a non-existent field
803  * @tc.desc    Updated ability to call record
804  * @tc.level   Level1
805  * @tc.size    MediumTest
806  * @tc.type    Function
807  */
HWTEST_F(CalllogAbilityTest, abnormal_calllog_Update_test_1800, testing::ext::TestSize.Level1)808 HWTEST_F(CalllogAbilityTest, abnormal_calllog_Update_test_1800, testing::ext::TestSize.Level1)
809 {
810     HILOG_INFO("--- abnormal_calllog_Update_test_1800 is starting! ---");
811     std::vector<std::string> columns;
812     OHOS::DataShare::DataShareValuesBucket valuesBucketOne;
813     RandomNumberUtils randomNumberUtils;
814     std::string phoneNumber = randomNumberUtils.Generating(10);
815     valuesBucketOne.Put("phone_number", phoneNumber);
816     valuesBucketOne.Put("ring_duration", 998);
817     int rawIdOne = CalllogInsertValues(valuesBucketOne);
818     EXPECT_GT(rawIdOne, 0);
819 
820     OHOS::DataShare::DataShareValuesBucket valuesBucketTwo;
821     std::string phoneNumber_test = randomNumberUtils.Generating(12);
822     valuesBucketTwo.Put("phone_number", phoneNumber_test);
823     valuesBucketTwo.Put("ring_duration", 999);
824     int rawIdTwo = CalllogInsertValues(valuesBucketTwo);
825     EXPECT_GT(rawIdTwo, 0);
826 
827     columns.push_back("phone_number");
828     columns.push_back("ring_duration");
829 
830     OHOS::DataShare::DataShareValuesBucket updateValues;
831     updateValues.Put("phone_number", phoneNumber);
832     updateValues.Put("ring_duration", 888);
833     OHOS::DataShare::DataSharePredicates predicates;
834     predicates.GreaterThan("id", "0");
835     predicates.And();
836     predicates.EqualTo("ring_duration_shs", "999");
837     int updateCode = CalllogUpdate(updateValues, predicates);
838     EXPECT_EQ(-1, updateCode);
839 
840     // query insert data
841     OHOS::DataShare::DataSharePredicates predicates2;
842     predicates2.EqualTo("id", std::to_string(rawIdOne));
843     predicates2.Or();
844     predicates2.EqualTo("id", std::to_string(rawIdTwo));
845     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetInsertQuery = CalllogQuery(columns, predicates2);
846 
847     // resultSet count 0, update failed will delete the calllog
848     int rowCount = 0;
849     resultSetInsertQuery->GetRowCount(rowCount);
850     EXPECT_EQ(0, rowCount);
851     std::vector<OHOS::DataShare::DataShareValuesBucket> listValue;
852     listValue.push_back(valuesBucketOne);
853     listValue.push_back(valuesBucketTwo);
854     CheckResultSetList(listValue, resultSetInsertQuery, "abnormal_calllog_Update_test_1800");
855     ClearCallLog();
856 }
857 
858 /*
859  * @tc.number  abnormal_calllog_Query_test_1900
860  * @tc.name    When querying the call record, a non-existent data is passed in
861  * @tc.desc    Exception use case
862  * @tc.level   Level1
863  * @tc.size    MediumTest
864  * @tc.type    Function
865  */
HWTEST_F(CalllogAbilityTest, abnormal_calllog_Query_test_1900, testing::ext::TestSize.Level1)866 HWTEST_F(CalllogAbilityTest, abnormal_calllog_Query_test_1900, testing::ext::TestSize.Level1)
867 {
868     HILOG_INFO("-----abnormal_calllog_Query_test_1900 is starting!-----");
869     std::vector<std::string> columns;
870     columns.push_back("id");
871     columns.push_back("phone_number");
872     OHOS::DataShare::DataSharePredicates predicates;
873     predicates.EqualTo("id", "100000000");
874     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates);
875     // resultSet count
876     int rowCount = 0;
877     resultSet->GetRowCount(rowCount);
878     EXPECT_EQ(0, rowCount);
879     resultSet->Close();
880     ClearCallLog();
881 }
882 
883 /*
884  * @tc.number  abnormal_calllog_Query_test_2000
885  * @tc.name    An incorrect table name was passed in when querying the call record
886  * @tc.desc    Exception use case
887  * @tc.level   Level1
888  * @tc.size    MediumTest
889  * @tc.type    Function
890  */
HWTEST_F(CalllogAbilityTest, abnormal_calllog_Query_test_2000, testing::ext::TestSize.Level1)891 HWTEST_F(CalllogAbilityTest, abnormal_calllog_Query_test_2000, testing::ext::TestSize.Level1)
892 {
893     HILOG_INFO("-----abnormal_calllog_Query_test_2000 is starting!-----");
894     OHOS::Uri uriCalllogs(CallLogUri::ERROR_URI);
895     std::vector<std::string> columns;
896     columns.push_back("id");
897     columns.push_back("phone_number");
898     OHOS::DataShare::DataSharePredicates predicates;
899     predicates.GreaterThan("id", "0");
900     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
901         calllogAbility.Query(uriCalllogs, predicates, columns);
902     EXPECT_EQ(resultSet, nullptr);
903     ClearCallLog();
904 }
905 
906 /*
907  * @tc.number  abnormal_calllog_Query_test_2100
908  * @tc.name    When querying the call record according to the combination conditions,
909  *             the wrong field name and nonexistent data are passed in
910  * @tc.desc    Exception use case
911  * @tc.level   Level1
912  * @tc.size    MediumTest
913  * @tc.type    Function
914  */
HWTEST_F(CalllogAbilityTest, abnormal_calllog_Query_test_2100, testing::ext::TestSize.Level1)915 HWTEST_F(CalllogAbilityTest, abnormal_calllog_Query_test_2100, testing::ext::TestSize.Level1)
916 {
917     HILOG_INFO("-----abnormal_calllog_Query_test_2100 is starting!-----");
918 
919     OHOS::Uri uriCalllog(CallLogUri::CALL_LOG);
920     std::vector<std::string> columns;
921     columns.push_back("id");
922     columns.push_back("phone_number");
923     OHOS::DataShare::DataSharePredicates predicates;
924     predicates.GreaterThan("ids", "0");
925     predicates.And();
926     predicates.LessThan("id", "20");
927     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet =
928         calllogAbility.Query(uriCalllog, predicates, columns);
929     // resultSet count
930     int rowCount = -1;
931     resultSet->GetRowCount(rowCount);
932     EXPECT_EQ(-1, rowCount);
933     resultSet->Close();
934     ClearCallLog();
935 }
936 
937 /*
938  * @tc.number  abnormal_calllog_Query_test_2200
939  * @tc.name    An error field is passed in when querying all call records
940  * @tc.desc    Exception use case
941  * @tc.level   Level1
942  * @tc.size    MediumTest
943  * @tc.type    Function
944  */
HWTEST_F(CalllogAbilityTest, abnormal_calllog_Query_test_2200, testing::ext::TestSize.Level1)945 HWTEST_F(CalllogAbilityTest, abnormal_calllog_Query_test_2200, testing::ext::TestSize.Level1)
946 {
947     HILOG_INFO("-----abnormal_calllog_Query_test_2200 is starting!-----");
948     OHOS::Uri uriCalllog(CallLogUri::CALL_LOG);
949     OHOS::DataShare::DataSharePredicates predicates;
950     predicates.GreaterThan("id", "0");
951 
952     int deleteCode = calllogAbility.Delete(uriCalllog, predicates);
953     EXPECT_EQ(deleteCode, 0);
954     std::vector<std::string> columns;
955     columns.push_back("id");
956     columns.push_back("phone_numbers");
957     OHOS::DataShare::DataSharePredicates predicates2;
958     predicates2.GreaterThan("id", "0");
959     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates2);
960     EXPECT_NE(resultSet, nullptr);
961     ClearCallLog();
962 }
963 
964 /*
965  * @tc.number  abnormal_calllog_Delete_test_2300
966  * @tc.name    An error field is passed in when deleting a single call record
967  * @tc.desc    Added ability to call record
968  * @tc.level   Level1
969  * @tc.size    MediumTest
970  * @tc.type    Function
971  */
HWTEST_F(CalllogAbilityTest, abnormal_calllog_Delete_test_2300, testing::ext::TestSize.Level1)972 HWTEST_F(CalllogAbilityTest, abnormal_calllog_Delete_test_2300, testing::ext::TestSize.Level1)
973 {
974     HILOG_INFO("-----abnormal_calllog_Delete_test_2300 is starting!-----");
975     std::vector<std::string> columns;
976     GetAllValuesColumn(columns);
977     int columnsSize = 27;
978     OHOS::DataShare::DataShareValuesBucket valuesBucket = GetCallLogValues(0, columnsSize, columns);
979     int rawId = CalllogInsertValues(valuesBucket);
980     EXPECT_GT(rawId, 0);
981     OHOS::DataShare::DataSharePredicates predicates;
982     predicates.EqualTo("id", std::to_string(rawId));
983     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates);
984     int rowCount = 0;
985     resultSet->GetRowCount(rowCount);
986     EXPECT_EQ(1, rowCount);
987     CheckResultSet(valuesBucket, resultSet, "abnormal_calllog_Delete_test_2300");
988     OHOS::DataShare::DataSharePredicates predicates2;
989     predicates2.EqualTo("ids", std::to_string(rawId));
990     // test end delete data
991     int deleteCode = CalllogDelete(predicates2);
992     EXPECT_EQ(deleteCode, -1);
993 
994     OHOS::DataShare::DataSharePredicates predicates3;
995     predicates3.EqualTo("id", std::to_string(rawId));
996     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetDelete = CalllogQuery(columns, predicates3);
997     // resultSet count 1
998     int rowCountDelete = 0;
999     resultSetDelete->GetRowCount(rowCountDelete);
1000     EXPECT_EQ(1, rowCountDelete);
1001     CheckResultSet(valuesBucket, resultSetDelete, "abnormal_calllog_Delete_test_2300");
1002     ClearCallLog();
1003 }
1004 
1005 /*
1006  * @tc.number  abnormal_calllog_BatchInsert_test_2400
1007  * @tc.name    Batch call records are added and several of them fail. See the processing logic
1008  * @tc.desc    Exception use case
1009  * @tc.level   Level1
1010  * @tc.size    MediumTest
1011  * @tc.type    Function
1012  */
HWTEST_F(CalllogAbilityTest, abnormal_calllog_BatchInsert_test_2400, testing::ext::TestSize.Level1)1013 HWTEST_F(CalllogAbilityTest, abnormal_calllog_BatchInsert_test_2400, testing::ext::TestSize.Level1)
1014 {
1015     OHOS::DataShare::DataSharePredicates predicates;
1016     predicates.GreaterThan("id", "0");
1017     int deleteCode = CalllogDelete(predicates);
1018     EXPECT_EQ(deleteCode, 0);
1019     HILOG_INFO("--- abnormal_calllog_BatchInsert_test_2400 is starting! ---");
1020 
1021     OHOS::Uri uriData(CallLogUri::CALL_LOG);
1022     OHOS::DataShare::DataShareValuesBucket calllogValues;
1023     std::vector<OHOS::DataShare::DataShareValuesBucket> listAddBluk;
1024     int batchInserCode = 0;
1025     for (int i = 0; i < 10; i++) {
1026         listAddBluk.clear();
1027         for (int j = 10 * i + 1; j <= 10 * (i + 1); j++) {
1028             calllogValues.Clear();
1029             if (j == 14 || j == 27 || j == 57) {
1030                 calllogValues.Put("phone_numbers", std::to_string(j));
1031             } else {
1032                 calllogValues.Put("phone_number", std::to_string(j));
1033             }
1034             listAddBluk.push_back(calllogValues);
1035         }
1036         batchInserCode = calllogAbility.BatchInsert(uriData, listAddBluk);
1037         HILOG_INFO("abnormal_calllog_BatchInsert_test_2400 : batchInserCode = %{public}d", batchInserCode);
1038         if (batchInserCode == 0) {
1039             HILOG_INFO("abnormal_calllog_BatchInsert_test_2400 batch insert success!");
1040             EXPECT_EQ(batchInserCode, 0);
1041         } else {
1042             HILOG_INFO("abnormal_calllog_BatchInsert_test_2400 batch insert fail!");
1043             EXPECT_EQ(batchInserCode, -1);
1044         }
1045     }
1046     ClearCallLog();
1047 }
1048 
1049 /*
1050  * @tc.number  abnormal_calllog_BatchInsert_test_2500
1051  * @tc.name    Add 1000 pieces of data in batch to make article 500 fail. Check the subsequent processing logic
1052  * @tc.desc    Exception use case
1053  * @tc.level   Level1
1054  * @tc.size    MediumTest
1055  * @tc.type    Function
1056  */
HWTEST_F(CalllogAbilityTest, abnormal_calllog_BatchInsert_test_2500, testing::ext::TestSize.Level1)1057 HWTEST_F(CalllogAbilityTest, abnormal_calllog_BatchInsert_test_2500, testing::ext::TestSize.Level1)
1058 {
1059     HILOG_INFO("--- abnormal_calllog_BatchInsert_test_2500 is starting! ---");
1060 
1061     OHOS::Uri uriData(CallLogUri::CALL_LOG);
1062     OHOS::DataShare::DataShareValuesBucket calllogValues;
1063     std::vector<OHOS::DataShare::DataShareValuesBucket> listAddBluk;
1064     int batchInserCode = 0;
1065     for (int i = 0; i < 1000; i++) {
1066         calllogValues.Clear();
1067         if (i == 500) {
1068             calllogValues.Put("phone_numbers", std::to_string(i + 1));
1069         } else {
1070             calllogValues.Put("phone_number", std::to_string(i + 1));
1071         }
1072         listAddBluk.push_back(calllogValues);
1073     }
1074     batchInserCode = calllogAbility.BatchInsert(uriData, listAddBluk);
1075     if (batchInserCode == 0) {
1076         HILOG_INFO("abnormal_calllog_BatchInsert_test_2500 batch insert success!");
1077         EXPECT_EQ(batchInserCode, 0);
1078     } else {
1079         HILOG_INFO("abnormal_calllog_BatchInsert_test_2500 batch insert fail!");
1080         EXPECT_EQ(batchInserCode, -1);
1081     }
1082     ClearCallLog();
1083 }
1084 
1085 /*
1086  * @tc.number  abnormal_calllog_delete_test_2600
1087  * @tc.name    Delete call record data in batch, and several of them fail. Check the processing logic
1088  * @tc.desc    Exception use case
1089  * @tc.level   Level1
1090  * @tc.size    MediumTest
1091  * @tc.type    Function
1092  */
HWTEST_F(CalllogAbilityTest, abnormal_calllog_delete_test_2600, testing::ext::TestSize.Level1)1093 HWTEST_F(CalllogAbilityTest, abnormal_calllog_delete_test_2600, testing::ext::TestSize.Level1)
1094 {
1095     HILOG_INFO("--- abnormal_calllog_delete_test_2600 is starting! ---");
1096 
1097     OHOS::Uri errorUriCalllogs(CallLogUri::ERROR_URI);
1098     OHOS::DataShare::DataShareValuesBucket valuesBucket;
1099     RandomNumberUtils randomNumberUtils;
1100     std::string phoneNumber = randomNumberUtils.Generating(10);
1101     valuesBucket.Put("phone_number", phoneNumber);
1102     int calllogIdOne = CalllogInsertValues(valuesBucket);
1103     EXPECT_GT(calllogIdOne, 0);
1104     OHOS::DataShare::DataShareValuesBucket valuesBucketTwo;
1105     valuesBucketTwo.Put("phone_number", phoneNumber);
1106     int calllogIdTwo = CalllogInsertValues(valuesBucketTwo);
1107     EXPECT_GT(calllogIdTwo, 0);
1108 
1109     OHOS::DataShare::DataSharePredicates predicates;
1110     predicates.EqualTo("ids", std::to_string(calllogIdOne));
1111     int deleteCode = CalllogDelete(predicates);
1112     EXPECT_EQ(deleteCode, -1);
1113     std::vector<std::string> columns;
1114     columns.push_back("phone_number");
1115     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetOne = CalllogQuery(columns, predicates);
1116     int rowCountOne = 0;
1117     resultSetOne->GetRowCount(rowCountOne);
1118     EXPECT_EQ(-1, rowCountOne);
1119 
1120     CheckResultSet(valuesBucket, resultSetOne, "abnormal_calllog_delete_test_2600");
1121     OHOS::DataShare::DataSharePredicates predicates2;
1122     predicates2.EqualTo("id", std::to_string(calllogIdTwo));
1123     deleteCode = calllogAbility.Delete(errorUriCalllogs, predicates2);
1124     EXPECT_EQ(deleteCode, -1);
1125     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetTwo = CalllogQuery(columns, predicates2);
1126     int rowCountTwo = 0;
1127     resultSetTwo->GetRowCount(rowCountTwo);
1128     EXPECT_EQ(1, rowCountTwo);
1129     resultSetTwo->Close();
1130     ClearCallLog();
1131 }
1132 
1133 /*
1134  * @tc.number  abnormal_calllog_Update_test_2700
1135  * @tc.name    When batch call record is modified, the wrong field or table name is passed in
1136  * @tc.desc    Exception use case
1137  * @tc.level   Level1
1138  * @tc.size    MediumTest
1139  * @tc.type    Function
1140  */
HWTEST_F(CalllogAbilityTest, abnormal_calllog_Update_test_2700, testing::ext::TestSize.Level1)1141 HWTEST_F(CalllogAbilityTest, abnormal_calllog_Update_test_2700, testing::ext::TestSize.Level1)
1142 {
1143     HILOG_INFO("--- abnormal_calllog_Update_test_2700 is starting! ---");
1144 
1145     OHOS::Uri errorUri(CallLogUri::ERROR_URI);
1146     RandomNumberUtils randomNumberUtils;
1147     std::string phoneNumber = randomNumberUtils.Generating(10);
1148     int64_t calllogIdOne = CalllogInsert(phoneNumber);
1149     EXPECT_GT(calllogIdOne, 0);
1150     int64_t calllogIdTwo = CalllogInsert(phoneNumber);
1151     EXPECT_GT(calllogIdTwo, 0);
1152 
1153     OHOS::DataShare::DataShareValuesBucket updateCalllogValues;
1154     std::string phoneNumber_test = randomNumberUtils.Generating(6);
1155     updateCalllogValues.Put("phone_number", phoneNumber_test);
1156     OHOS::DataShare::DataSharePredicates predicates;
1157     predicates.EqualTo("ids", std::to_string(calllogIdOne));
1158     int updateCode = CalllogUpdate(updateCalllogValues, predicates);
1159     EXPECT_EQ(updateCode, -1);
1160     std::vector<std::string> columns;
1161     columns.push_back("phone_number");
1162     OHOS::DataShare::DataSharePredicates predicates2;
1163     predicates2.EqualTo("phone_number", phoneNumber_test);
1164     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetOne = CalllogQuery(columns, predicates2);
1165     int rowCountOne = 0;
1166     resultSetOne->GetRowCount(rowCountOne);
1167     EXPECT_EQ(0, rowCountOne);
1168 
1169     resultSetOne->Close();
1170     updateCalllogValues.Clear();
1171     updateCalllogValues.Put("phone_number", phoneNumber_test);
1172     OHOS::DataShare::DataSharePredicates predicates3;
1173     predicates3.EqualTo("id", std::to_string(calllogIdTwo));
1174     updateCode = calllogAbility.Update(errorUri, predicates3, updateCalllogValues);
1175     EXPECT_EQ(updateCode, -1);
1176 
1177     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSetTwo = CalllogQuery(columns, predicates3);
1178     int rowCountTwo = 0;
1179     resultSetTwo->GetRowCount(rowCountOne);
1180     EXPECT_EQ(0, rowCountTwo);
1181     OHOS::DataShare::DataShareValuesBucket oldValue;
1182     oldValue.Put("phone_number", phoneNumber);
1183     CheckResultSet(oldValue, resultSetTwo, "abnormal_calllog_Update_test_2700");
1184     ClearCallLog();
1185 }
1186 
1187 /*
1188  * @tc.number  calllog_async_insert_test_2800
1189  * @tc.name    Add callLog async
1190  * @tc.desc    Ability to join or add calllog
1191  * @tc.level   Level1
1192  * @tc.size    MediumTest
1193  * @tc.type    Function
1194  */
HWTEST_F(CalllogAbilityTest, calllog_async_insert_test_2800, testing::ext::TestSize.Level1)1195 HWTEST_F(CalllogAbilityTest, calllog_async_insert_test_2800, testing::ext::TestSize.Level1)
1196 {
1197     HILOG_INFO("--- calllog_async_insert_test_2800 is staring! ---");
1198     std::map<int, OHOS::DataShare::DataShareValuesBucket> result;
1199     std::vector<CallLogAsync *> callLogAsyncVector;
1200     int threadNum = 6;
1201     for (int i = 0; i < threadNum; ++i) {
1202         OHOS::DataShare::DataShareValuesBucket values;
1203         std::string name;
1204         name.append("asyncTest");
1205         name.append(std::to_string(i));
1206         values.Put("display_name", name);
1207         CallLogAsync *contactAsync = new CallLogAsync(values, result);
1208         std::thread asyncThread(&CallLogAsync::Insert, contactAsync);
1209         callLogAsyncVector.push_back(contactAsync);
1210         asyncThread.detach();
1211     }
1212     std::chrono::milliseconds dura(Time::ASYNC_SLEEP_TIME);
1213     std::this_thread::sleep_for(dura);
1214     std::vector<std::string> columns;
1215     columns.push_back("display_name");
1216     std::map<int, OHOS::DataShare::DataShareValuesBucket>::iterator it;
1217     for (it = result.begin(); it != result.end(); it++) {
1218         OHOS::DataShare::DataSharePredicates predicates;
1219         predicates.EqualTo("id", std::to_string(it->first));
1220         std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates);
1221         CheckResultSet(it->second, resultSet, "calllog_async_insert_test_2800");
1222     }
1223     for (int i = 0; i < threadNum; ++i) {
1224         delete callLogAsyncVector[i];
1225     }
1226     ClearCallLog();
1227 }
1228 
1229 /*
1230  * @tc.number  calllog_async_update_test_2900
1231  * @tc.name    update calllog async
1232  * @tc.desc    Ability to join or update calllog
1233  * @tc.level   Level1
1234  * @tc.size    MediumTest
1235  * @tc.type    Function
1236  */
HWTEST_F(CalllogAbilityTest, calllog_async_update_test_2900, testing::ext::TestSize.Level1)1237 HWTEST_F(CalllogAbilityTest, calllog_async_update_test_2900, testing::ext::TestSize.Level1)
1238 {
1239     HILOG_INFO("--- calllog_async_update_test_2900 is staring! ---");
1240     OHOS::DataShare::DataShareValuesBucket callValues;
1241     std::vector<int64_t> callLogId;
1242     callLogId.push_back(CalllogInsertValue("async_update1", callValues));
1243     callValues.Clear();
1244     callLogId.push_back(CalllogInsertValue("async_update2", callValues));
1245     callValues.Clear();
1246     callLogId.push_back(CalllogInsertValue("async_update3", callValues));
1247     callValues.Clear();
1248     callLogId.push_back(CalllogInsertValue("async_update4", callValues));
1249     callValues.Clear();
1250     callLogId.push_back(CalllogInsertValue("async_update5", callValues));
1251     callValues.Clear();
1252     callLogId.push_back(CalllogInsertValue("async_update6", callValues));
1253     callValues.Clear();
1254     std::vector<OHOS::DataShare::DataShareValuesBucket> upDateValues;
1255     OHOS::DataShare::DataSharePredicates queryPredicates;
1256     std::vector<CallLogAsync *> callLogAsyncVector;
1257     int size = callLogId.size();
1258     for (int i = 0; i < size; ++i) {
1259         OHOS::DataShare::DataShareValuesBucket values;
1260         std::string name;
1261         name.append("asyncTest");
1262         values.Put("display_name", name);
1263         upDateValues.push_back(values);
1264         int id = callLogId[i];
1265         CallLogAsync *contactAsync = new CallLogAsync(values, id);
1266         callLogAsyncVector.push_back(contactAsync);
1267         std::thread asyncThread(&CallLogAsync::Update, contactAsync);
1268         asyncThread.detach();
1269         queryPredicates.EqualTo("id", std::to_string(callLogId[i]));
1270         if (i < size - 1) {
1271             queryPredicates.Or();
1272         }
1273     }
1274     std::chrono::milliseconds dura(Time::ASYNC_SLEEP_TIME);
1275     std::this_thread::sleep_for(dura);
1276     std::vector<std::string> columns;
1277     columns.push_back("display_name");
1278     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, queryPredicates);
1279     CheckResultSetList(upDateValues, resultSet, "calllog_async_update_test_2900");
1280     for (int i = 0; i < size; ++i) {
1281         delete callLogAsyncVector[i];
1282     }
1283     ClearCallLog();
1284 }
1285 
1286 /*
1287  * @tc.number  calllog_async_query_test_3000
1288  * @tc.name    query calllog async
1289  * @tc.desc    Ability to join or query
1290  * @tc.level   Level1
1291  * @tc.size    MediumTest
1292  * @tc.type    Function
1293  */
HWTEST_F(CalllogAbilityTest, calllog_async_query_test_3000, testing::ext::TestSize.Level1)1294 HWTEST_F(CalllogAbilityTest, calllog_async_query_test_3000, testing::ext::TestSize.Level1)
1295 {
1296     HILOG_INFO("--- calllog_async_query_test_3000 is staring! ---");
1297     OHOS::DataShare::DataShareValuesBucket callLogValues;
1298     std::vector<int64_t> callLogId;
1299     callLogId.push_back(CalllogInsertValue("async_query1", callLogValues));
1300     callLogValues.Clear();
1301     callLogId.push_back(CalllogInsertValue("async_query2", callLogValues));
1302     callLogValues.Clear();
1303     callLogId.push_back(CalllogInsertValue("async_query3", callLogValues));
1304     callLogValues.Clear();
1305     callLogId.push_back(CalllogInsertValue("async_query4", callLogValues));
1306     callLogValues.Clear();
1307     callLogId.push_back(CalllogInsertValue("async_query5", callLogValues));
1308     callLogValues.Clear();
1309     callLogId.push_back(CalllogInsertValue("async_query6", callLogValues));
1310     callLogValues.Clear();
1311     std::vector<CallLogAsync *> callLogAsyncVector;
1312     std::vector<std::shared_ptr<OHOS::DataShare::DataShareResultSet>> resultSetVector;
1313     int threadNum = 6;
1314     for (int i = 0; i < threadNum; ++i) {
1315         CallLogAsync *contactAsync = new CallLogAsync(resultSetVector, callLogId);
1316         callLogAsyncVector.push_back(contactAsync);
1317         std::thread asyncThread(&CallLogAsync::Query, contactAsync);
1318         asyncThread.detach();
1319     }
1320     int queryCount = 6;
1321     int size = resultSetVector.size();
1322     for (int i = 0; i < size; ++i) {
1323         int rowCount = 0;
1324         resultSetVector[i]->GetRowCount(rowCount);
1325         EXPECT_EQ(queryCount, rowCount);
1326         resultSetVector[i]->Close();
1327     }
1328     for (int i = 0; i < size; ++i) {
1329         delete callLogAsyncVector[i];
1330     }
1331     ClearCallLog();
1332 }
1333 
1334 /*
1335  * @tc.number  contact_async_update_test_7300
1336  * @tc.name    delete calllog async
1337  * @tc.desc    Ability to join or delete calllog
1338  * @tc.level   Level1
1339  * @tc.size    MediumTest
1340  * @tc.type    Function
1341  */
HWTEST_F(CalllogAbilityTest, calllog_async_delete_test_3100, testing::ext::TestSize.Level1)1342 HWTEST_F(CalllogAbilityTest, calllog_async_delete_test_3100, testing::ext::TestSize.Level1)
1343 {
1344     HILOG_INFO("--- calllog_async_delete_test_3100 is staring! ---");
1345     OHOS::DataShare::DataShareValuesBucket callLogValues;
1346     std::vector<int64_t> callLogId;
1347     callLogId.push_back(CalllogInsertValue("async_update1", callLogValues));
1348     callLogValues.Clear();
1349     callLogId.push_back(CalllogInsertValue("async_update2", callLogValues));
1350     callLogValues.Clear();
1351     callLogId.push_back(CalllogInsertValue("async_update3", callLogValues));
1352     callLogValues.Clear();
1353     callLogId.push_back(CalllogInsertValue("async_update4", callLogValues));
1354     callLogValues.Clear();
1355     callLogId.push_back(CalllogInsertValue("async_update5", callLogValues));
1356     callLogValues.Clear();
1357     callLogId.push_back(CalllogInsertValue("async_update6", callLogValues));
1358     callLogValues.Clear();
1359     int size = callLogId.size();
1360     OHOS::DataShare::DataSharePredicates predicates;
1361     predicates.BeginWrap();
1362     std::vector<CallLogAsync *> callLogAsyncVector;
1363     for (int i = 0; i < size; ++i) {
1364         int id = callLogId[i];
1365         CallLogAsync *contactAsync = new CallLogAsync(id);
1366         callLogAsyncVector.push_back(contactAsync);
1367         std::thread asyncThread(&CallLogAsync::Delete, contactAsync);
1368         asyncThread.detach();
1369         predicates.EqualTo("id", std::to_string(id));
1370         if (i < size - 1) {
1371             predicates.Or();
1372         }
1373     }
1374     predicates.EndWrap();
1375     std::chrono::milliseconds dura(Time::ASYNC_SLEEP_TIME);
1376     std::this_thread::sleep_for(dura);
1377     std::vector<std::string> columns;
1378     std::shared_ptr<OHOS::DataShare::DataShareResultSet> resultSet = CalllogQuery(columns, predicates);
1379     int rowCount = 0;
1380     resultSet->GetRowCount(rowCount);
1381     EXPECT_EQ(0, rowCount);
1382     resultSet->Close();
1383     for (int i = 0; i < size; ++i) {
1384         delete callLogAsyncVector[i];
1385     }
1386     ClearCallLog();
1387 }
1388 } // namespace Test
1389 } // namespace Contacts
1390