openharmony/telephony_core_service
1
0
Fork 0
mirror of https://gitee.com/openharmony/telephony_core_service synced 2025-02-25 12:13:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix tdd test.

Browse Source 
Signed-off-by: dingxiaochen <dingxiaochen@huawei.com>
This commit is contained in:
dingxiaochen 2022-11-26 17:34:06 +08:00
parent 6dd0dd82f8
commit 76a483b1e8
3 changed files with 325 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
services/core/src/core_service.cpp
View File

@ -119,7 +119,7 @@ int32_t CoreService::GetPsRadioTech(int32_t slotId)
{
if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_PERMISSION_ERROR;
return TELEPHONY_ERR_PERMISSION_ERR;
}
if (networkSearchManager_ == nullptr) {
TELEPHONY_LOGE("networkSearchManager_ is null");
@ -132,7 +132,7 @@ int32_t CoreService::GetCsRadioTech(int32_t slotId)
{
if (!TelephonyPermission::CheckPermission(Permission::GET_NETWORK_INFO)) {
TELEPHONY_LOGE("permission denied!");
return TELEPHONY_PERMISSION_ERROR;
return TELEPHONY_ERR_PERMISSION_ERR;
}
if (networkSearchManager_ == nullptr) {
TELEPHONY_LOGE("networkSearchManager_ is null");
@ -753,7 +753,7 @@ int32_t CoreService::GetLockState(int32_t slotId, LockType lockType)
{
if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
TELEPHONY_LOGE("CoreService::GetLockState, Permission denied!");
return TELEPHONY_PERMISSION_ERROR;
return TELEPHONY_ERR_PERMISSION_ERR;
}
TELEPHONY_LOGI("CoreService::GetLockState(), lockType = %{public}d, slotId = %{public}d", lockType, slotId);
if (simManager_ == nullptr) {

322
test/unittest/core_service_gtest/network_search_test.cpp
View File

@ -430,6 +430,24 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetPsRadioTech_0200, Functio
}
}
/**
* @tc.number Telephony_NetworkSearch_GetPsRadioTech_0300
* @tc.name Get RAT of the PS domain on the registered network without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetPsRadioTech_0300, Function | MediumTest | Level1)
{
if (NetworkSearchTest::telephonyService_ == nullptr ||
!(NetworkSearchTest::telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGI("TelephonyTestService Remote service is null");
NetworkSearchTest::telephonyService_ = GetProxy();
return;
}
int32_t result = CoreServiceClient::GetInstance().GetPsRadioTech(SLOT_ID);
TELEPHONY_LOGI("TelephonyTestService GetPsRadioTech result: %{public}d", result);
EXPECT_EQ(TELEPHONY_ERR_PERMISSION_ERR, result);
}
/**
* @tc.number Telephony_NetworkSearch_GetCsRadioTech_0100
* @tc.name Get RAT of the CS domain on the registered network
@ -466,6 +484,23 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetCsRadioTech_0200, Functio
}
}
/**
* @tc.number Telephony_NetworkSearch_GetCsRadioTech_0300
* @tc.name Get RAT of the CS domain on the registered network without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetCsRadioTech_0300, Function | MediumTest | Level1)
{
if (NetworkSearchTest::telephonyService_ == nullptr ||
!(NetworkSearchTest::telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGI("TelephonyTestService Remote service is null");
NetworkSearchTest::telephonyService_ = GetProxy();
return;
}
int32_t result = CoreServiceClient::GetInstance().GetCsRadioTech(SLOT_ID);
EXPECT_EQ(TELEPHONY_ERR_PERMISSION_ERR, result);
}
/**
* @tc.number Telephony_NetworkSearch_GetNetworkState_0100
* @tc.name Get Network State
@ -520,6 +555,23 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetNetworkState_0200, Functi
}
}
/**
* @tc.number Telephony_NetworkSearch_GetNetworkState_0300
* @tc.name Get Network State without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetNetworkState_0300, Function | MediumTest | Level2)
{
if (NetworkSearchTest::telephonyService_ == nullptr ||
!(NetworkSearchTest::telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGI("TelephonyTestService Remote service is null");
NetworkSearchTest::telephonyService_ = GetProxy();
return;
}
sptr<NetworkState> result = CoreServiceClient::GetInstance().GetNetworkState(SLOT_ID);
ASSERT_TRUE(result == nullptr);
}
/**
* @tc.number Telephony_NetworkSearch_GetOperatorNumeric_0100
* @tc.name Get Operator Numeric of PLMN
@ -732,11 +784,29 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetCellInfoList_0200, Functi
NetworkSearchTest::telephonyService_ = GetProxy();
return;
}
std::vector<sptr<CellInformation>> cellList = CoreServiceClient::GetInstance().GetCellInfoList(SLOT_ID);
std::vector<sptr<CellInformation>> cellList = CoreServiceClient::GetInstance().GetCellInfoList(SLOT_ID1);
PrintCellInformation(cellList);
ASSERT_TRUE(!cellList.empty());
}
/**
* @tc.number Telephony_NetworkSearch_GetCellInfoList_0300
* @tc.name Get Cell Info List without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetCellInfoList_0300, Function | MediumTest | Level3)
{
if (NetworkSearchTest::telephonyService_ == nullptr ||
!(NetworkSearchTest::telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGE("TelephonyTestService Remote service is null");
NetworkSearchTest::telephonyService_ = GetProxy();
return;
}
std::vector<sptr<CellInformation>> cellList = CoreServiceClient::GetInstance().GetCellInfoList(SLOT_ID);
PrintCellInformation(cellList);
ASSERT_TRUE(cellList.empty());
}
/**
* @tc.number Telephony_NetworkSearch_PrintCellInfoList_0100
* @tc.name Get Cell Info List
@ -924,6 +994,33 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_SetNetworkSelectionMode_0400
ASSERT_TRUE(syncResult);
}
/**
* @tc.number Telephony_NetworkSearch_SetNetworkSelectionMode_0500
* @tc.name Set Auto Network Selection Mode without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_SetNetworkSelectionMode_0500, Function | MediumTest | Level3)
{
if (telephonyService_ == nullptr || !(telephonyService_->HasSimCard(SLOT_ID1))) {
TELEPHONY_LOGE("TelephonyTestService Remote service is null");
telephonyService_ = GetProxy();
return;
}
sptr<NetworkInformation> networkInfo = new (std::nothrow) NetworkInformation();
networkInfo->SetOperateInformation("CHINA MOBILE", "CMCC", "46000",
static_cast<int32_t>(NetworkPlmnState::NETWORK_PLMN_STATE_AVAILABLE),
static_cast<int32_t>(NetworkRat::NETWORK_LTE));
sptr<NetworkSearchTestCallbackStub> callback(new NetworkSearchTestCallbackStub());
bool result = telephonyService_->SetNetworkSelectionMode(
SLOT_ID1, static_cast<int32_t>(SelectionMode::MODE_TYPE_AUTO), networkInfo, true, callback);
TELEPHONY_LOGI("TelephonyTestService SetNetworkSelectionMode result: %{public}d", result);
ASSERT_FALSE(result);
callback->WaitForSetNetworkModeCallback(WAIT_TIME_SECOND_LONG);
bool syncResult = callback->SetNetworkModeCallbackResult();
TELEPHONY_LOGI("TelephonyTestService SetNetworkSelectionMode syncResult: %{public}d", syncResult);
ASSERT_TRUE(syncResult);
}
/**
* @tc.number Telephony_NetworkSearch_GetNetworkSelectionMode_0100
* @tc.name Get Manual Network Selection Mode
@ -1160,6 +1257,24 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_SetRadioState_0400, Function
ASSERT_TRUE(syncResult);
}
/**
* @tc.number Telephony_NetworkSearch_SetRadioState_0500
* @tc.name Set radio state off without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_SetRadioState_0500, Function | MediumTest | Level3)
{
if (telephonyService_ == nullptr || !(telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGE("TelephonyTestService Remote service is null");
telephonyService_ = GetProxy();
return;
}
sptr<NetworkSearchTestCallbackStub> callback(new NetworkSearchTestCallbackStub());
bool result = CoreServiceClient::GetInstance().SetRadioState(SLOT_ID, false, callback);
TELEPHONY_LOGI("SetRadioState_0100 SetRadioState result: %{public}d", result);
ASSERT_FALSE(result);
}
/**
* @tc.number Telephony_NetworkSearch_GetRadioState_0100
* @tc.name Get Radio State Off
@ -1284,6 +1399,24 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetRadioState_0400, Function
ASSERT_TRUE(isRadioOn);
}
/**
* @tc.number Telephony_NetworkSearch_GetRadioState_0500
* @tc.name Get radio state off without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetRadioState_0500, Function | MediumTest | Level3)
{
if (telephonyService_ == nullptr || !(telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGE("TelephonyTestService Remote service is null");
telephonyService_ = GetProxy();
return;
}
sptr<NetworkSearchTestCallbackStub> callback(new NetworkSearchTestCallbackStub());
bool result = CoreServiceClient::GetInstance().GetRadioState(SLOT_ID, callback);
TELEPHONY_LOGI("GetRadioState_0100 GetRadioState result: %{public}d", result);
ASSERT_FALSE(result);
}
/**
* @tc.number Telephony_NetworkSearch_GetImei_0100
* @tc.name Get Imei
@ -1324,6 +1457,25 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetImei_0200, Function | Med
}
}
/**
* @tc.number Telephony_NetworkSearch_GetImei_0300
* @tc.name Get Imei without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetImei_0300, Function | MediumTest | Level2)
{
if (NetworkSearchTest::telephonyService_ == nullptr ||
!(NetworkSearchTest::telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGI("TelephonyTestService Remote service is null");
NetworkSearchTest::telephonyService_ = GetProxy();
return;
}
std::u16string result = CoreServiceClient::GetInstance().GetImei(SLOT_ID);
std::string imei = Str16ToStr8(result);
TELEPHONY_LOGI("TelephonyTestService GetImei Imei: %{public}s", imei.c_str());
ASSERT_TRUE(imei.empty());
}
/**
* @tc.number Telephony_NetworkSearch_GetMeid_0100
* @tc.name Get Meid
@ -1364,6 +1516,25 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetMeid_0200, Function | Med
}
}
/**
* @tc.number Telephony_NetworkSearch_GetMeid_0300
* @tc.name Get meid without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetMeid_0300, Function | MediumTest | Level2)
{
if (NetworkSearchTest::telephonyService_ == nullptr ||
!(NetworkSearchTest::telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGI("TelephonyTestService Remote service is null");
NetworkSearchTest::telephonyService_ = GetProxy();
return;
}
std::u16string result = CoreServiceClient::GetInstance().GetMeid(SLOT_ID);
std::string meid = Str16ToStr8(result);
TELEPHONY_LOGI("TelephonyTestService GetMeid Meid: %{public}s", meid.c_str());
ASSERT_TRUE(meid.empty());
}
/**
* @tc.number Telephony_NetworkSearch_GetUniqueDeviceId_0100
* @tc.name Get unique device id
@ -1404,6 +1575,26 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetUniqueDeviceId_0200, Func
}
}
/**
* @tc.number Telephony_NetworkSearch_GetUniqueDeviceId_0300
* @tc.name Get unique device id without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetUniqueDeviceId_0300, Function | MediumTest | Level2)
{
if (NetworkSearchTest::telephonyService_ == nullptr ||
!(NetworkSearchTest::telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGI("TelephonyTestService Remote service is null");
NetworkSearchTest::telephonyService_ = GetProxy();
return;
} else {
std::u16string result = CoreServiceClient::GetInstance().GetUniqueDeviceId(SLOT_ID);
std::string deviceid = Str16ToStr8(result);
TELEPHONY_LOGI("TelephonyTestService GetUniqueDeviceId DeviceId: %{public}s", deviceid.c_str());
ASSERT_TRUE(deviceid.empty());
}
}
/**
* @tc.number Telephony_NetworkSearch_SendUpdateCellLocationRequest_0100
* @tc.name Send Cell Location Update
@ -1442,6 +1633,25 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_SendUpdateCellLocationReques
}
}
/**
* @tc.number Telephony_NetworkSearch_SendUpdateCellLocationRequest_0300
* @tc.name Send Cell Location Update without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_SendUpdateCellLocationRequest_0300, Function | MediumTest | Level3)
{
if (NetworkSearchTest::telephonyService_ == nullptr ||
!(NetworkSearchTest::telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGI("TelephonyTestService Remote service is null");
NetworkSearchTest::telephonyService_ = GetProxy();
return;
} else {
bool result = CoreServiceClient::GetInstance().SendUpdateCellLocationRequest(SLOT_ID);
TELEPHONY_LOGI("TelephonyTestService SendUpdateCellLocationRequest result: %{public}d", result);
ASSERT_FALSE(result);
}
}
/**
* @tc.number Telephony_NetworkSearch_GetNetworkSearchInformation_0100
* @tc.name Get Network Search Information
@ -1488,6 +1698,24 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetNetworkSearchInformation_
ASSERT_TRUE(syncResult);
}
/**
* @tc.number Telephony_NetworkSearch_GetNetworkSearchInformation_0300
* @tc.name Get Network Search Information without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetNetworkSearchInformation_0300, Function | MediumTest | Level3)
{
if (telephonyService_ == nullptr || !(telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGE("TelephonyTestService Remote service is null");
telephonyService_ = GetProxy();
return;
}
sptr<NetworkSearchTestCallbackStub> callback(new NetworkSearchTestCallbackStub());
bool result = CoreServiceClient::GetInstance().GetNetworkSearchInformation(SLOT_ID, callback);
TELEPHONY_LOGI("TelephonyTestService GetNetworkSearchInformation result: %{public}d", result);
ASSERT_FALSE(result);
}
/**
* @tc.number Telephony_NetworkSearch_GetImsRegStatus_0100
* @tc.name Get ims register status
@ -1577,6 +1805,22 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetImsRegStatus_0500, Functi
EXPECT_EQ(TELEPHONY_ERR_ARGUMENT_INVALID, ret);
}
/**
* @tc.number Telephony_NetworkSearch_GetImsRegStatus_0600
* @tc.name Get ims register status without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_GetImsRegStatus_0600, Function | MediumTest | Level2)
{
if (NetworkSearchTest::telephonyService_ == nullptr || !(telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGE("TelephonyTestService Remote service is null");
return;
}
ImsRegInfo info;
int ret = CoreServiceClient::GetInstance().GetImsRegStatus(SLOT_ID, ImsServiceType::TYPE_VOICE, info);
EXPECT_EQ(TELEPHONY_ERR_PERMISSION_ERR, ret);
}
/**
* @tc.number Telephony_NetworkSearch_RegImsRegInfoCallback_0100
* @tc.name Register ims registation info callback
@ -1729,6 +1973,47 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_RegImsRegInfoCallback_0700,
EXPECT_EQ(TELEPHONY_ERR_ARGUMENT_NULL, ret);
}
/**
* @tc.number Telephony_NetworkSearch_RegImsRegInfoCallback_0800
* @tc.name Register ims registation info callback without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_RegImsRegInfoCallback_0800, Function | MediumTest | Level2)
{
if (NetworkSearchTest::telephonyService_ == nullptr || !(telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGE("TelephonyTestService Remote service is null");
return;
}
ImsRegStateCallback imsRegStateCallback;
imsRegStateCallback.slotId = SLOT_ID;
imsRegStateCallback.imsSrvType = ImsServiceType::TYPE_VIDEO;
imsRegStateCallback.imsCallback = new ImsRegInfoCallbackGtest();
int ret = CoreServiceClient::GetInstance().RegisterImsRegInfoCallback(
imsRegStateCallback.slotId, imsRegStateCallback.imsSrvType, imsRegStateCallback.imsCallback);
EXPECT_EQ(TELEPHONY_ERR_PERMISSION_ERR, ret);
}
/**
* @tc.number Telephony_NetworkSearch_RegImsRegInfoCallback_0900
* @tc.name Register ims registation info callback with video type
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_RegImsRegInfoCallback_0900, Function | MediumTest | Level2)
{
AccessToken token;
if (NetworkSearchTest::telephonyService_ == nullptr || !(telephonyService_->HasSimCard(SLOT_ID))) {
TELEPHONY_LOGE("TelephonyTestService Remote service is null");
return;
}
ImsRegStateCallback imsRegStateCallback;
imsRegStateCallback.slotId = SLOT_ID;
imsRegStateCallback.imsSrvType = ImsServiceType::TYPE_VIDEO;
imsRegStateCallback.imsCallback = new ImsRegInfoCallbackGtest();
int ret = CoreServiceClient::GetInstance().RegisterImsRegInfoCallback(
imsRegStateCallback.slotId, imsRegStateCallback.imsSrvType, imsRegStateCallback.imsCallback);
EXPECT_EQ(TELEPHONY_SUCCESS, ret);
}
/**
* @tc.number Telephony_NetworkSearch_UnRegImsRegInfoCallback_0100
* @tc.name Unregister ims registation info callback
@ -1873,6 +2158,41 @@ HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_UnRegImsRegInfoCallback_0700
EXPECT_EQ(TELEPHONY_ERR_ARGUMENT_INVALID, ret);
}
/**
* @tc.number Telephony_NetworkSearch_UnRegImsRegInfoCallback_0800
* @tc.name Unregister ims registation info callback without permission
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_UnRegImsRegInfoCallback_0800, Function | MediumTest | Level2)
{
int ret = TELEPHONY_ERROR;
if (NetworkSearchTest::telephonyService_ == nullptr) {
TELEPHONY_LOGE("TelephonyTestService Remote service is null");
EXPECT_EQ(TELEPHONY_SUCCESS, ret);
return;
}
ret = NetworkSearchTest::telephonyService_->UnregisterImsRegInfoCallback(SLOT_ID, ImsServiceType::TYPE_VIDEO);
EXPECT_EQ(TELEPHONY_ERR_PERMISSION_ERR, ret);
}
/**
* @tc.number Telephony_NetworkSearch_UnRegImsRegInfoCallback_0900
* @tc.name Unregister ims registation info callback with video type
* @tc.desc Function test
*/
HWTEST_F(NetworkSearchTest, Telephony_NetworkSearch_UnRegImsRegInfoCallback_0900, Function | MediumTest | Level2)
{
AccessToken token;
int ret = TELEPHONY_ERROR;
if (NetworkSearchTest::telephonyService_ == nullptr) {
TELEPHONY_LOGE("TelephonyTestService Remote service is null");
EXPECT_EQ(TELEPHONY_SUCCESS, ret);
return;
}
ret = NetworkSearchTest::telephonyService_->UnregisterImsRegInfoCallback(SLOT_ID, ImsServiceType::TYPE_VIDEO);
EXPECT_EQ(TELEPHONY_SUCCESS, ret);
}
#else // TEL_TEST_UNSUPPORT
/**
* @tc.number Telephony_NetworkSearch_MockTest_0100

1
test/unittest/core_service_gtest/network_search_test.h
View File

@ -183,6 +183,7 @@ struct ImsRegStateCallback {
ImsServiceType imsSrvType;
sptr<ImsRegInfoCallback> imsCallback = nullptr;
};
class NetworkSearchTest : public testing::Test {
public:
// execute before first testcase