1 /*
2 * Copyright (C) 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 #define private public
16 #define protected public
17 #include "apn_holder.h"
18 #include "apn_item.h"
19 #include "cellular_data_controller.h"
20 #include "cellular_data_dump_helper.h"
21 #include "cellular_data_handler.h"
22 #include "cellular_data_hisysevent.h"
23 #include "cellular_data_rdb_observer.h"
24 #include "cellular_data_roaming_observer.h"
25 #include "cellular_data_service.h"
26 #include "cellular_data_setting_observer.h"
27 #include "cellular_data_utils.h"
28 #include "common_event_manager.h"
29 #include "common_event_support.h"
30 #include "data_connection_manager.h"
31 #include "data_connection_monitor.h"
32 #include "gtest/gtest.h"
33 #include "net_manager_call_back.h"
34 #include "net_manager_tactics_call_back.h"
35 #include "network_search_callback.h"
36 #include "telephony_errors.h"
37 #include "telephony_hisysevent.h"
38 #include "telephony_log_wrapper.h"
39
40 namespace OHOS {
41 namespace Telephony {
42 using namespace testing::ext;
43
44 namespace {
45 const int32_t INVALID_SLOTID = -1;
46 const int32_t INVALID_SLOTID_TWO = 5;
47 const int32_t INVALID_CID = -1;
48 const int32_t INVALID_FD = -1;
49 } // namespace
50
51 class DemoHandler : public AppExecFwk::EventHandler {
52 public:
DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> & runner)53 explicit DemoHandler(std::shared_ptr<AppExecFwk::EventRunner> &runner) : AppExecFwk::EventHandler(runner) {}
~DemoHandler()54 virtual ~DemoHandler() {}
ProcessEvent(const AppExecFwk::InnerEvent::Pointer & event)55 void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) {}
56 };
57
58 class BranchTest : public testing::Test {
59 public:
60 static void SetUpTestCase();
61 static void TearDownTestCase();
62 void SetUp();
63 void TearDown();
64 };
SetUpTestCase()65 void BranchTest::SetUpTestCase() {}
66
TearDownTestCase()67 void BranchTest::TearDownTestCase() {}
68
SetUp()69 void BranchTest::SetUp() {}
70
TearDown()71 void BranchTest::TearDown() {}
72
73 /**
74 * @tc.number Telephony_CellularDataHandler_001
75 * @tc.name test error branch
76 * @tc.desc Function test
77 */
78 HWTEST_F(BranchTest, Telephony_CellularDataHandler_001, Function | MediumTest | Level1)
79 {
80 std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create("test");
81 EventFwk::MatchingSkills matchingSkills;
82 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
83 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
84 CellularDataHandler cellularDataHandler { runner, subscriberInfo, 0 };
85 NetRequest request;
86 ASSERT_FALSE(cellularDataHandler.ReleaseNet(request));
87 ASSERT_FALSE(cellularDataHandler.RequestNet(request));
88 auto event = AppExecFwk::InnerEvent::Get(0);
89 event = nullptr;
90 cellularDataHandler.ProcessEvent(event);
91 EventFwk::CommonEventData data;
92 cellularDataHandler.OnReceiveEvent(data);
93 ASSERT_NE(cellularDataHandler.SetCellularDataEnable(true), TELEPHONY_ERR_SUCCESS);
94 bool dataEnaled = false;
95 cellularDataHandler.IsCellularDataEnabled(dataEnaled);
96 ASSERT_FALSE(dataEnaled);
97 bool dataRoamingEnabled = false;
98 cellularDataHandler.IsCellularDataRoamingEnabled(dataRoamingEnabled);
99 ASSERT_FALSE(dataRoamingEnabled);
100 ASSERT_NE(cellularDataHandler.SetCellularDataRoamingEnabled(true), TELEPHONY_ERR_SUCCESS);
101 ASSERT_EQ(ApnProfileState::PROFILE_STATE_IDLE, cellularDataHandler.GetCellularDataState());
102 ASSERT_EQ(ApnProfileState::PROFILE_STATE_IDLE, cellularDataHandler.GetCellularDataState(""));
103 sptr<ApnHolder> apnHolder;
104 DisConnectionReason reason = cellularDataHandler.GetDisConnectionReason();
105 cellularDataHandler.ClearConnection(apnHolder, reason);
106 cellularDataHandler.EstablishAllApnsIfConnectable();
107 cellularDataHandler.ClearAllConnections(reason);
108 cellularDataHandler.GetSlotId();
109 ASSERT_FALSE(cellularDataHandler.HandleApnChanged());
110 cellularDataHandler.HandleApnChanged(event);
111 cellularDataHandler.GetCellularDataFlowType();
112 cellularDataHandler.SetPolicyDataOn(true);
113 ASSERT_FALSE(cellularDataHandler.IsRestrictedMode());
114 cellularDataHandler.GetDisConnectionReason();
115 ASSERT_FALSE(cellularDataHandler.HasInternetCapability(0));
116 ASSERT_EQ(nullptr, cellularDataHandler.FindIdleCellularDataConnection());
117 cellularDataHandler.AttemptEstablishDataConnection(apnHolder);
118 ASSERT_FALSE(cellularDataHandler.CheckAttachAndSimState(apnHolder));
119 ASSERT_FALSE(cellularDataHandler.CheckRoamingState(apnHolder));
120 ASSERT_FALSE(cellularDataHandler.CheckApnState(apnHolder));
121 }
122
123 /**
124 * @tc.number Telephony_CellularDataHandler_002
125 * @tc.name test error branch
126 * @tc.desc Function test
127 */
128 HWTEST_F(BranchTest, Telephony_CellularDataHandler_002, Function | MediumTest | Level1)
129 {
130 std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create("test");
131 EventFwk::MatchingSkills matchingSkills;
132 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
133 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
134 CellularDataHandler cellularDataHandler { runner, subscriberInfo, 0 };
135 NetRequest request;
136 auto event = AppExecFwk::InnerEvent::Get(0);
137 event = nullptr;
138 sptr<ApnHolder> apnHolder;
139 cellularDataHandler.RadioPsConnectionAttached(event);
140 cellularDataHandler.RadioPsConnectionDetached(event);
141 cellularDataHandler.RoamingStateOn(event);
142 cellularDataHandler.RoamingStateOff(event);
143 cellularDataHandler.EstablishDataConnectionComplete(event);
144 cellularDataHandler.DisconnectDataComplete(event);
145 cellularDataHandler.MsgEstablishDataConnection(event);
146 cellularDataHandler.MsgRequestNetwork(event);
147 cellularDataHandler.HandleSettingSwitchChanged(event);
148 cellularDataHandler.HandleVoiceCallChanged(0);
149 cellularDataHandler.HandleSimStateOrRecordsChanged(event);
150 cellularDataHandler.HandleSimAccountLoaded(event);
151 cellularDataHandler.HandleRadioStateChanged(event);
152 cellularDataHandler.SetRilAttachApnResponse(event);
153 cellularDataHandler.GetDefaultConfiguration();
154 cellularDataHandler.HandleRadioNrStateChanged(event);
155 cellularDataHandler.HandleRadioNrFrequencyChanged(event);
156 cellularDataHandler.HandleDBSettingEnableChanged(event);
157 cellularDataHandler.HandleDBSettingRoamingChanged(event);
158 cellularDataHandler.SetDataPermittedResponse(event);
159 cellularDataHandler.RegisterDataSettingObserver();
160 cellularDataHandler.UnRegisterDataSettingObserver();
161 ASSERT_FALSE(cellularDataHandler.HasAnyHigherPriorityConnection(apnHolder));
162 }
163
164 /**
165 * @tc.number Telephony_CellularDataHandler_003
166 * @tc.name test error branch
167 * @tc.desc Function test
168 */
169 HWTEST_F(BranchTest, Telephony_CellularDataHandler_003, Function | MediumTest | Level3)
170 {
171 std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create("test");
172 EventFwk::MatchingSkills matchingSkills;
173 matchingSkills.AddEvent(EventFwk::CommonEventSupport::COMMON_EVENT_CALL_STATE_CHANGED);
174 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
175 CellularDataHandler cellularDataHandler { runner, subscriberInfo, INVALID_SLOTID };
176 cellularDataHandler.apnManager_ = std::make_unique<ApnManager>().release();
177 NetRequest request;
178 ASSERT_FALSE(cellularDataHandler.ReleaseNet(request));
179 sptr<ApnHolder> apnHolder = new ApnHolder("", 0);
180 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
181 cellularDataHandler.ClearConnection(apnHolder, reason);
182 cellularDataHandler.EstablishAllApnsIfConnectable();
183 cellularDataHandler.ClearAllConnections(reason);
184 cellularDataHandler.connectionManager_ = std::make_unique<DataConnectionManager>(runner, INVALID_SLOTID).release();
185 cellularDataHandler.ClearAllConnections(reason);
186 cellularDataHandler.EstablishAllApnsIfConnectable();
187 ASSERT_FALSE(cellularDataHandler.CheckApnState(apnHolder));
188 cellularDataHandler.AttemptEstablishDataConnection(apnHolder);
189 cellularDataHandler.connectionManager_ = nullptr;
190 auto event = AppExecFwk::InnerEvent::Get(0);
191 event = nullptr;
192 cellularDataHandler.MsgEstablishDataConnection(event);
193 ASSERT_FALSE(cellularDataHandler.HasAnyHigherPriorityConnection(apnHolder));
194 cellularDataHandler.connectionManager_ = std::make_unique<DataConnectionManager>(runner, INVALID_SLOTID).release();
195 ASSERT_FALSE(cellularDataHandler.HasInternetCapability(INVALID_CID));
196 }
197
198 /**
199 * @tc.number Telephony_CellularDataService_001
200 * @tc.name test error branch
201 * @tc.desc Function test
202 */
203 HWTEST_F(BranchTest, Telephony_CellularDataService_001, Function | MediumTest | Level3)
204 {
205 CellularDataService service;
206 std::vector<std::u16string> strV;
207 ASSERT_EQ(TELEPHONY_ERR_FAIL, service.Dump(INVALID_FD, strV));
208 service.state_ = ServiceRunningState::STATE_RUNNING;
209 service.OnStart();
210 bool dataEnabled = false;
211 bool dataRoamingEnabled = false;
212 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataEnabled(dataEnabled));
213 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularData(false));
214 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataState());
215 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.IsCellularDataRoamingEnabled(INVALID_SLOTID, dataRoamingEnabled));
216 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.EnableCellularDataRoaming(INVALID_SLOTID, false));
217 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HandleApnChanged(INVALID_SLOTID));
218 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetDefaultCellularDataSlotId());
219 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.SetDefaultCellularDataSlotId(INVALID_SLOTID));
220 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.GetCellularDataFlowType());
221 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.HasInternetCapability(INVALID_SLOTID, 0));
222 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearCellularDataConnections(INVALID_SLOTID));
223 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
224 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ClearAllConnections(INVALID_SLOTID, reason));
225 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.StrategySwitch(INVALID_SLOTID, false));
226 NetRequest request;
227 request.ident = "simId12";
228 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.RequestNet(request));
229 request.ident = "simId2";
230 ASSERT_NE(TELEPHONY_ERR_SUCCESS, service.ReleaseNet(request));
231 ASSERT_FALSE(service.CheckParamValid(INVALID_SLOTID));
232 ASSERT_FALSE(service.CheckParamValid(INVALID_SLOTID_TWO));
233 }
234
235 /**
236 * @tc.number CellularDataController_001
237 * @tc.name test error branch
238 * @tc.desc Function test
239 */
240 HWTEST_F(BranchTest, Telephony_CellularDataController_001, Function | MediumTest | Level3)
241 {
242 std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create("test");
243 CellularDataController controller { runner, 0 };
244 controller.RegisterEvents();
245 controller.Init();
246 controller.cellularDataHandler_ = nullptr;
247 controller.cellularDataRdbObserver_ = nullptr;
248 NetRequest request;
249 ASSERT_FALSE(controller.ReleaseNet(request));
250 ASSERT_FALSE(controller.RequestNet(request));
251 ASSERT_NE(controller.SetCellularDataEnable(true), TELEPHONY_ERR_SUCCESS);
252 bool dataEnabled = false;
253 controller.IsCellularDataEnabled(dataEnabled);
254 ASSERT_FALSE(dataEnabled);
255 ASSERT_NE(controller.SetCellularDataRoamingEnabled(true), TELEPHONY_ERR_SUCCESS);
256 EXPECT_EQ(ApnProfileState::PROFILE_STATE_FAILED, controller.GetCellularDataState());
257 EXPECT_EQ(ApnProfileState::PROFILE_STATE_FAILED, controller.GetCellularDataState(""));
258 bool dataRoamingEnabled = false;
259 controller.IsCellularDataRoamingEnabled(dataRoamingEnabled);
260 ASSERT_FALSE(dataRoamingEnabled);
261 controller.SetDataPermitted(true);
262 ASSERT_FALSE(controller.HandleApnChanged());
263 controller.EstablishDataConnection();
264 auto event = AppExecFwk::InnerEvent::Get(0);
265 controller.ProcessEvent(event);
266 event = nullptr;
267 controller.ProcessEvent(event);
268 controller.RegisterEvents();
269 ASSERT_FALSE(controller.IsRestrictedMode());
270 ASSERT_EQ(DisConnectionReason::REASON_NORMAL, controller.GetDisConnectionReason());
271 controller.HasInternetCapability(0);
272 DisConnectionReason reason = DisConnectionReason::REASON_NORMAL;
273 ASSERT_FALSE(controller.ClearAllConnections(reason));
274 controller.UnRegisterEvents();
275 ASSERT_FALSE(controller.HandleApnChanged());
276 ASSERT_FALSE(controller.GetCellularDataFlowType());
277 }
278
279 /**
280 * @tc.number CellularDataConnectionManager_001
281 * @tc.name test error branch
282 * @tc.desc Function test
283 */
284 HWTEST_F(BranchTest, Telephony_CellularDataConnectionManager_001, Function | MediumTest | Level3)
285 {
286 std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create("test");
287 DataConnectionManager con { runner, 0 };
288 con.connectionMonitor_ = nullptr;
289 con.ccmDefaultState_ = nullptr;
290 std::shared_ptr<CellularDataStateMachine> stateMachine = nullptr;
291 con.RemoveConnectionStateMachine(stateMachine);
292 ASSERT_TRUE(con.GetActiveConnectionByCid(0) == nullptr);
293 ASSERT_TRUE(con.isNoActiveConnection());
294 auto event = AppExecFwk::InnerEvent::Get(0);
295 event = nullptr;
296 CcmDefaultState ccmDefaultState { con, "CcmDefaultState" };
297 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
298 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_CONNECTED);
299 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
300 event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_DATA_CALL_LIST_CHANGED);
301 ASSERT_TRUE(ccmDefaultState.StateProcess(event));
302 event = AppExecFwk::InnerEvent::Get(0);
303 ASSERT_FALSE(ccmDefaultState.StateProcess(event));
304 ccmDefaultState.RadioDataCallListChanged(event);
305 ccmDefaultState.UpdateNetworkInfo(event);
306 con.GetDataFlowType();
307 con.SetDataFlowType(CellDataFlowType::DATA_FLOW_TYPE_NONE);
308 ASSERT_EQ("", con.GetTcpBufferByRadioTech(0));
309 ASSERT_TRUE(con.GetBandwidthsByRadioTech(0).upBandwidth == DEFAULT_BANDWIDTH);
310 }
311
312 /**
313 * @tc.number DataConnectionMonitor_001
314 * @tc.name test error branch
315 * @tc.desc Function test
316 */
317 HWTEST_F(BranchTest, Telephony_DataConnectionMonitor_001, Function | MediumTest | Level3)
318 {
319 std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create("test");
320 DataConnectionMonitor mon { runner, 0 };
321 mon.trafficManager_ = nullptr;
322 mon.stallDetectionTrafficManager_ = nullptr;
323 mon.UpdateFlowInfo();
324 auto event = AppExecFwk::InnerEvent::Get(0);
325 mon.SetPreferredNetworkPara(event);
326 mon.UpdateDataFlowType();
327 mon.ProcessEvent(event);
328 event = nullptr;
329 mon.ProcessEvent(event);
330 ASSERT_EQ(CellDataFlowType::DATA_FLOW_TYPE_NONE, mon.GetDataFlowType());
331 }
332
333 /**
334 * @tc.number CellularDataUtils_001
335 * @tc.name test error branch
336 * @tc.desc Function test
337 */
338 HWTEST_F(BranchTest, Telephony_CellularDataUtils_001, Function | MediumTest | Level3)
339 {
340 ASSERT_EQ("unknown",
341 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_UNKNOWN)));
342 ASSERT_EQ(
343 "EDGE", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_GSM)));
344 ASSERT_EQ("1xRTT",
345 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_1XRTT)));
346 ASSERT_EQ("UMTS",
347 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_WCDMA)));
348 ASSERT_EQ(
349 "HSPA", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_HSPA)));
350 ASSERT_EQ("HSPAP",
351 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_HSPAP)));
352 ASSERT_EQ("TD-SCDMA",
353 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_TD_SCDMA)));
354 ASSERT_EQ(
355 "EVDO", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_EVDO)));
356 ASSERT_EQ("eHRPD",
357 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_EHRPD)));
358 ASSERT_EQ(
359 "LTE", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_LTE)));
360 ASSERT_EQ("LTE_CA",
361 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_LTE_CA)));
362 ASSERT_EQ("IWAN",
363 CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_IWLAN)));
364 ASSERT_EQ(
365 "NR", CellularDataUtils::ConvertRadioTechToRadioName(static_cast<int32_t>(RadioTech::RADIO_TECHNOLOGY_NR)));
366 ASSERT_FALSE(CellularDataUtils::IsDigit(""));
367 ASSERT_TRUE(CellularDataUtils::Split("", "").empty());
368 AddressInfo info;
369 ASSERT_TRUE(CellularDataUtils::ParseDotIpData(
370 "a1.a2.a3.a4.a5.a6.a7.a8.a9.a10.a11.a12.a13.a14.a15.a16.m1.m2.m3.m4.m5.m6.m7.m8.m9.m10.m11.m12.m13.m14.m15.m16",
371 info));
372 ASSERT_TRUE(CellularDataUtils::ParseDotIpData("a1.a2.a3.a4.m1.m2.m3.m4", info));
373 }
374
375 } // namespace Telephony
376 } // namespace OHOS
377