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
32namespace OHOS {
33namespace Telephony {
34using namespace testing::ext;
35
36namespace {
37const int32_t SIM1_SLOTID = 0;
38const int32_t SIM2_SLOTID = 1;
39const std::string PHONE_NUMBER = "00000000";
40} // namespace
41
42class BranchTest : public testing::Test {
43public:
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
51void BranchTest::SetUpTestCase()
52{
53    std::cout << "---------- CellularCallService start ------------" << std::endl;
54}
55
56void BranchTest::TearDownTestCase() {}
57
58void BranchTest::SetUp() {}
59
60void BranchTest::TearDown() {}
61
62int32_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 */
86HWTEST_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 */
135HWTEST_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 */
158HWTEST_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 */
174HWTEST_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 */
192HWTEST_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