1 /*
2 * Copyright (C) 2023 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 #define PRIVATE PUBLIC
16 #define PROTECTED PUBLIC
17 #include "cellular_call_config.h"
18 #include "cellular_call_handler.h"
19 #include "cellular_call_proxy.h"
20 #include "cellular_call_register.h"
21 #include "cellular_call_service.h"
22 #include "tel_ril_call_parcel.h"
23 #include "ims_call_callback_proxy.h"
24 #include "ims_call_callback_stub.h"
25 #include "ims_call_client.h"
26 #include "ims_control.h"
27 #include "ims_error.h"
28 #include "core_service_client.h"
29 #include "gtest/gtest.h"
30 #include "securec.h"
31 #include "ims_core_service_client.h"
32
33 namespace OHOS {
34 namespace Telephony {
35 using namespace testing::ext;
36 const std::string PHONE_NUMBER = "0000000";
37 const int32_t DEFAULT_INDEX = 1;
38
39 class ImsCallbackProxyTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp();
44 void TearDown();
HasSimCard(int32_t slotId)45 bool HasSimCard(int32_t slotId)
46 {
47 bool hasSimCard = false;
48 DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(slotId, hasSimCard);
49 return hasSimCard;
50 }
51 };
52
SetUpTestCase(void)53 void ImsCallbackProxyTest::SetUpTestCase(void)
54 {
55 // step 3: Set Up Test Case
56 }
57
TearDownTestCase(void)58 void ImsCallbackProxyTest::TearDownTestCase(void) {}
59
SetUp(void)60 void ImsCallbackProxyTest::SetUp(void) {}
61
TearDown(void)62 void ImsCallbackProxyTest::TearDown(void) {}
63
64 /**
65 * @tc.number cellular_call_ImsCallCallbackProxy_0001
66 * @tc.name Test for ImsCallCallbackProxy
67 * @tc.desc Function test
68 */
69 HWTEST_F(ImsCallbackProxyTest, cellular_call_ImsCallCallbackProxy_0001, Function | MediumTest | Level3)
70 {
71 const sptr<ImsCallCallbackInterface> imsCallCallback_ = (std::make_unique<ImsCallCallbackStub>()).release();
72 auto callCallbackProxy =
73 (std::make_unique<ImsCallCallbackProxy>(imsCallCallback_->AsObject().GetRefPtr())).release();
74 ASSERT_TRUE(callCallbackProxy != nullptr);
75 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
76 if (!HasSimCard(slotId)) {
77 continue;
78 }
79 EventFwk::MatchingSkills matchingSkills;
80 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
81 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
82 auto handler = std::make_shared<CellularCallHandler>(subscriberInfo);
83 handler->SetSlotId(slotId);
84 handler->RegisterImsCallCallbackHandler();
85 RadioResponseInfo rilRadioResponse;
86 rilRadioResponse.error = ErrType::ERR_GENERIC_FAILURE;
87 EXPECT_EQ(callCallbackProxy->DialResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
88 EXPECT_EQ(callCallbackProxy->HangUpResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
89 EXPECT_EQ(callCallbackProxy->RejectWithReasonResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
90 EXPECT_EQ(callCallbackProxy->AnswerResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
91 EXPECT_EQ(callCallbackProxy->HoldCallResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
92 EXPECT_EQ(callCallbackProxy->UnHoldCallResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
93 EXPECT_EQ(callCallbackProxy->SwitchCallResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
94 EXPECT_EQ(callCallbackProxy->StartDtmfResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
95 EXPECT_GE(callCallbackProxy->SendDtmfResponse(slotId, rilRadioResponse, DEFAULT_INDEX), TELEPHONY_SUCCESS);
96 EXPECT_EQ(callCallbackProxy->StopDtmfResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
97 EXPECT_EQ(callCallbackProxy->SetImsSwitchResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
98 EXPECT_EQ(callCallbackProxy->GetImsSwitchResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
99 EXPECT_EQ(callCallbackProxy->GetImsCallsDataResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
100 EXPECT_EQ(callCallbackProxy->CallStateChangeReport(slotId), TELEPHONY_SUCCESS);
101 ImsCurrentCallList imsCallList;
102 imsCallList.callSize = 0;
103 EXPECT_EQ(callCallbackProxy->GetImsCallsDataResponse(slotId, imsCallList), TELEPHONY_SUCCESS);
104 DisconnectedDetails details;
105 EXPECT_EQ(callCallbackProxy->LastCallFailReasonResponse(slotId, details), TELEPHONY_SUCCESS);
106 RingbackVoice ringback;
107 EXPECT_EQ(callCallbackProxy->CallRingBackReport(slotId, ringback), TELEPHONY_SUCCESS);
108 int32_t active = 0;
109 EXPECT_EQ(callCallbackProxy->GetImsSwitchResponse(slotId, active), TELEPHONY_SUCCESS);
110 ImsCapFromChip imsCap = {0};
111 EXPECT_EQ(callCallbackProxy->GetImsCapResponse(slotId, imsCap), TELEPHONY_SUCCESS);
112 MuteControlResponse muteResponse;
113 EXPECT_EQ(callCallbackProxy->SetMuteResponse(slotId, muteResponse), TELEPHONY_SUCCESS);
114 EXPECT_EQ(callCallbackProxy->CombineConferenceResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
115 EXPECT_EQ(callCallbackProxy->InviteToConferenceResponse(slotId, rilRadioResponse), TELEPHONY_SUCCESS);
116 }
117 }
118
119 /**
120 * @tc.number cellular_call_ImsCallCallbackProxy_0002
121 * @tc.name Test for ImsCallCallbackProxy
122 * @tc.desc Function test
123 */
124 HWTEST_F(ImsCallbackProxyTest, cellular_call_ImsCallCallbackProxy_0002, Function | MediumTest | Level3)
125 {
126 const sptr<ImsCallCallbackInterface> imsCallCallback_ = (std::make_unique<ImsCallCallbackStub>()).release();
127 auto callCallbackProxy =
128 (std::make_unique<ImsCallCallbackProxy>(imsCallCallback_->AsObject().GetRefPtr())).release();
129 ASSERT_TRUE(callCallbackProxy != nullptr);
130 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
131 if (!HasSimCard(slotId)) {
132 continue;
133 }
134 EventFwk::MatchingSkills matchingSkills;
135 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
136 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
137 auto handler = std::make_shared<CellularCallHandler>(subscriberInfo);
138 handler->SetSlotId(slotId);
139 handler->RegisterImsCallCallbackHandler();
140 GetClipResult clipResult;
141 clipResult.result.index = INVALID_INDEX;
142 EXPECT_EQ(callCallbackProxy->GetClipResponse(slotId, clipResult), TELEPHONY_SUCCESS);
143 GetClirResult clirResult;
144 clirResult.result.index = INVALID_INDEX;
145 EXPECT_EQ(callCallbackProxy->GetClirResponse(slotId, clirResult), TELEPHONY_SUCCESS);
146 SsBaseResult normalResult;
147 normalResult.index = DEFAULT_INDEX;
148 EXPECT_EQ(callCallbackProxy->SetClipResponse(slotId, normalResult), TELEPHONY_SUCCESS);
149 EXPECT_EQ(callCallbackProxy->SetClirResponse(slotId, normalResult), TELEPHONY_SUCCESS);
150 EXPECT_EQ(callCallbackProxy->SetCallTransferResponse(slotId, normalResult), TELEPHONY_SUCCESS);
151 EXPECT_EQ(callCallbackProxy->SetCallRestrictionResponse(slotId, normalResult), TELEPHONY_SUCCESS);
152 EXPECT_EQ(callCallbackProxy->SetCallWaitingResponse(slotId, normalResult), TELEPHONY_SUCCESS);
153 EXPECT_EQ(callCallbackProxy->SetColrResponse(slotId, normalResult), TELEPHONY_SUCCESS);
154 EXPECT_EQ(callCallbackProxy->SetColpResponse(slotId, normalResult), TELEPHONY_SUCCESS);
155 CallForwardQueryInfoList callList;
156 callList.result.index = INVALID_INDEX;
157 EXPECT_EQ(callCallbackProxy->GetCallTransferResponse(slotId, callList), TELEPHONY_SUCCESS);
158 CallRestrictionResult crResult;
159 crResult.result.index = INVALID_INDEX;
160 EXPECT_EQ(callCallbackProxy->GetCallRestrictionResponse(slotId, crResult), TELEPHONY_SUCCESS);
161 CallWaitResult cwResult;
162 cwResult.result.index = INVALID_INDEX;
163 EXPECT_EQ(callCallbackProxy->GetCallWaitingResponse(slotId, cwResult), TELEPHONY_SUCCESS);
164 GetColrResult colrResult;
165 colrResult.result.index = INVALID_INDEX;
166 EXPECT_EQ(callCallbackProxy->GetColrResponse(slotId, colrResult), TELEPHONY_SUCCESS);
167 GetColpResult colpResult;
168 colpResult.result.index = INVALID_INDEX;
169 EXPECT_EQ(callCallbackProxy->GetColpResponse(slotId, colpResult), TELEPHONY_SUCCESS);
170 }
171 }
172
173 /**
174 * @tc.number cellular_call_ImsCallCallbackProxy_0003
175 * @tc.name Test for ImsCallCallbackProxy
176 * @tc.desc Function test
177 */
178 HWTEST_F(ImsCallbackProxyTest, cellular_call_ImsCallCallbackProxy_0003, Function | MediumTest | Level3)
179 {
180 const sptr<ImsCallCallbackInterface> imsCallCallback_ = (std::make_unique<ImsCallCallbackStub>()).release();
181 auto callCallbackProxy =
182 (std::make_unique<ImsCallCallbackProxy>(imsCallCallback_->AsObject().GetRefPtr())).release();
183 ASSERT_TRUE(callCallbackProxy != nullptr);
184 for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; slotId++) {
185 if (!HasSimCard(slotId)) {
186 continue;
187 }
188 EventFwk::MatchingSkills matchingSkills;
189 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_OPERATOR_CONFIG_CHANGED);
190 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
191 auto handler = std::make_shared<CellularCallHandler>(subscriberInfo);
192 handler->SetSlotId(slotId);
193 handler->RegisterImsCallCallbackHandler();
194 ImsCallModeReceiveInfo callModeReceiveInfo;
195 callModeReceiveInfo.callIndex = DEFAULT_INDEX;
196 EXPECT_EQ(
197 callCallbackProxy->ReceiveUpdateCallMediaModeResponse(slotId, callModeReceiveInfo), TELEPHONY_SUCCESS);
198 EXPECT_EQ(
199 callCallbackProxy->ReceiveUpdateCallMediaModeRequest(slotId, callModeReceiveInfo), TELEPHONY_SUCCESS);
200 ImsCallSessionEventInfo callSessionEventInfo;
201 callSessionEventInfo.callIndex = DEFAULT_INDEX;
202 EXPECT_EQ(callCallbackProxy->CallSessionEventChanged(slotId, callSessionEventInfo), TELEPHONY_SUCCESS);
203 ImsCallPeerDimensionsInfo callPeerDimensionsInfo;
204 callPeerDimensionsInfo.callIndex = DEFAULT_INDEX;
205 EXPECT_EQ(callCallbackProxy->PeerDimensionsChanged(slotId, callPeerDimensionsInfo), TELEPHONY_SUCCESS);
206 ImsCallDataUsageInfo callDataUsageInfo;
207 callDataUsageInfo.callIndex = DEFAULT_INDEX;
208 EXPECT_EQ(callCallbackProxy->CallDataUsageChanged(slotId, callDataUsageInfo), TELEPHONY_SUCCESS);
209 CameraCapabilitiesInfo cameraCapabilitiesInfo;
210 cameraCapabilitiesInfo.callIndex = DEFAULT_INDEX;
211 EXPECT_EQ(callCallbackProxy->CameraCapabilitiesChanged(slotId, cameraCapabilitiesInfo), TELEPHONY_SUCCESS);
212 }
213 }
214 } // namespace Telephony
215 } // namespace OHOS
216