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
18 #include "cellular_call_config.h"
19 #include "cellular_call_connection_satellite.h"
20 #include "cellular_call_handler.h"
21 #include "cellular_call_proxy.h"
22 #include "cellular_call_register.h"
23 #include "cellular_call_service.h"
24 #include "gtest/gtest.h"
25 #include "tel_ril_call_parcel.h"
26 #include "satellite_call_client.h"
27 #include "satellite_control.h"
28 #include "satellite_test.h"
29 #include "securec.h"
30 #include "standardize_utils.h"
31
32 namespace OHOS {
33 namespace Telephony {
34 using namespace testing::ext;
35
36 namespace {
37 const int32_t SIM1_SLOTID = 0;
38 const int32_t SIM2_SLOTID = 1;
39 const std::string PHONE_NUMBER = "00000000";
40 } // namespace
41
42 class BranchTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp();
47 void TearDown();
48 int32_t InitCellularCallInfo(int32_t accountId, std::string phonenumber, CellularCallInfo &callInfo);
49 };
50
SetUpTestCase()51 void BranchTest::SetUpTestCase()
52 {
53 std::cout << "---------- CellularCallService start ------------" << std::endl;
54 }
55
TearDownTestCase()56 void BranchTest::TearDownTestCase() {}
57
SetUp()58 void BranchTest::SetUp() {}
59
TearDown()60 void BranchTest::TearDown() {}
61
InitCellularCallInfo(int32_t accountId,std::string phonenumber,CellularCallInfo & callInfo)62 int32_t BranchTest::InitCellularCallInfo(int32_t accountId, std::string phonenumber, CellularCallInfo &callInfo)
63 {
64 callInfo.accountId = accountId;
65 callInfo.slotId = accountId;
66 callInfo.index = accountId;
67 callInfo.callType = CallType::TYPE_SATELLITE;
68 callInfo.videoState = 0; // 0 means audio
69 if (memset_s(callInfo.phoneNum, kMaxNumberLen, 0, kMaxNumberLen) != EOK) {
70 return TELEPHONY_ERR_MEMSET_FAIL;
71 }
72 if (phonenumber.length() > static_cast<size_t>(kMaxNumberLen)) {
73 return CALL_ERR_NUMBER_OUT_OF_RANGE;
74 }
75 if (memcpy_s(callInfo.phoneNum, kMaxNumberLen, phonenumber.c_str(), phonenumber.length()) != EOK) {
76 return TELEPHONY_ERR_MEMCPY_FAIL;
77 }
78 return TELEPHONY_SUCCESS;
79 }
80
81 /**
82 * @tc.number Telephony_CellularCallSatelliteControl_001
83 * @tc.name Test error branch
84 * @tc.desc Function test
85 */
86 HWTEST_F(BranchTest, Telephony_CellularCallSatelliteControl_001, Function | MediumTest | Level3)
87 {
88 AccessToken token;
89 SatelliteControl satelliteControl;
90 CellularCallInfo cellularCallInfo;
91 std::vector<CellularCallInfo> infos;
92 infos.emplace_back(cellularCallInfo);
93 CellularCallInfo cellularCallInfo_new;
94 int32_t invalidSupType = -1;
95 InitCellularCallInfo(SIM1_SLOTID, PHONE_NUMBER, cellularCallInfo);
96
97 satelliteControl.Dial(cellularCallInfo, true);
98 cellularCallInfo_new.slotId = 1;
99 satelliteControl.Dial(cellularCallInfo_new, true);
100 cellularCallInfo_new.callType = CallType::TYPE_SATELLITE;
101 infos.emplace_back(cellularCallInfo_new);
102 satelliteControl.HangUp(cellularCallInfo, CallSupplementType::TYPE_DEFAULT);
103 satelliteControl.HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_HOLD_WAIT);
104 satelliteControl.HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ACTIVE);
105 satelliteControl.HangUp(cellularCallInfo, CallSupplementType::TYPE_HANG_UP_ALL);
106 satelliteControl.HangUp(cellularCallInfo, static_cast<CallSupplementType>(invalidSupType));
107 satelliteControl.Answer(cellularCallInfo);
108 satelliteControl.Reject(cellularCallInfo);
109 satelliteControl.ReportHangUp(infos, SIM2_SLOTID);
110 satelliteControl.HoldCall(SIM1_SLOTID);
111 satelliteControl.UnHoldCall(SIM1_SLOTID);
112 satelliteControl.SwitchCall(SIM1_SLOTID);
113 satelliteControl.CombineConference(SIM1_SLOTID);
114 CallInfoList callInfoList;
115 satelliteControl.ReportCallsData(SIM1_SLOTID, callInfoList);
116 SatelliteCurrentCallList satellitecallInfoList;
117 satelliteControl.ReportHangUpInfo(SIM1_SLOTID);
118 satelliteControl.ReportIncomingInfo(SIM1_SLOTID, satellitecallInfoList);
119 satelliteControl.ReportUpdateInfo(SIM1_SLOTID, satellitecallInfoList);
120 SatelliteCurrentCall CallInfo;
121 satelliteControl.EncapsulationCallReportInfo(SIM1_SLOTID, CallInfo);
122 CallsReportInfo callsReportInfo;
123 satelliteControl.DeleteConnection(callsReportInfo, satellitecallInfoList);
124 satelliteControl.HangUpAllConnection(SIM1_SLOTID);
125 CLIRMode mode = DEFAULT;
126 satelliteControl.EncapsulateDialCommon(SIM1_SLOTID, PHONE_NUMBER, mode);
127 ASSERT_EQ(satelliteControl.ReportSatelliteCallsData(SIM1_SLOTID, satellitecallInfoList), TELEPHONY_SUCCESS);
128 }
129
130 /**
131 * @tc.number Telephony_CellularCallSatelliteControl_002
132 * @tc.name Test error branch
133 * @tc.desc Function test
134 */
135 HWTEST_F(BranchTest, Telephony_CellularCallSatelliteControl_002, Function | MediumTest | Level3)
136 {
137 AccessToken token;
138 SatelliteControl satelliteControl;
139 CellularCallInfo cellularCallInfo;
140 std::vector<CellularCallInfo> infos;
141 infos.emplace_back(cellularCallInfo);
142 SatelliteCurrentCallList satellitecallInfoList;
143 satellitecallInfoList.callSize = 2;
144 CallsReportInfo callsReportInfo;
145 auto connectionMap = satelliteControl.GetConnectionMap();
146 satelliteControl.connectionMap_.insert(std::make_pair(1, CellularCallConnectionSatellite()));
147 satelliteControl.ReportHangUpInfo(SIM1_SLOTID);
148 satelliteControl.DeleteConnection(callsReportInfo, satellitecallInfoList);
149 satelliteControl.ExecutePostDial(SIM1_SLOTID, 0);
150 ASSERT_NE(satelliteControl.PostDialProceed(cellularCallInfo, true), TELEPHONY_SUCCESS);
151 }
152
153 /**
154 * @tc.number Telephony_ControlBase_001
155 * @tc.name Test error branch
156 * @tc.desc Function test
157 */
158 HWTEST_F(BranchTest, Telephony_ControlBase_001, Function | MediumTest | Level3)
159 {
160 SatelliteControl satelliteControl;
161 CellularCallInfo callInfo;
162 bool isEcc = true;
163 bool isAirplaneModeOn = true;
164 bool isActivateSim = false;
165 satelliteControl.HandleEcc(callInfo, isEcc, isAirplaneModeOn, isActivateSim);
166 ASSERT_EQ(satelliteControl.SetReadyToCall(SIM1_SLOTID, true), TELEPHONY_SUCCESS);
167 }
168
169 /**
170 * @tc.number Telephony_CellularCallConnectionSatellite_001
171 * @tc.name Test error branch
172 * @tc.desc Function test
173 */
174 HWTEST_F(BranchTest, Telephony_CellularCallConnectionSatellite_001, Function | MediumTest | Level3)
175 {
176 AccessToken token;
177 CellularCallConnectionSatellite callConn;
178 DialRequestStruct dialRequest;
179 callConn.DialRequest(SIM1_SLOTID, dialRequest);
180 callConn.HangUpRequest(SIM1_SLOTID);
181 callConn.AnswerRequest(SIM1_SLOTID);
182 callConn.RejectRequest(SIM1_SLOTID);
183 callConn.GetSatelliteCallsDataRequest(SIM1_SLOTID, 0);
184 ASSERT_NE(callConn.GetCallFailReasonRequest(SIM1_SLOTID), TELEPHONY_SUCCESS);
185 }
186
187 /**
188 * @tc.number Telephony_CellularCallService_001
189 * @tc.name Test error branch
190 * @tc.desc Function test
191 */
192 HWTEST_F(BranchTest, Telephony_CellularCallService_001, Function | MediumTest | Level3)
193 {
194 CellularCallService callService;
195 CellularCallInfo satelliteCallInfo = { .callType = CallType::TYPE_SATELLITE };
196 callService.Dial(satelliteCallInfo);
197 callService.HangUp(satelliteCallInfo, CallSupplementType::TYPE_HANG_UP_HOLD_WAIT);
198 callService.Reject(satelliteCallInfo);
199 callService.Answer(satelliteCallInfo);
200 callService.HoldCall(satelliteCallInfo);
201 callService.UnHoldCall(satelliteCallInfo);
202
203 callService.GetSatelliteControl(SIM1_SLOTID);
204
205 std::shared_ptr<SatelliteControl> satelliteControl;
206 callService.SetSatelliteControl(SIM1_SLOTID, satelliteControl);
207 ASSERT_NE(callService.SwitchCall(satelliteCallInfo), TELEPHONY_SUCCESS);
208 }
209 } // namespace Telephony
210 } // namespace OHOS
211