/* * Copyright (c) 2021-2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "calllogability_test.h" #include "data_ability_operation_builder.h" #include "random_number_utils.h" using namespace OHOS::Contacts; namespace Contacts { namespace Test { CalllogAbilityTest::CalllogAbilityTest() { } CalllogAbilityTest::~CalllogAbilityTest() { } int64_t CalllogAbilityTest::CalllogInsert(std::string phoneNumber) { OHOS::Uri uriCalllog(CallLogUri::CALL_LOG); OHOS::DataShare::DataShareValuesBucket calllogValues; calllogValues.Put("phone_number", phoneNumber); int64_t code = calllogAbility.Insert(uriCalllog, calllogValues); calllogValues.Clear(); return code; } int CalllogAbilityTest::CalllogUpdate( OHOS::DataShare::DataShareValuesBucket updateValues, OHOS::DataShare::DataSharePredicates predicates) { OHOS::Uri uriCalllog(CallLogUri::CALL_LOG); int code = calllogAbility.Update(uriCalllog, predicates, updateValues); return code; } int CalllogAbilityTest::CalllogDelete(OHOS::DataShare::DataSharePredicates predicates) { OHOS::Uri uriCalllog(CallLogUri::CALL_LOG); int code = calllogAbility.Delete(uriCalllog, predicates); return code; } std::shared_ptr CalllogAbilityTest::CalllogQuery( std::vector columns, OHOS::DataShare::DataSharePredicates predicates) { OHOS::Uri uriCalllog(CallLogUri::CALL_LOG); std::shared_ptr resultSet = calllogAbility.Query(uriCalllog, predicates, columns); return resultSet; } int64_t CalllogAbilityTest::CalllogInsertValues(OHOS::DataShare::DataShareValuesBucket &values) { OHOS::Uri uriCalllog(CallLogUri::CALL_LOG); int64_t code = calllogAbility.Insert(uriCalllog, values); return code; } int64_t CalllogAbilityTest::CalllogInsertValue(std::string displayName, OHOS::DataShare::DataShareValuesBucket &values) { OHOS::Uri uriCalllog(CallLogUri::CALL_LOG); values.Put("display_name", displayName); int64_t code = calllogAbility.Insert(uriCalllog, values); return code; } void CalllogAbilityTest::GetAllValuesColumn(std::vector &column) { column.push_back("slot_id"); column.push_back("phone_number"); column.push_back("display_name"); column.push_back("call_direction"); column.push_back("voicemail_uri"); column.push_back("sim_type"); column.push_back("is_hd"); column.push_back("is_read"); column.push_back("ring_duration"); column.push_back("talk_duration"); column.push_back("format_number"); column.push_back("quicksearch_key"); column.push_back("number_type"); column.push_back("number_type_name"); column.push_back("begin_time"); column.push_back("end_time"); column.push_back("answer_state"); column.push_back("create_time"); column.push_back("number_location"); column.push_back("photo_id"); column.push_back("photo_uri"); column.push_back("country_iso_code"); column.push_back("extra1"); column.push_back("extra2"); column.push_back("extra3"); column.push_back("extra4"); column.push_back("extra5"); column.push_back("extra6"); } /** * @brief get ValuesBucket * @params columnsStart column start index * @params columnsEnd column end index * @return ValuesBucket */ OHOS::DataShare::DataShareValuesBucket CalllogAbilityTest::GetCallLogValues( int columnsStart, int columnsEnd, std::vector &columns) { std::string callLogTestStringValue = std::to_string(ContactsRand()); int number = 6; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(number); OHOS::DataShare::DataShareValuesBucket valuesBucket; valuesBucket.Put("slot_id", ContactsRand()); valuesBucket.Put("phone_number", phoneNumber + callLogTestStringValue); valuesBucket.Put("display_name", "name"); valuesBucket.Put("call_direction", ContactsRand()); valuesBucket.Put("voicemail_uri", "uri::voicemail_uri" + callLogTestStringValue); valuesBucket.Put("sim_type", ContactsRand()); valuesBucket.Put("is_hd", ContactsRand()); valuesBucket.Put("is_read", ContactsRand()); valuesBucket.Put("ring_duration", ContactsRand()); valuesBucket.Put("talk_duration", ContactsRand()); valuesBucket.Put("format_number", "154 121" + callLogTestStringValue); valuesBucket.Put("quicksearch_key", "1"); valuesBucket.Put("number_type", ContactsRand()); valuesBucket.Put("number_type_name", "numberType" + callLogTestStringValue); valuesBucket.Put("begin_time", ContactsRand()); valuesBucket.Put("end_time", ContactsRand()); valuesBucket.Put("answer_state", ContactsRand()); valuesBucket.Put("create_time", ContactsRand()); valuesBucket.Put("number_location", "location" + callLogTestStringValue); valuesBucket.Put("photo_id", ContactsRand()); valuesBucket.Put("photo_uri", "uri::photo_uri" + callLogTestStringValue); valuesBucket.Put("country_iso_code", ContactsRand()); valuesBucket.Put("extra1", "extra1" + callLogTestStringValue); valuesBucket.Put("extra2", "extra2" + callLogTestStringValue); valuesBucket.Put("extra3", "extra3" + callLogTestStringValue); valuesBucket.Put("extra4", "extra4" + callLogTestStringValue); valuesBucket.Put("extra5", "extra5" + callLogTestStringValue); valuesBucket.Put("extra6", "extra6" + callLogTestStringValue); std::vector columnsTemp; GetAllValuesColumn(columnsTemp); int allSize = columnsTemp.size(); for (int i = 0; i < allSize; i++) { if (i >= columnsStart && i < columnsEnd) { columns.push_back(columnsTemp[i]); } else { valuesBucket.Put(columnsTemp[i], ""); } } return valuesBucket; } void CalllogAbilityTest::ClearCallLog() { // clear all callLog data OHOS::DataShare::DataSharePredicates predicates; predicates.GreaterThan("id", "0"); int deleteCode = CalllogDelete(predicates); EXPECT_EQ(deleteCode, 0); } /* * @tc.number calllog_Insert_test_100 * @tc.name Add a single contact data and verify whether the insertion is successful * @tc.desc Added ability to call record * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Insert_test_100, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_Insert_test_100 is starting! ---"); std::vector columns; OHOS::DataShare::DataShareValuesBucket valuesBucket; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(10); valuesBucket.Put("phone_number", phoneNumber); columns.push_back("phone_number"); int rawId = CalllogInsertValues(valuesBucket); EXPECT_GT(rawId, 0); // query insert data OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(rawId)); std::shared_ptr resultSetDeleteQuery = CalllogQuery(columns, predicates); // resultSet count 1 int rowCount = 0; resultSetDeleteQuery->GetRowCount(rowCount); EXPECT_EQ(1, rowCount); CheckResultSet(valuesBucket, resultSetDeleteQuery, "calllog_Insert_test_100"); ClearCallLog(); } /* * @tc.number calllog_Insert_test_200 * @tc.name Add full field data to the callog table and verify that the insertion was successful * @tc.desc Added ability to call record * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Insert_test_200, testing::ext::TestSize.Level1) { HILOG_INFO("-----calllog_Insert_test_200 is starting!-----"); std::vector columns; GetAllValuesColumn(columns); int columnsSize = 27; OHOS::DataShare::DataShareValuesBucket valuesBucket = GetCallLogValues(0, columnsSize, columns); int rawId = CalllogInsertValues(valuesBucket); EXPECT_GT(rawId, 0); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(rawId)); std::shared_ptr resultSet = CalllogQuery(columns, predicates); // resultSet count 1 int rowCount = 0; resultSet->GetRowCount(rowCount); EXPECT_EQ(1, rowCount); CheckResultSet(valuesBucket, resultSet, "calllog_Insert_test_200"); OHOS::DataShare::DataSharePredicates predicates2; predicates2.EqualTo("id", std::to_string(rawId)); // test end delete data int deleteCode = CalllogDelete(predicates2); EXPECT_EQ(deleteCode, 0); ClearCallLog(); } /* * @tc.number calllog_Update_test_300 * @tc.name Update single contact data and verify whether the update is successful * @tc.desc Support single call record update capability * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Update_test_300, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_Update_test_300 is starting! ---"); std::vector columns; columns.push_back("phone_number"); OHOS::DataShare::DataShareValuesBucket valuesBucket; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(12); valuesBucket.Put("phone_number", phoneNumber); int rawId = CalllogInsertValues(valuesBucket); EXPECT_GT(rawId, 0); OHOS::DataShare::DataShareValuesBucket updateValues; std::string phoneNumber_test = randomNumberUtils.Generating(10); updateValues.Put("phone_number", phoneNumber_test); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(rawId)); int updateCode = CalllogUpdate(updateValues, predicates); EXPECT_EQ(0, updateCode); std::shared_ptr resultSetDeleteQuery = CalllogQuery(columns, predicates); // resultSet count 1 int rowCount = 0; resultSetDeleteQuery->GetRowCount(rowCount); EXPECT_EQ(1, rowCount); CheckResultSet(updateValues, resultSetDeleteQuery, "calllog_Update_test_300"); ClearCallLog(); } /* * @tc.number calllog_Update_test_400 * @tc.name Update the data of all fields of callog table and verify whether the update is successful * @tc.desc Support all call log update capability * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Update_test_400, testing::ext::TestSize.Level1) { HILOG_INFO("-----calllog_Update_test_400 is starting!-----"); std::vector columns; GetAllValuesColumn(columns); int columnsSize = 27; OHOS::DataShare::DataShareValuesBucket valuesBucket = GetCallLogValues(0, columnsSize, columns); int rawId = CalllogInsertValues(valuesBucket); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(rawId)); OHOS::DataShare::DataShareValuesBucket upDateValuesBucket = GetCallLogValues(0, columnsSize, columns); int upDateCode = CalllogUpdate(upDateValuesBucket, predicates); EXPECT_EQ(upDateCode, 0); std::shared_ptr resultSet = CalllogQuery(columns, predicates); int rowCount = 0; resultSet->GetRowCount(rowCount); EXPECT_EQ(1, rowCount); CheckResultSet(upDateValuesBucket, resultSet, "calllog_Update_test_400"); OHOS::DataShare::DataSharePredicates predicates2; predicates2.EqualTo("id", std::to_string(rawId)); // test end delete data int deleteCode = CalllogDelete(predicates2); EXPECT_EQ(deleteCode, 0); ClearCallLog(); } /* * @tc.number calllog_Update_test_500 * @tc.name Update all call records and verify that the update is successful * @tc.desc Support all call log update capability * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Update_test_500, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_Update_test_500 is starting! ---"); OHOS::DataShare::DataShareValuesBucket valuesBucket; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(10); valuesBucket.Put("phone_number", phoneNumber); valuesBucket.Put("display_name", "testName"); CalllogInsertValues(valuesBucket); CalllogInsertValues(valuesBucket); int rawCount = 2; std::vector columns; columns.push_back("ring_duration"); OHOS::DataShare::DataSharePredicates predicates; predicates.GreaterThan("id", "0"); std::shared_ptr resultSetQuery = CalllogQuery(columns, predicates); int rowCurrentCount = 0; resultSetQuery->GetRowCount(rowCurrentCount); resultSetQuery->Close(); EXPECT_EQ(rowCurrentCount, rawCount); // update database current data OHOS::DataShare::DataShareValuesBucket updateValues; updateValues.Put("ring_duration", 500); predicates.GreaterThan("id", "0"); int updateCode = CalllogUpdate(updateValues, predicates); EXPECT_EQ(updateCode, 0); // check update data or dataBase std::shared_ptr resultSetUpDateQuery = CalllogQuery(columns, predicates); int rowUpDateCount = 0; resultSetUpDateQuery->GetRowCount(rowUpDateCount); EXPECT_EQ(rowCurrentCount, rowUpDateCount); std::vector upValues; upValues.push_back(updateValues); upValues.push_back(updateValues); CheckResultSetList(upValues, resultSetUpDateQuery, "calllog_Update_test_500"); ClearCallLog(); } /* * @tc.number calllog_Query_test_600 * @tc.name Add call record data, query the data according to the returned ID and return the query result * @tc.desc Support single call record query capability * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Query_test_600, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_Query_test_600 is starting! ---"); std::vector columns; columns.push_back("phone_number"); columns.push_back("display_name"); columns.push_back("id"); OHOS::DataShare::DataShareValuesBucket valuesBucket; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(10); valuesBucket.Put("phone_number", phoneNumber); valuesBucket.Put("display_name", "testName"); int rawId = CalllogInsertValues(valuesBucket); EXPECT_GT(rawId, 0); // query insert data OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(rawId)); std::shared_ptr resultSetDeleteQuery = CalllogQuery(columns, predicates); // resultSet count 1 int rowCount = 0; resultSetDeleteQuery->GetRowCount(rowCount); EXPECT_EQ(1, rowCount); valuesBucket.Put("id", rawId); CheckResultSet(valuesBucket, resultSetDeleteQuery, "calllog_Query_test_600"); ClearCallLog(); } /* * @tc.number calllog_Query_test_800 * @tc.name Query the call record according to the combination conditions and return the query results * @tc.desc Support combination condition query call record ability * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Query_test_800, testing::ext::TestSize.Level1) { HILOG_INFO("-----calllog_Query_test_800 is starting!-----"); int ringDuration = 9121215; OHOS::DataShare::DataShareValuesBucket valuesBucket; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(10); valuesBucket.Put("phone_number", phoneNumber); valuesBucket.Put("display_name", "testName"); valuesBucket.Put("ring_duration", ringDuration); int rawId = CalllogInsertValues(valuesBucket); EXPECT_GT(rawId, 0); std::vector columns; columns.push_back("phone_number"); columns.push_back("display_name"); columns.push_back("ring_duration"); columns.push_back("id"); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(rawId)); predicates.And(); predicates.EqualTo("ring_duration", std::to_string(ringDuration)); std::shared_ptr resultSet = CalllogQuery(columns, predicates); // resultSet count 1 int rowCount = 0; resultSet->GetRowCount(rowCount); EXPECT_EQ(1, rowCount); // add id check valuesBucket.Put("id", rawId); CheckResultSet(valuesBucket, resultSet, "calllog_Query_test_800"); ClearCallLog(); } /* * @tc.number calllog_Query_test_900 * @tc.name Query all call records and return query results * @tc.desc Query all call records * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Query_test_900, testing::ext::TestSize.Level1) { HILOG_INFO("-----calllog_Query_test_900 is starting!-----"); OHOS::DataShare::DataShareValuesBucket valuesBucket; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(14); valuesBucket.Put("phone_number", phoneNumber); valuesBucket.Put("display_name", "testName"); CalllogInsertValues(valuesBucket); CalllogInsertValues(valuesBucket); CalllogInsertValues(valuesBucket); CalllogInsertValues(valuesBucket); std::vector columns; columns.push_back("id"); columns.push_back("phone_number"); OHOS::DataShare::DataSharePredicates predicates; predicates.GreaterThan("id", "0"); std::shared_ptr resultSet = CalllogQuery(columns, predicates); int current = 4; // resultSet count 4 int rowCount = 0; resultSet->GetRowCount(rowCount); EXPECT_EQ(current, rowCount); resultSet->Close(); ClearCallLog(); } /* * @tc.number calllog_Delete_test_1000 * @tc.name Delete a single call record and verify whether the deletion is successful * @tc.desc Call log deletion capability * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Delete_test_1000, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_Delete_test_1000 is starting! ---"); OHOS::DataShare::DataShareValuesBucket valuesBucket; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(10); valuesBucket.Put("phone_number", phoneNumber); std::vector columns; int rawId = CalllogInsertValues(valuesBucket); EXPECT_GT(rawId, 0); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(rawId)); int deleteCode = CalllogDelete(predicates); EXPECT_EQ(deleteCode, 0); std::shared_ptr resultSet = CalllogQuery(columns, predicates); // resultSet count int rowCount = 0; resultSet->GetRowCount(rowCount); EXPECT_EQ(0, rowCount); resultSet->Close(); ClearCallLog(); } /* * @tc.number calllog_Delete_test_1100 * @tc.name Delete a single call record data and verify whether the deletion is successful * @tc.desc Call log deletion capability * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Delete_test_1100, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_Delete_test_1100 is starting! ---"); OHOS::DataShare::DataShareValuesBucket valuesBucket; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(10); valuesBucket.Put("phone_number", phoneNumber); int rawId = CalllogInsertValues(valuesBucket); EXPECT_GT(rawId, 0); OHOS::DataShare::DataShareValuesBucket valuesBucketTwo; std::string phoneNumber_test = randomNumberUtils.Generating(11); valuesBucketTwo.Put("phone_number", phoneNumber_test); int rawIdTwo = CalllogInsertValues(valuesBucketTwo); EXPECT_GT(rawIdTwo, 0); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(rawId)); predicates.Or(); predicates.EqualTo("id", std::to_string(rawIdTwo)); int deleteCode = CalllogDelete(predicates); EXPECT_EQ(deleteCode, 0); std::vector columns; std::shared_ptr resultSet = CalllogQuery(columns, predicates); // resultSet count int rowCount = 0; resultSet->GetRowCount(rowCount); EXPECT_EQ(0, rowCount); resultSet->Close(); ClearCallLog(); } /* * @tc.number calllog_Delete_test_1200 * @tc.name Delete the data of all fields in the callog table and verify whether the deletion is successful * @tc.desc Call log deletion capability * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Delete_test_1200, testing::ext::TestSize.Level1) { HILOG_INFO("-----calllog_Delete_test_1200 is starting!-----"); // insert std::vector columns; GetAllValuesColumn(columns); int columnsSize = 27; OHOS::DataShare::DataShareValuesBucket valuesBucket = GetCallLogValues(0, columnsSize, columns); int rawId = CalllogInsertValues(valuesBucket); EXPECT_GT(rawId, 0); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(rawId)); int deleteCode = CalllogDelete(predicates); EXPECT_EQ(deleteCode, 0); std::shared_ptr resultSetDeleteQuery = CalllogQuery(columns, predicates); int rowCount = 0; resultSetDeleteQuery->GetRowCount(rowCount); EXPECT_EQ(0, rowCount); resultSetDeleteQuery->Close(); ClearCallLog(); } /* * @tc.number calllog_BatchInsert_test_1300 * @tc.name Batch add call record data and verify whether the insertion is successful * @tc.desc Add ability to call records in batches * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_BatchInsert_test_1300, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_BatchInsert_test_1300 is starting!---"); OHOS::DataShare::DataShareValuesBucket valuesBucket; int numberLen = 14; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(numberLen); valuesBucket.Put("phone_number", phoneNumber); valuesBucket.Put("ring_duration", 1000); OHOS::DataShare::DataShareValuesBucket valuesBucketTwo; std::string phoneNumber2 = randomNumberUtils.Generating(numberLen); valuesBucketTwo.Put("phone_number", phoneNumber2); valuesBucketTwo.Put("ring_duration", 1200); OHOS::DataShare::DataShareValuesBucket valuesBucketThree; std::string phoneNumber3 = randomNumberUtils.Generating(numberLen); valuesBucketThree.Put("phone_number", phoneNumber3); valuesBucketThree.Put("ring_duration", 1500); std::vector listAddValuesBucket; listAddValuesBucket.push_back(valuesBucket); listAddValuesBucket.push_back(valuesBucketTwo); listAddValuesBucket.push_back(valuesBucketThree); OHOS::Uri batchInsertUri(CallLogUri::CALL_LOG); int batchInsertCode = calllogAbility.BatchInsert(batchInsertUri, listAddValuesBucket); EXPECT_EQ(batchInsertCode, 0); OHOS::DataShare::DataSharePredicates predicates; std::vector columns; columns.push_back("phone_number"); columns.push_back("ring_duration"); predicates.EqualTo("phone_number", phoneNumber); std::shared_ptr resultSet = CalllogQuery(columns, predicates); int rowCount = 0; resultSet->GetRowCount(rowCount); EXPECT_EQ(1, rowCount); CheckResultSet(valuesBucket, resultSet, "calllog_BatchInsert_test_1300"); OHOS::DataShare::DataSharePredicates predicates2; predicates2.EqualTo("phone_number", phoneNumber2); std::shared_ptr resultSetTwo = CalllogQuery(columns, predicates2); int rowCountTwo = 0; resultSetTwo->GetRowCount(rowCountTwo); EXPECT_EQ(1, rowCountTwo); CheckResultSet(valuesBucketTwo, resultSetTwo, "calllog_BatchInsert_test_1300"); OHOS::DataShare::DataSharePredicates predicates3; predicates3.EqualTo("phone_number", phoneNumber3); std::shared_ptr resultSetThree = CalllogQuery(columns, predicates3); int rowCountThree = 0; resultSetThree->GetRowCount(rowCountThree); EXPECT_EQ(1, rowCountThree); CheckResultSet(valuesBucketThree, resultSetThree, "calllog_BatchInsert_test_1300"); ClearCallLog(); } /* * @tc.number calllog_Delete_test_1400 * @tc.name Delete call record data in batch and verify whether the deletion is successful * @tc.desc delete ability to call records in batches * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Delete_test_1400, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_Delete_test_1400 is starting!---"); OHOS::DataShare::DataShareValuesBucket valuesBucketOne; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(9); valuesBucketOne.Put("phone_number", phoneNumber); valuesBucketOne.Put("ring_duration", 998); int rawIdOne = CalllogInsertValues(valuesBucketOne); EXPECT_GT(rawIdOne, 0); int rawIdTwo = CalllogInsertValues(valuesBucketOne); EXPECT_GT(rawIdTwo, 0); OHOS::DataShare::DataSharePredicates predicates; predicates.GreaterThan("id", "0"); int deleteCode = CalllogDelete(predicates); EXPECT_EQ(deleteCode, 0); std::vector columns; std::shared_ptr resultSetInsertQuery = CalllogQuery(columns, predicates); int rowCount = 0; resultSetInsertQuery->GetRowCount(rowCount); EXPECT_EQ(0, rowCount); ClearCallLog(); } /* * @tc.number calllog_Update_test_1500 * @tc.name Batch update call record data and verify whether the update is successful * @tc.desc update ability to call records in batches * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_Update_test_1500, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_Update_test_1500 is starting!---"); OHOS::DataShare::DataShareValuesBucket valuesBucketOne; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(9); valuesBucketOne.Put("phone_number", phoneNumber); valuesBucketOne.Put("ring_duration", 998); int rawIdOne = CalllogInsertValues(valuesBucketOne); EXPECT_GT(rawIdOne, 0); int rawIdTwo = CalllogInsertValues(valuesBucketOne); EXPECT_GT(rawIdTwo, 0); OHOS::DataShare::DataShareValuesBucket calllogValues; std::string phoneNumber2 = randomNumberUtils.Generating(5); calllogValues.Put("phone_number", phoneNumber2); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(rawIdOne)); predicates.Or(); predicates.EqualTo("id", std::to_string(rawIdTwo)); int updateCode = CalllogUpdate(calllogValues, predicates); EXPECT_EQ(updateCode, 0); std::vector columns; columns.push_back("phone_number"); std::shared_ptr resultSetInsertQuery = CalllogQuery(columns, predicates); int rowCount = 0; resultSetInsertQuery->GetRowCount(rowCount); EXPECT_EQ(2, rowCount); std::vector listValue; listValue.push_back(calllogValues); listValue.push_back(calllogValues); CheckResultSetList(listValue, resultSetInsertQuery, "calllog_Update_test_1500"); ClearCallLog(); } /* * @tc.number abnormal_calllog_Insert_test_1600 * @tc.name When adding individual contact data, a non-existent field is passed in * @tc.desc Exception use case * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, abnormal_calllog_Insert_test_1600, testing::ext::TestSize.Level1) { HILOG_INFO("-----abnormal_calllog_Insert_test_1600 is starting!-----"); OHOS::Uri uriCalllog(CallLogUri::CALL_LOG); OHOS::Uri errorUri(CallLogUri::ERROR_URI); std::vector columns; columns.push_back("phone_number"); RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(6); OHOS::DataShare::DataShareValuesBucket calllogValues; calllogValues.Put("phone_numbers", phoneNumber); int calllogId = calllogAbility.Insert(uriCalllog, calllogValues); EXPECT_EQ(calllogId, -1); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("phone_numbers", phoneNumber); std::shared_ptr resultSet = CalllogQuery(columns, predicates); int rowCount = 0; resultSet->GetRowCount(rowCount); EXPECT_EQ(-1, rowCount); resultSet->Close(); calllogValues.Clear(); calllogValues.Put("phone_number", phoneNumber); calllogId = calllogAbility.Insert(errorUri, calllogValues); EXPECT_EQ(calllogId, -1); calllogValues.Clear(); predicates.EqualTo("phone_number", phoneNumber); std::shared_ptr resultSetUriError = CalllogQuery(columns, predicates); int rowCountUriError = 0; resultSetUriError->GetRowCount(rowCountUriError); EXPECT_EQ(-1, rowCountUriError); resultSetUriError->Close(); ClearCallLog(); } /* * @tc.number abnormal_calllog_Update_test_1700 * @tc.name Update a single call record and pass in non-existent fields * @tc.desc Updated ability to call record * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, abnormal_calllog_Update_test_1700, testing::ext::TestSize.Level1) { HILOG_INFO("--- abnormal_calllog_Update_test_1700 is starting! ---"); std::vector columns; OHOS::DataShare::DataShareValuesBucket valuesBucket; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(10); valuesBucket.Put("phone_number", phoneNumber); valuesBucket.Put("display_name", "abnormal_sigle"); columns.push_back("phone_number"); columns.push_back("display_name"); int rawId = CalllogInsertValues(valuesBucket); EXPECT_GT(rawId, 0); OHOS::DataShare::DataShareValuesBucket updateValues; updateValues.Put("phone_number_sha", phoneNumber); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(rawId)); int updateCode = CalllogUpdate(updateValues, predicates); EXPECT_EQ(-1, updateCode); // query insert data std::shared_ptr resultSetInsertQuery = CalllogQuery(columns, predicates); // resultSet count 0, update failed will delete the calllog int rowCount = 0; resultSetInsertQuery->GetRowCount(rowCount); EXPECT_EQ(0, rowCount); CheckResultSet(valuesBucket, resultSetInsertQuery, "abnormal_calllog_Update_test_1700"); ClearCallLog(); } /* * @tc.number abnormal_calllog_Update_test_1800 * @tc.name Update all call records and pass in a non-existent field * @tc.desc Updated ability to call record * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, abnormal_calllog_Update_test_1800, testing::ext::TestSize.Level1) { HILOG_INFO("--- abnormal_calllog_Update_test_1800 is starting! ---"); std::vector columns; OHOS::DataShare::DataShareValuesBucket valuesBucketOne; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(10); valuesBucketOne.Put("phone_number", phoneNumber); valuesBucketOne.Put("ring_duration", 998); int rawIdOne = CalllogInsertValues(valuesBucketOne); EXPECT_GT(rawIdOne, 0); OHOS::DataShare::DataShareValuesBucket valuesBucketTwo; std::string phoneNumber_test = randomNumberUtils.Generating(12); valuesBucketTwo.Put("phone_number", phoneNumber_test); valuesBucketTwo.Put("ring_duration", 999); int rawIdTwo = CalllogInsertValues(valuesBucketTwo); EXPECT_GT(rawIdTwo, 0); columns.push_back("phone_number"); columns.push_back("ring_duration"); OHOS::DataShare::DataShareValuesBucket updateValues; updateValues.Put("phone_number", phoneNumber); updateValues.Put("ring_duration", 888); OHOS::DataShare::DataSharePredicates predicates; predicates.GreaterThan("id", "0"); predicates.And(); predicates.EqualTo("ring_duration_shs", "999"); int updateCode = CalllogUpdate(updateValues, predicates); EXPECT_EQ(-1, updateCode); // query insert data OHOS::DataShare::DataSharePredicates predicates2; predicates2.EqualTo("id", std::to_string(rawIdOne)); predicates2.Or(); predicates2.EqualTo("id", std::to_string(rawIdTwo)); std::shared_ptr resultSetInsertQuery = CalllogQuery(columns, predicates2); // resultSet count 0, update failed will delete the calllog int rowCount = 0; resultSetInsertQuery->GetRowCount(rowCount); EXPECT_EQ(0, rowCount); std::vector listValue; listValue.push_back(valuesBucketOne); listValue.push_back(valuesBucketTwo); CheckResultSetList(listValue, resultSetInsertQuery, "abnormal_calllog_Update_test_1800"); ClearCallLog(); } /* * @tc.number abnormal_calllog_Query_test_1900 * @tc.name When querying the call record, a non-existent data is passed in * @tc.desc Exception use case * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, abnormal_calllog_Query_test_1900, testing::ext::TestSize.Level1) { HILOG_INFO("-----abnormal_calllog_Query_test_1900 is starting!-----"); std::vector columns; columns.push_back("id"); columns.push_back("phone_number"); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", "100000000"); std::shared_ptr resultSet = CalllogQuery(columns, predicates); // resultSet count int rowCount = 0; resultSet->GetRowCount(rowCount); EXPECT_EQ(0, rowCount); resultSet->Close(); ClearCallLog(); } /* * @tc.number abnormal_calllog_Query_test_2000 * @tc.name An incorrect table name was passed in when querying the call record * @tc.desc Exception use case * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, abnormal_calllog_Query_test_2000, testing::ext::TestSize.Level1) { HILOG_INFO("-----abnormal_calllog_Query_test_2000 is starting!-----"); OHOS::Uri uriCalllogs(CallLogUri::ERROR_URI); std::vector columns; columns.push_back("id"); columns.push_back("phone_number"); OHOS::DataShare::DataSharePredicates predicates; predicates.GreaterThan("id", "0"); std::shared_ptr resultSet = calllogAbility.Query(uriCalllogs, predicates, columns); EXPECT_EQ(resultSet, nullptr); ClearCallLog(); } /* * @tc.number abnormal_calllog_Query_test_2100 * @tc.name When querying the call record according to the combination conditions, * the wrong field name and nonexistent data are passed in * @tc.desc Exception use case * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, abnormal_calllog_Query_test_2100, testing::ext::TestSize.Level1) { HILOG_INFO("-----abnormal_calllog_Query_test_2100 is starting!-----"); OHOS::Uri uriCalllog(CallLogUri::CALL_LOG); std::vector columns; columns.push_back("id"); columns.push_back("phone_number"); OHOS::DataShare::DataSharePredicates predicates; predicates.GreaterThan("ids", "0"); predicates.And(); predicates.LessThan("id", "20"); std::shared_ptr resultSet = calllogAbility.Query(uriCalllog, predicates, columns); // resultSet count int rowCount = -1; resultSet->GetRowCount(rowCount); EXPECT_EQ(-1, rowCount); resultSet->Close(); ClearCallLog(); } /* * @tc.number abnormal_calllog_Query_test_2200 * @tc.name An error field is passed in when querying all call records * @tc.desc Exception use case * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, abnormal_calllog_Query_test_2200, testing::ext::TestSize.Level1) { HILOG_INFO("-----abnormal_calllog_Query_test_2200 is starting!-----"); OHOS::Uri uriCalllog(CallLogUri::CALL_LOG); OHOS::DataShare::DataSharePredicates predicates; predicates.GreaterThan("id", "0"); int deleteCode = calllogAbility.Delete(uriCalllog, predicates); EXPECT_EQ(deleteCode, 0); std::vector columns; columns.push_back("id"); columns.push_back("phone_numbers"); OHOS::DataShare::DataSharePredicates predicates2; predicates2.GreaterThan("id", "0"); std::shared_ptr resultSet = CalllogQuery(columns, predicates2); EXPECT_NE(resultSet, nullptr); ClearCallLog(); } /* * @tc.number abnormal_calllog_Delete_test_2300 * @tc.name An error field is passed in when deleting a single call record * @tc.desc Added ability to call record * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, abnormal_calllog_Delete_test_2300, testing::ext::TestSize.Level1) { HILOG_INFO("-----abnormal_calllog_Delete_test_2300 is starting!-----"); std::vector columns; GetAllValuesColumn(columns); int columnsSize = 27; OHOS::DataShare::DataShareValuesBucket valuesBucket = GetCallLogValues(0, columnsSize, columns); int rawId = CalllogInsertValues(valuesBucket); EXPECT_GT(rawId, 0); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(rawId)); std::shared_ptr resultSet = CalllogQuery(columns, predicates); int rowCount = 0; resultSet->GetRowCount(rowCount); EXPECT_EQ(1, rowCount); CheckResultSet(valuesBucket, resultSet, "abnormal_calllog_Delete_test_2300"); OHOS::DataShare::DataSharePredicates predicates2; predicates2.EqualTo("ids", std::to_string(rawId)); // test end delete data int deleteCode = CalllogDelete(predicates2); EXPECT_EQ(deleteCode, -1); OHOS::DataShare::DataSharePredicates predicates3; predicates3.EqualTo("id", std::to_string(rawId)); std::shared_ptr resultSetDelete = CalllogQuery(columns, predicates3); // resultSet count 1 int rowCountDelete = 0; resultSetDelete->GetRowCount(rowCountDelete); EXPECT_EQ(1, rowCountDelete); CheckResultSet(valuesBucket, resultSetDelete, "abnormal_calllog_Delete_test_2300"); ClearCallLog(); } /* * @tc.number abnormal_calllog_BatchInsert_test_2400 * @tc.name Batch call records are added and several of them fail. See the processing logic * @tc.desc Exception use case * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, abnormal_calllog_BatchInsert_test_2400, testing::ext::TestSize.Level1) { OHOS::DataShare::DataSharePredicates predicates; predicates.GreaterThan("id", "0"); int deleteCode = CalllogDelete(predicates); EXPECT_EQ(deleteCode, 0); HILOG_INFO("--- abnormal_calllog_BatchInsert_test_2400 is starting! ---"); OHOS::Uri uriData(CallLogUri::CALL_LOG); OHOS::DataShare::DataShareValuesBucket calllogValues; std::vector listAddBluk; int batchInserCode = 0; for (int i = 0; i < 10; i++) { listAddBluk.clear(); for (int j = 10 * i + 1; j <= 10 * (i + 1); j++) { calllogValues.Clear(); if (j == 14 || j == 27 || j == 57) { calllogValues.Put("phone_numbers", std::to_string(j)); } else { calllogValues.Put("phone_number", std::to_string(j)); } listAddBluk.push_back(calllogValues); } batchInserCode = calllogAbility.BatchInsert(uriData, listAddBluk); HILOG_INFO("abnormal_calllog_BatchInsert_test_2400 : batchInserCode = %{public}d", batchInserCode); if (batchInserCode == 0) { HILOG_INFO("abnormal_calllog_BatchInsert_test_2400 batch insert success!"); EXPECT_EQ(batchInserCode, 0); } else { HILOG_INFO("abnormal_calllog_BatchInsert_test_2400 batch insert fail!"); EXPECT_EQ(batchInserCode, -1); } } ClearCallLog(); } /* * @tc.number abnormal_calllog_BatchInsert_test_2500 * @tc.name Add 1000 pieces of data in batch to make article 500 fail. Check the subsequent processing logic * @tc.desc Exception use case * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, abnormal_calllog_BatchInsert_test_2500, testing::ext::TestSize.Level1) { HILOG_INFO("--- abnormal_calllog_BatchInsert_test_2500 is starting! ---"); OHOS::Uri uriData(CallLogUri::CALL_LOG); OHOS::DataShare::DataShareValuesBucket calllogValues; std::vector listAddBluk; int batchInserCode = 0; for (int i = 0; i < 1000; i++) { calllogValues.Clear(); if (i == 500) { calllogValues.Put("phone_numbers", std::to_string(i + 1)); } else { calllogValues.Put("phone_number", std::to_string(i + 1)); } listAddBluk.push_back(calllogValues); } batchInserCode = calllogAbility.BatchInsert(uriData, listAddBluk); if (batchInserCode == 0) { HILOG_INFO("abnormal_calllog_BatchInsert_test_2500 batch insert success!"); EXPECT_EQ(batchInserCode, 0); } else { HILOG_INFO("abnormal_calllog_BatchInsert_test_2500 batch insert fail!"); EXPECT_EQ(batchInserCode, -1); } ClearCallLog(); } /* * @tc.number abnormal_calllog_delete_test_2600 * @tc.name Delete call record data in batch, and several of them fail. Check the processing logic * @tc.desc Exception use case * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, abnormal_calllog_delete_test_2600, testing::ext::TestSize.Level1) { HILOG_INFO("--- abnormal_calllog_delete_test_2600 is starting! ---"); OHOS::Uri errorUriCalllogs(CallLogUri::ERROR_URI); OHOS::DataShare::DataShareValuesBucket valuesBucket; RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(10); valuesBucket.Put("phone_number", phoneNumber); int calllogIdOne = CalllogInsertValues(valuesBucket); EXPECT_GT(calllogIdOne, 0); OHOS::DataShare::DataShareValuesBucket valuesBucketTwo; valuesBucketTwo.Put("phone_number", phoneNumber); int calllogIdTwo = CalllogInsertValues(valuesBucketTwo); EXPECT_GT(calllogIdTwo, 0); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("ids", std::to_string(calllogIdOne)); int deleteCode = CalllogDelete(predicates); EXPECT_EQ(deleteCode, -1); std::vector columns; columns.push_back("phone_number"); std::shared_ptr resultSetOne = CalllogQuery(columns, predicates); int rowCountOne = 0; resultSetOne->GetRowCount(rowCountOne); EXPECT_EQ(-1, rowCountOne); CheckResultSet(valuesBucket, resultSetOne, "abnormal_calllog_delete_test_2600"); OHOS::DataShare::DataSharePredicates predicates2; predicates2.EqualTo("id", std::to_string(calllogIdTwo)); deleteCode = calllogAbility.Delete(errorUriCalllogs, predicates2); EXPECT_EQ(deleteCode, -1); std::shared_ptr resultSetTwo = CalllogQuery(columns, predicates2); int rowCountTwo = 0; resultSetTwo->GetRowCount(rowCountTwo); EXPECT_EQ(1, rowCountTwo); resultSetTwo->Close(); ClearCallLog(); } /* * @tc.number abnormal_calllog_Update_test_2700 * @tc.name When batch call record is modified, the wrong field or table name is passed in * @tc.desc Exception use case * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, abnormal_calllog_Update_test_2700, testing::ext::TestSize.Level1) { HILOG_INFO("--- abnormal_calllog_Update_test_2700 is starting! ---"); OHOS::Uri errorUri(CallLogUri::ERROR_URI); RandomNumberUtils randomNumberUtils; std::string phoneNumber = randomNumberUtils.Generating(10); int64_t calllogIdOne = CalllogInsert(phoneNumber); EXPECT_GT(calllogIdOne, 0); int64_t calllogIdTwo = CalllogInsert(phoneNumber); EXPECT_GT(calllogIdTwo, 0); OHOS::DataShare::DataShareValuesBucket updateCalllogValues; std::string phoneNumber_test = randomNumberUtils.Generating(6); updateCalllogValues.Put("phone_number", phoneNumber_test); OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("ids", std::to_string(calllogIdOne)); int updateCode = CalllogUpdate(updateCalllogValues, predicates); EXPECT_EQ(updateCode, -1); std::vector columns; columns.push_back("phone_number"); OHOS::DataShare::DataSharePredicates predicates2; predicates2.EqualTo("phone_number", phoneNumber_test); std::shared_ptr resultSetOne = CalllogQuery(columns, predicates2); int rowCountOne = 0; resultSetOne->GetRowCount(rowCountOne); EXPECT_EQ(0, rowCountOne); resultSetOne->Close(); updateCalllogValues.Clear(); updateCalllogValues.Put("phone_number", phoneNumber_test); OHOS::DataShare::DataSharePredicates predicates3; predicates3.EqualTo("id", std::to_string(calllogIdTwo)); updateCode = calllogAbility.Update(errorUri, predicates3, updateCalllogValues); EXPECT_EQ(updateCode, -1); std::shared_ptr resultSetTwo = CalllogQuery(columns, predicates3); int rowCountTwo = 0; resultSetTwo->GetRowCount(rowCountOne); EXPECT_EQ(0, rowCountTwo); OHOS::DataShare::DataShareValuesBucket oldValue; oldValue.Put("phone_number", phoneNumber); CheckResultSet(oldValue, resultSetTwo, "abnormal_calllog_Update_test_2700"); ClearCallLog(); } /* * @tc.number calllog_async_insert_test_2800 * @tc.name Add callLog async * @tc.desc Ability to join or add calllog * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_async_insert_test_2800, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_async_insert_test_2800 is staring! ---"); std::map result; std::vector callLogAsyncVector; int threadNum = 6; for (int i = 0; i < threadNum; ++i) { OHOS::DataShare::DataShareValuesBucket values; std::string name; name.append("asyncTest"); name.append(std::to_string(i)); values.Put("display_name", name); CallLogAsync *contactAsync = new CallLogAsync(values, result); std::thread asyncThread(&CallLogAsync::Insert, contactAsync); callLogAsyncVector.push_back(contactAsync); asyncThread.detach(); } std::chrono::milliseconds dura(Time::ASYNC_SLEEP_TIME); std::this_thread::sleep_for(dura); std::vector columns; columns.push_back("display_name"); std::map::iterator it; for (it = result.begin(); it != result.end(); it++) { OHOS::DataShare::DataSharePredicates predicates; predicates.EqualTo("id", std::to_string(it->first)); std::shared_ptr resultSet = CalllogQuery(columns, predicates); CheckResultSet(it->second, resultSet, "calllog_async_insert_test_2800"); } for (int i = 0; i < threadNum; ++i) { delete callLogAsyncVector[i]; } ClearCallLog(); } /* * @tc.number calllog_async_update_test_2900 * @tc.name update calllog async * @tc.desc Ability to join or update calllog * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_async_update_test_2900, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_async_update_test_2900 is staring! ---"); OHOS::DataShare::DataShareValuesBucket callValues; std::vector callLogId; callLogId.push_back(CalllogInsertValue("async_update1", callValues)); callValues.Clear(); callLogId.push_back(CalllogInsertValue("async_update2", callValues)); callValues.Clear(); callLogId.push_back(CalllogInsertValue("async_update3", callValues)); callValues.Clear(); callLogId.push_back(CalllogInsertValue("async_update4", callValues)); callValues.Clear(); callLogId.push_back(CalllogInsertValue("async_update5", callValues)); callValues.Clear(); callLogId.push_back(CalllogInsertValue("async_update6", callValues)); callValues.Clear(); std::vector upDateValues; OHOS::DataShare::DataSharePredicates queryPredicates; std::vector callLogAsyncVector; int size = callLogId.size(); for (int i = 0; i < size; ++i) { OHOS::DataShare::DataShareValuesBucket values; std::string name; name.append("asyncTest"); values.Put("display_name", name); upDateValues.push_back(values); int id = callLogId[i]; CallLogAsync *contactAsync = new CallLogAsync(values, id); callLogAsyncVector.push_back(contactAsync); std::thread asyncThread(&CallLogAsync::Update, contactAsync); asyncThread.detach(); queryPredicates.EqualTo("id", std::to_string(callLogId[i])); if (i < size - 1) { queryPredicates.Or(); } } std::chrono::milliseconds dura(Time::ASYNC_SLEEP_TIME); std::this_thread::sleep_for(dura); std::vector columns; columns.push_back("display_name"); std::shared_ptr resultSet = CalllogQuery(columns, queryPredicates); CheckResultSetList(upDateValues, resultSet, "calllog_async_update_test_2900"); for (int i = 0; i < size; ++i) { delete callLogAsyncVector[i]; } ClearCallLog(); } /* * @tc.number calllog_async_query_test_3000 * @tc.name query calllog async * @tc.desc Ability to join or query * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_async_query_test_3000, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_async_query_test_3000 is staring! ---"); OHOS::DataShare::DataShareValuesBucket callLogValues; std::vector callLogId; callLogId.push_back(CalllogInsertValue("async_query1", callLogValues)); callLogValues.Clear(); callLogId.push_back(CalllogInsertValue("async_query2", callLogValues)); callLogValues.Clear(); callLogId.push_back(CalllogInsertValue("async_query3", callLogValues)); callLogValues.Clear(); callLogId.push_back(CalllogInsertValue("async_query4", callLogValues)); callLogValues.Clear(); callLogId.push_back(CalllogInsertValue("async_query5", callLogValues)); callLogValues.Clear(); callLogId.push_back(CalllogInsertValue("async_query6", callLogValues)); callLogValues.Clear(); std::vector callLogAsyncVector; std::vector> resultSetVector; int threadNum = 6; for (int i = 0; i < threadNum; ++i) { CallLogAsync *contactAsync = new CallLogAsync(resultSetVector, callLogId); callLogAsyncVector.push_back(contactAsync); std::thread asyncThread(&CallLogAsync::Query, contactAsync); asyncThread.detach(); } int queryCount = 6; int size = resultSetVector.size(); for (int i = 0; i < size; ++i) { int rowCount = 0; resultSetVector[i]->GetRowCount(rowCount); EXPECT_EQ(queryCount, rowCount); resultSetVector[i]->Close(); } for (int i = 0; i < size; ++i) { delete callLogAsyncVector[i]; } ClearCallLog(); } /* * @tc.number contact_async_update_test_7300 * @tc.name delete calllog async * @tc.desc Ability to join or delete calllog * @tc.level Level1 * @tc.size MediumTest * @tc.type Function */ HWTEST_F(CalllogAbilityTest, calllog_async_delete_test_3100, testing::ext::TestSize.Level1) { HILOG_INFO("--- calllog_async_delete_test_3100 is staring! ---"); OHOS::DataShare::DataShareValuesBucket callLogValues; std::vector callLogId; callLogId.push_back(CalllogInsertValue("async_update1", callLogValues)); callLogValues.Clear(); callLogId.push_back(CalllogInsertValue("async_update2", callLogValues)); callLogValues.Clear(); callLogId.push_back(CalllogInsertValue("async_update3", callLogValues)); callLogValues.Clear(); callLogId.push_back(CalllogInsertValue("async_update4", callLogValues)); callLogValues.Clear(); callLogId.push_back(CalllogInsertValue("async_update5", callLogValues)); callLogValues.Clear(); callLogId.push_back(CalllogInsertValue("async_update6", callLogValues)); callLogValues.Clear(); int size = callLogId.size(); OHOS::DataShare::DataSharePredicates predicates; predicates.BeginWrap(); std::vector callLogAsyncVector; for (int i = 0; i < size; ++i) { int id = callLogId[i]; CallLogAsync *contactAsync = new CallLogAsync(id); callLogAsyncVector.push_back(contactAsync); std::thread asyncThread(&CallLogAsync::Delete, contactAsync); asyncThread.detach(); predicates.EqualTo("id", std::to_string(id)); if (i < size - 1) { predicates.Or(); } } predicates.EndWrap(); std::chrono::milliseconds dura(Time::ASYNC_SLEEP_TIME); std::this_thread::sleep_for(dura); std::vector columns; std::shared_ptr resultSet = CalllogQuery(columns, predicates); int rowCount = 0; resultSet->GetRowCount(rowCount); EXPECT_EQ(0, rowCount); resultSet->Close(); for (int i = 0; i < size; ++i) { delete callLogAsyncVector[i]; } ClearCallLog(); } } // namespace Test } // namespace Contacts