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 "call_manager_special_mock.h"
17 #include <thread>
18 #include <chrono>
19 #include "call_manager_service_proxy.h"
20 #include "call_manager_errors.h"
21 #include "message_option.h"
22 #include "message_parcel.h"
23 #include "call_manager_proxy.h"
24 #include "call_status_callback_proxy.h"
25 #include "voip_call_manager_proxy.h"
26 #include "call_status_callback.h"
27 #include "cellular_call_proxy.h"
28
29 namespace OHOS::Telephony {
30 using namespace testing::ext;
31 class SpecialBranch3Test : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase()39 void SpecialBranch3Test::SetUpTestCase()
40 {
41 }
42
TearDownTestCase()43 void SpecialBranch3Test::TearDownTestCase()
44 {
45 }
46
SetUp()47 void SpecialBranch3Test::SetUp()
48 {
49 }
50
TearDown()51 void SpecialBranch3Test::TearDown()
52 {
53 sleep(1);
54 }
55
56 /**
57 * @tc.number Telephony_CallManagerServiceProxy_001
58 * @tc.name test branch
59 * @tc.desc Function test
60 */
61 HWTEST_F(SpecialBranch3Test, Telephony_CallManagerServiceProxy_001, TestSize.Level1)
62 {
63 sptr<IRemoteObject> impl;
64 CallManagerServiceProxy proxy(impl);
65 EXPECT_EQ(proxy.ObserverOnCallDetailsChange(), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
66 EXPECT_EQ(proxy.MakeCall(""), TELEPHONY_ERR_ARGUMENT_INVALID);
67 EXPECT_EQ(proxy.MakeCall("12345"), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
68 EXPECT_EQ(proxy.AnswerCall(0, 0), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
69 EXPECT_EQ(proxy.HoldCall(0), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
70 EXPECT_EQ(proxy.UnHoldCall(0), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
71 EXPECT_EQ(proxy.SwitchCall(0), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
72 bool enabled = false;
73 EXPECT_EQ(proxy.IsNewCallAllowed(enabled), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
74 EXPECT_EQ(proxy.SetMuted(false), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
75 AudioDevice device;
76 EXPECT_EQ(proxy.SetAudioDevice(device), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
77 EXPECT_EQ(proxy.IsRinging(enabled), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
78 EXPECT_EQ(proxy.StartDtmf(0, '0'), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
79 EXPECT_EQ(proxy.StopDtmf(0), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
80 EXPECT_EQ(proxy.PostDialProceed(0, false), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
81 EXPECT_EQ(proxy.GetCallWaiting(0), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
82 EXPECT_EQ(proxy.SetCallWaiting(0, false), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
83 EXPECT_EQ(proxy.PostDialProceed(0, false), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
84 EXPECT_EQ(proxy.GetCallRestriction(0, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING),
85 TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
86 CallRestrictionInfo info;
87 EXPECT_EQ(proxy.SetCallRestriction(0, info), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
88 const char *oldPass = nullptr;
89 const char *newPass = nullptr;
90 EXPECT_EQ(proxy.SetCallRestrictionPassword(0, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING,
91 oldPass, newPass), TELEPHONY_ERR_ARGUMENT_INVALID);
92 oldPass = "str";
93 EXPECT_EQ(proxy.SetCallRestrictionPassword(0, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING,
94 oldPass, newPass), TELEPHONY_ERR_ARGUMENT_INVALID);
95 newPass = "str";
96 EXPECT_EQ(proxy.SetCallRestrictionPassword(0, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING,
97 oldPass, newPass), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
98 oldPass = nullptr;
99 EXPECT_EQ(proxy.SetCallRestrictionPassword(0, CallRestrictionType::RESTRICTION_TYPE_ALL_INCOMING,
100 oldPass, newPass), TELEPHONY_ERR_ARGUMENT_INVALID);
101 EXPECT_EQ(proxy.GetCallTransferInfo(0, CallTransferType::TRANSFER_TYPE_UNCONDITIONAL),
102 TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
103 CallTransferInfo transferInfo;
104 EXPECT_EQ(proxy.SetCallTransferInfo(0, transferInfo), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
105 EXPECT_EQ(proxy.CanSetCallTransferTime(0, enabled), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
106 }
107
108 /**
109 * @tc.number Telephony_CallManagerServiceProxy_003
110 * @tc.name test branch
111 * @tc.desc Function test
112 */
113 HWTEST_F(SpecialBranch3Test, Telephony_CallManagerServiceProxy_003, TestSize.Level1)
114 {
115 sptr<IRemoteObject> impl;
116 CallManagerServiceProxy proxy(impl);
117 EXPECT_EQ(proxy.CloseUnFinishedUssd(0), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
118 std::string code = "";
119 EXPECT_EQ(proxy.InputDialerSpecialCode(code), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
120 EXPECT_EQ(proxy.RemoveMissedIncomingCallNotification(), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
121 EXPECT_EQ(proxy.SetVoIPCallState(0), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
122 int32_t callId = 0;
123 int32_t state = 0;
124 std::string phoneNumber = "123456";
125 EXPECT_EQ(proxy.SetVoIPCallInfo(callId, state, phoneNumber), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
126 EXPECT_EQ(proxy.CancelCallUpgrade(0), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
127 EXPECT_EQ(proxy.RequestCameraCapabilities(0), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
128 EXPECT_EQ(proxy.SendCallUiEvent(0, code), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
129 EXPECT_EQ(proxy.RegisterBluetoothCallManagerCallbackPtr(code), nullptr);
130 EXPECT_EQ(proxy.SendUssdResponse(0, code), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
131 std::vector<std::string> dialingList;
132 std::vector<std::string> incomingList;
133 EXPECT_EQ(proxy.SetCallPolicyInfo(false, dialingList, false, incomingList), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
134 }
135
136 /**
137 * @tc.number Telephony_CallStatusCallbackProxy_001
138 * @tc.name test branch
139 * @tc.desc Function test
140 */
141 HWTEST_F(SpecialBranch3Test, Telephony_CallStatusCallbackProxy_001, TestSize.Level1)
142 {
143 auto callStatusCallbackProxy = std::make_shared<CallStatusCallbackProxy>(nullptr);
144 CallModeReportInfo response;
145 EXPECT_EQ(callStatusCallbackProxy->ReceiveUpdateCallMediaModeRequest(response),
146 TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
147 EXPECT_EQ(callStatusCallbackProxy->ReceiveUpdateCallMediaModeResponse(response),
148 TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
149 std::string str = "";
150 const VoipCallEventInfo info;
151 EXPECT_EQ(callStatusCallbackProxy->ReportPostDialChar(str), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
152 EXPECT_EQ(callStatusCallbackProxy->ReportPostDialDelay(str), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
153 EXPECT_EQ(callStatusCallbackProxy->UpdateVoipEventInfo(info), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
154 CallSessionReportInfo options;
155 EXPECT_EQ(callStatusCallbackProxy->HandleCallSessionEventChanged(options), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
156 PeerDimensionsReportInfo peerInfo;
157 EXPECT_EQ(callStatusCallbackProxy->HandlePeerDimensionsChanged(peerInfo), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
158 int64_t result = 0;
159 EXPECT_EQ(callStatusCallbackProxy->HandleCallDataUsageChanged(result), TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
160 CameraCapabilitiesReportInfo cameraInfo;
161 EXPECT_EQ(callStatusCallbackProxy->HandleCameraCapabilitiesChanged(cameraInfo),
162 TELEPHONY_ERR_IPC_CONNECT_STUB_FAIL);
163 }
164
165 /**
166 * @tc.number Telephony_callularCallProxy_001
167 * @tc.name test branch
168 * @tc.desc Function test
169 */
170 HWTEST_F(SpecialBranch3Test, Telephony_callularCallProxy_001, TestSize.Level1)
171 {
172 sptr<IRemoteObject> impl;
173 int32_t slotId = 0;
174 CellularCallInfo callInfo;
175 auto cellularCallProxy = std::make_shared<CellularCallProxy>(impl);
176 EXPECT_NE(cellularCallProxy->Dial(callInfo), TELEPHONY_SUCCESS);
177 EXPECT_NE(cellularCallProxy->Reject(callInfo), TELEPHONY_SUCCESS);
178 EXPECT_NE(cellularCallProxy->Answer(callInfo), TELEPHONY_SUCCESS);
179 EXPECT_NE(cellularCallProxy->HoldCall(callInfo), TELEPHONY_SUCCESS);
180 EXPECT_NE(cellularCallProxy->UnHoldCall(callInfo), TELEPHONY_SUCCESS);
181 EXPECT_NE(cellularCallProxy->SwitchCall(callInfo), TELEPHONY_SUCCESS);
182 EXPECT_NE(cellularCallProxy->CombineConference(callInfo), TELEPHONY_SUCCESS);
183 EXPECT_NE(cellularCallProxy->SeparateConference(callInfo), TELEPHONY_SUCCESS);
184 EXPECT_NE(cellularCallProxy->KickOutFromConference(callInfo), TELEPHONY_SUCCESS);
185 EXPECT_NE(cellularCallProxy->HangUpAllConnection(), TELEPHONY_SUCCESS);
186 EXPECT_NE(cellularCallProxy->StopDtmf(callInfo), TELEPHONY_SUCCESS);
187 EXPECT_NE(cellularCallProxy->StopRtt(slotId), TELEPHONY_SUCCESS);
188 EXPECT_NE(cellularCallProxy->GetDomainPreferenceMode(slotId), TELEPHONY_SUCCESS);
189 std::string value = "";
190 EXPECT_NE(cellularCallProxy->SetImsConfig(slotId, ImsConfigItem::ITEM_VIDEO_QUALITY, value), TELEPHONY_SUCCESS);
191 }
192
193 /**
194 * @tc.number Telephony_callularCallProxy_002
195 * @tc.name test branch
196 * @tc.desc Function test
197 */
198 HWTEST_F(SpecialBranch3Test, Telephony_callularCallProxy_002, TestSize.Level1)
199 {
200 sptr<IRemoteObject> impl;
201 int32_t slotId = 0;
202 CellularCallInfo callInfo;
203 CallTransferInfo ctInfo;
204 auto Proxy = std::make_shared<CellularCallProxy>(impl);
205 std::vector<std::string> numberList;
206 char cDtmfCode = '1';
207 bool proceed = false;
208 bool result = false;
209 bool enabled = false;
210 int32_t index = 1;
211 std::string cameraId = "";
212 std::string surfaceId = "123";
213 std::string msg = "";
214 sptr<Surface> surface;
215 std::string path = "";
216 std::vector<EmergencyCall> eccVec;
217 std::vector<CellularCallInfo> infos;
218 std::string number = "0123456789";
219 EXPECT_NE(Proxy->HangUp(callInfo, CallSupplementType::TYPE_DEFAULT), TELEPHONY_SUCCESS);
220 EXPECT_NE(Proxy->InviteToConference(slotId, numberList), TELEPHONY_SUCCESS);
221 EXPECT_NE(Proxy->InviteToConference(slotId, numberList), TELEPHONY_SUCCESS);
222 EXPECT_NE(Proxy->SendUpdateCallMediaModeRequest(callInfo, ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_SUCCESS);
223 EXPECT_NE(Proxy->SendUpdateCallMediaModeResponse(callInfo, ImsCallMode::CALL_MODE_AUDIO_ONLY), TELEPHONY_SUCCESS);
224 EXPECT_NE(Proxy->StartDtmf(cDtmfCode, callInfo), TELEPHONY_SUCCESS);
225 EXPECT_NE(Proxy->PostDialProceed(callInfo, 0), TELEPHONY_SUCCESS);
226 EXPECT_NE(Proxy->SendDtmf(cDtmfCode, callInfo), TELEPHONY_SUCCESS);
227 EXPECT_NE(Proxy->StartRtt(slotId, msg), TELEPHONY_SUCCESS);
228 EXPECT_NE(Proxy->SetCallTransferInfo(slotId, ctInfo), TELEPHONY_SUCCESS);
229 EXPECT_NE(Proxy->CanSetCallTransferTime(slotId, result), TELEPHONY_SUCCESS);
230 EXPECT_NE(Proxy->GetVideoCallWaiting(slotId, enabled), TELEPHONY_SUCCESS);
231 EXPECT_NE(Proxy->SetDomainPreferenceMode(slotId, -1), TELEPHONY_SUCCESS);
232 EXPECT_NE(Proxy->GetCarrierVtConfig(slotId, enabled), TELEPHONY_SUCCESS);
233 EXPECT_NE(Proxy->SetImsConfig(slotId, ImsConfigItem::ITEM_VIDEO_QUALITY, 1), TELEPHONY_SUCCESS);
234 EXPECT_NE(Proxy->ControlCamera(slotId, index, cameraId), TELEPHONY_SUCCESS);
235 EXPECT_NE(Proxy->SetPreviewWindow(slotId, index, surfaceId, surface), TELEPHONY_SUCCESS);
236 EXPECT_NE(Proxy->SetDisplayWindow(slotId, index, surfaceId, surface), TELEPHONY_SUCCESS);
237 EXPECT_NE(Proxy->SetCameraZoom(1.0), TELEPHONY_SUCCESS);
238 EXPECT_NE(Proxy->SetPausePicture(slotId, index, path), TELEPHONY_SUCCESS);
239 EXPECT_NE(Proxy->SetDeviceDirection(slotId, index, 0), TELEPHONY_SUCCESS);
240 EXPECT_NE(Proxy->SetMute(slotId, 0), TELEPHONY_SUCCESS);
241 EXPECT_NE(Proxy->SetEmergencyCallList(slotId, eccVec), TELEPHONY_SUCCESS);
242 EXPECT_NE(Proxy->ClearAllCalls(infos), TELEPHONY_SUCCESS);
243 EXPECT_NE(Proxy->CancelCallUpgrade(slotId, index), TELEPHONY_SUCCESS);
244 EXPECT_NE(Proxy->RequestCameraCapabilities(slotId, index), TELEPHONY_SUCCESS);
245 EXPECT_FALSE(Proxy->IsMmiCode(slotId, number));
246 }
247 } // namespace OHOS::Telephony
248