1 /*
2  * Copyright (C) 2024 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 "activating.h"
19 #include "active.h"
20 #include "apn_manager.h"
21 #include "cellular_data_state_machine.h"
22 #include "data_connection_manager.h"
23 #include "default.h"
24 #include "disconnecting.h"
25 #include "gtest/gtest.h"
26 #include "inactive.h"
27 #include "incall_data_state_machine.h"
28 #include "tel_event_handler.h"
29 #include "telephony_types.h"
30 
31 namespace OHOS {
32 namespace Telephony {
33 using namespace testing::ext;
34 
35 static const int32_t SLEEP_TIME = 3;
36 
37 class CellularStateMachineTest : public testing::Test {
38 public:
39     static void SetUpTestCase();
40     static void TearDownTestCase();
41     void SetUp();
42     void TearDown();
43     std::shared_ptr<CellularDataStateMachine> cellularMachine;
44 };
SetUpTestCase()45 void CellularStateMachineTest::SetUpTestCase() {}
46 
TearDownTestCase()47 void CellularStateMachineTest::TearDownTestCase()
48 {
49     sleep(SLEEP_TIME);
50 }
51 
SetUp()52 void CellularStateMachineTest::SetUp() {}
53 
TearDown()54 void CellularStateMachineTest::TearDown() {}
55 
56 class CellularMachineTest : public TelEventHandler {
57 public:
CellularMachineTest()58     CellularMachineTest() : TelEventHandler("CellularDataStateMachineTest") {}
59     ~CellularMachineTest() = default;
60     std::shared_ptr<CellularDataStateMachine> CreateCellularDataConnect(int32_t slotId);
61 
62 public:
63     std::shared_ptr<CellularDataStateMachine> cellularDataStateMachine_ = nullptr;
64 };
65 
CreateCellularDataConnect(int32_t slotId)66 std::shared_ptr<CellularDataStateMachine> CellularMachineTest::CreateCellularDataConnect(int32_t slotId)
67 {
68     if (cellularDataStateMachine_ != nullptr) {
69         return cellularDataStateMachine_;
70     }
71     sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(slotId).release();
72     if (connectionManager == nullptr) {
73         return nullptr;
74     }
75     connectionManager->Init();
76     cellularDataStateMachine_ = std::make_shared<CellularDataStateMachine>(
77         connectionManager, std::static_pointer_cast<TelEventHandler>(shared_from_this()));
78     return cellularDataStateMachine_;
79 }
80 
81 /**
82  * @tc.number   Active_RefreshTcpBufferSizes_001
83  * @tc.name     test function branch
84  * @tc.desc     Function test
85  */
HWTEST_F(CellularStateMachineTest, Active_RefreshTcpBufferSizes_001, Function | MediumTest | Level1)86 HWTEST_F(CellularStateMachineTest, Active_RefreshTcpBufferSizes_001, Function | MediumTest | Level1)
87 {
88     if (cellularMachine == nullptr) {
89         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
90         cellularMachine = machine->CreateCellularDataConnect(0);
91         cellularMachine->Init();
92     }
93     auto active = static_cast<Active *>(cellularMachine->activeState_.GetRefPtr());
94     active->stateMachine_ = cellularMachine;
95     active->RefreshTcpBufferSizes();
96     ASSERT_TRUE(cellularMachine != nullptr);
97 }
98 
99 /**
100  * @tc.number   Activating_StateBegin_001
101  * @tc.name     test function branch
102  * @tc.desc     Function test
103  */
HWTEST_F(CellularStateMachineTest, Activating_StateBegin_001, Function | MediumTest | Level1)104 HWTEST_F(CellularStateMachineTest, Activating_StateBegin_001, Function | MediumTest | Level1)
105 {
106     if (cellularMachine == nullptr) {
107         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
108         cellularMachine = machine->CreateCellularDataConnect(0);
109         cellularMachine->Init();
110     }
111     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
112     activating->stateMachine_ = cellularMachine;
113     activating->StateBegin();
114     EXPECT_EQ(activating->isActive_, true);
115 }
116 
117 /**
118  * @tc.number   Activating_StateProcess_001
119  * @tc.name     test function branch
120  * @tc.desc     Function test
121  */
HWTEST_F(CellularStateMachineTest, Activating_StateProcess_001, Function | MediumTest | Level1)122 HWTEST_F(CellularStateMachineTest, Activating_StateProcess_001, Function | MediumTest | Level1)
123 {
124     if (cellularMachine == nullptr) {
125         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
126         cellularMachine = machine->CreateCellularDataConnect(0);
127         cellularMachine->Init();
128     }
129     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
130     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DRS_OR_RAT_CHANGED);
131     bool result = activating->StateProcess(event);
132     EXPECT_EQ(result, true);
133     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT);
134     result = activating->StateProcess(event);
135     EXPECT_EQ(result, true);
136     event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_RIL_SETUP_DATA_CALL);
137     result = activating->StateProcess(event);
138     EXPECT_EQ(result, false);
139     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_GET_LAST_FAIL_DONE);
140     result = activating->StateProcess(event);
141     EXPECT_EQ(result, true);
142     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_GET_RIL_BANDWIDTH);
143     result = activating->StateProcess(event);
144     EXPECT_EQ(result, false);
145     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_CONNECT_TIMEOUT_CHECK);
146     result = activating->StateProcess(event);
147     EXPECT_EQ(result, true);
148     event = AppExecFwk::InnerEvent::Get(0);
149     result = activating->StateProcess(event);
150     EXPECT_EQ(result, false);
151 }
152 
153 /**
154  * @tc.number   Activating_ProcessConnectTimeout_001
155  * @tc.name     test function branch
156  * @tc.desc     Function test
157  */
HWTEST_F(CellularStateMachineTest, Activating_ProcessConnectTimeout_001, Function | MediumTest | Level1)158 HWTEST_F(CellularStateMachineTest, Activating_ProcessConnectTimeout_001, Function | MediumTest | Level1)
159 {
160     if (cellularMachine == nullptr) {
161         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
162         cellularMachine = machine->CreateCellularDataConnect(0);
163         cellularMachine->Init();
164     }
165     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
166     cellularMachine->connectId_ = 1;
167     activating->stateMachine_ = cellularMachine;
168     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT, 1);
169     activating->ProcessConnectTimeout(event);
170     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
171 }
172 
173 /**
174  * @tc.number   Activating_ProcessConnectTimeout_002
175  * @tc.name     test function branch
176  * @tc.desc     Function test
177  */
HWTEST_F(CellularStateMachineTest, Activating_ProcessConnectTimeout_002, Function | MediumTest | Level1)178 HWTEST_F(CellularStateMachineTest, Activating_ProcessConnectTimeout_002, Function | MediumTest | Level1)
179 {
180     if (cellularMachine == nullptr) {
181         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
182         cellularMachine = machine->CreateCellularDataConnect(0);
183         cellularMachine->Init();
184     }
185     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
186     cellularMachine->TransitionTo(cellularMachine->disconnectingState_);
187     cellularMachine = nullptr;
188     activating->stateMachine_ = cellularMachine;
189     auto event = AppExecFwk::InnerEvent::Get(1);
190     activating->ProcessConnectTimeout(event);
191     EXPECT_EQ(cellularMachine == nullptr, true);
192 }
193 
194 /**
195  * @tc.number   Activating_ProcessConnectTimeout_003
196  * @tc.name     test function branch
197  * @tc.desc     Function test
198  */
HWTEST_F(CellularStateMachineTest, Activating_ProcessConnectTimeout_003, Function | MediumTest | Level1)199 HWTEST_F(CellularStateMachineTest, Activating_ProcessConnectTimeout_003, Function | MediumTest | Level1)
200 {
201     if (cellularMachine == nullptr) {
202         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
203         cellularMachine = machine->CreateCellularDataConnect(0);
204         cellularMachine->Init();
205     }
206     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
207     cellularMachine->connectId_ = 1;
208     cellularMachine->TransitionTo(cellularMachine->disconnectingState_);
209     activating->stateMachine_ = cellularMachine;
210     auto event = AppExecFwk::InnerEvent::Get(0);
211     activating->ProcessConnectTimeout(event);
212     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
213 }
214 
215 /**
216  * @tc.number   Activating_CellularDataStateMachine_001
217  * @tc.name     test function branch
218  * @tc.desc     Function test
219  */
HWTEST_F(CellularStateMachineTest, Activating_CellularDataStateMachine_001, Function | MediumTest | Level1)220 HWTEST_F(CellularStateMachineTest, Activating_CellularDataStateMachine_001, Function | MediumTest | Level1)
221 {
222     if (cellularMachine == nullptr) {
223         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
224         cellularMachine = machine->CreateCellularDataConnect(0);
225         cellularMachine->Init();
226     }
227     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
228     cellularMachine = nullptr;
229     activating->stateMachine_ = cellularMachine;
230     auto event = AppExecFwk::InnerEvent::Get(0);
231     activating->StateBegin();
232     EXPECT_EQ(activating->isActive_, false);
233     auto result = activating->RilErrorResponse(event);
234     EXPECT_EQ(result, false);
235     result = activating->StateProcess(event);
236     EXPECT_EQ(result, false);
237 }
238 
239 /**
240  * @tc.number   Disconnecting_StateBegin_001
241  * @tc.name     test function branch
242  * @tc.desc     Function test
243  */
HWTEST_F(CellularStateMachineTest, Disconnecting_StateBegin_001, Function | MediumTest | Level1)244 HWTEST_F(CellularStateMachineTest, Disconnecting_StateBegin_001, Function | MediumTest | Level1)
245 {
246     if (cellularMachine == nullptr) {
247         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
248         cellularMachine = machine->CreateCellularDataConnect(0);
249         cellularMachine->Init();
250     }
251     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
252     disconnecting->stateMachine_ = cellularMachine;
253     disconnecting->StateBegin();
254     EXPECT_EQ(disconnecting->isActive_, true);
255 }
256 
257 /**
258  * @tc.number   Disconnecting_ProcessConnectTimeout_001
259  * @tc.name     test function branch
260  * @tc.desc     Function test
261  */
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessConnectTimeout_001, Function | MediumTest | Level1)262 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessConnectTimeout_001, Function | MediumTest | Level1)
263 {
264     if (cellularMachine == nullptr) {
265         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
266         cellularMachine = machine->CreateCellularDataConnect(0);
267         cellularMachine->Init();
268     }
269     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
270     cellularMachine->connectId_ = 1;
271     disconnecting->stateMachine_ = cellularMachine;
272     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
273     disconnecting->ProcessDisconnectTimeout(event);
274     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
275 }
276 
277 /**
278  * @tc.number   Disconnecting_ProcessConnectTimeout_002
279  * @tc.name     test function branch
280  * @tc.desc     Function test
281  */
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessConnectTimeout_002, Function | MediumTest | Level1)282 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessConnectTimeout_002, Function | MediumTest | Level1)
283 {
284     if (cellularMachine == nullptr) {
285         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
286         cellularMachine = machine->CreateCellularDataConnect(0);
287         cellularMachine->Init();
288     }
289     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
290     cellularMachine->connectId_ = 1;
291     disconnecting->stateMachine_ = cellularMachine;
292     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
293     disconnecting->ProcessDisconnectTimeout(event);
294     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
295 }
296 
297 /**
298  * @tc.number   Disconnecting_ProcessRilAdapterHostDied_001
299  * @tc.name     test function branch
300  * @tc.desc     Function test
301  */
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilAdapterHostDied_001, Function | MediumTest | Level1)302 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilAdapterHostDied_001, Function | MediumTest | Level1)
303 {
304     if (cellularMachine == nullptr) {
305         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
306         cellularMachine = machine->CreateCellularDataConnect(0);
307         cellularMachine->Init();
308     }
309     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
310     disconnecting->stateMachine_ = cellularMachine;
311     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
312     disconnecting->ProcessRilAdapterHostDied(event);
313     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
314 }
315 
316 /**
317  * @tc.number   Disconnecting_ProcessRilDeactivateDataCall_001
318  * @tc.name     test function branch
319  * @tc.desc     Function test
320  */
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_001, Function | MediumTest | Level1)321 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_001, Function | MediumTest | Level1)
322 {
323     if (cellularMachine == nullptr) {
324         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
325         cellularMachine = machine->CreateCellularDataConnect(0);
326         cellularMachine->Init();
327     }
328     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
329     disconnecting->stateMachine_ = cellularMachine;
330     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
331     disconnecting->ProcessRilDeactivateDataCall(event);
332     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
333 }
334 
335 /**
336  * @tc.number   Disconnecting_ProcessRilDeactivateDataCall_002
337  * @tc.name     test function branch
338  * @tc.desc     Function test
339  */
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_002, Function | MediumTest | Level1)340 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_002, Function | MediumTest | Level1)
341 {
342     if (cellularMachine == nullptr) {
343         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
344         cellularMachine = machine->CreateCellularDataConnect(0);
345         cellularMachine->Init();
346     }
347     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
348     cellularMachine->TransitionTo(cellularMachine->defaultState_);
349     cellularMachine->stateMachineEventHandler_ = nullptr;
350     disconnecting->stateMachine_ = cellularMachine;
351     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
352     disconnecting->ProcessRilDeactivateDataCall(event);
353     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
354 }
355 
356 /**
357  * @tc.number   Disconnecting_ProcessRilDeactivateDataCall_003
358  * @tc.name     test function branch
359  * @tc.desc     Function test
360  */
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_003, Function | MediumTest | Level1)361 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_003, Function | MediumTest | Level1)
362 {
363     if (cellularMachine == nullptr) {
364         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
365         cellularMachine = machine->CreateCellularDataConnect(0);
366         cellularMachine->Init();
367     }
368     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
369     cellularMachine->TransitionTo(cellularMachine->defaultState_);
370     disconnecting->stateMachine_ = cellularMachine;
371     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
372     event = nullptr;
373     disconnecting->ProcessRilDeactivateDataCall(event);
374     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
375 }
376 
377 /**
378  * @tc.number   Disconnecting_StateProcess_001
379  * @tc.name     test function branch
380  * @tc.desc     Function test
381  */
HWTEST_F(CellularStateMachineTest, Disconnecting_StateProcess_001, Function | MediumTest | Level1)382 HWTEST_F(CellularStateMachineTest, Disconnecting_StateProcess_001, Function | MediumTest | Level1)
383 {
384     if (cellularMachine == nullptr) {
385         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
386         cellularMachine = machine->CreateCellularDataConnect(0);
387         cellularMachine->Init();
388     }
389     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
390     auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_RIL_DEACTIVATE_DATA_CALL);
391     bool result = disconnecting->StateProcess(event);
392     EXPECT_EQ(result, true);
393     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DISCONNECT_TIMEOUT_CHECK);
394     result = disconnecting->StateProcess(event);
395     EXPECT_EQ(result, true);
396     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_RIL_ADAPTER_HOST_DIED);
397     result = disconnecting->StateProcess(event);
398     EXPECT_EQ(result, true);
399     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT);
400     result = disconnecting->StateProcess(event);
401     EXPECT_EQ(result, true);
402     event = AppExecFwk::InnerEvent::Get(0);
403     result = disconnecting->StateProcess(event);
404     EXPECT_EQ(result, false);
405 }
406 
407 /**
408  * @tc.number   Disconnecting_StateProcess_002
409  * @tc.name     test function branch
410  * @tc.desc     Function test
411  */
HWTEST_F(CellularStateMachineTest, Disconnecting_StateProcess_002, Function | MediumTest | Level1)412 HWTEST_F(CellularStateMachineTest, Disconnecting_StateProcess_002, Function | MediumTest | Level1)
413 {
414     if (cellularMachine == nullptr) {
415         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
416         cellularMachine = machine->CreateCellularDataConnect(0);
417         cellularMachine->Init();
418     }
419     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
420     cellularMachine = nullptr;
421     disconnecting->stateMachine_ = cellularMachine;
422     auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_RIL_DEACTIVATE_DATA_CALL);
423     bool result = disconnecting->StateProcess(event);
424     EXPECT_EQ(result, false);
425 }
426 
427 /**
428  * @tc.number   InactiveStateProcess_001
429  * @tc.name     test function branch
430  * @tc.desc     Function test
431  */
HWTEST_F(CellularStateMachineTest, InactiveStateProcess_001, Function | MediumTest | Level1)432 HWTEST_F(CellularStateMachineTest, InactiveStateProcess_001, Function | MediumTest | Level1)
433 {
434     if (cellularMachine == nullptr) {
435         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
436         cellularMachine = machine->CreateCellularDataConnect(0);
437         cellularMachine->Init();
438     }
439     auto inactive = static_cast<Inactive *>(cellularMachine->inActiveState_.GetRefPtr());
440     inactive->stateMachine_ = cellularMachine;
441     sptr<ApnHolder> apnHolder;
442     int32_t profileId = 0;
443     int32_t radioTechnology = 0;
444     bool nonTrafficUseOnly = false;
445     bool roamingState = false;
446     bool userDataRoaming = false;
447     std::shared_ptr<DataConnectionParams> dataConnectionParams = std::make_shared<DataConnectionParams>(apnHolder,
448         profileId, radioTechnology, nonTrafficUseOnly, roamingState, userDataRoaming);
449     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT, dataConnectionParams);
450     bool result = inactive->StateProcess(event);
451     EXPECT_EQ(result, true);
452 }
453 
454 /**
455  * @tc.number   Disconnecting_ProcessDisconnectTimeout_001
456  * @tc.name     test function branch
457  * @tc.desc     Function test
458  */
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessDisconnectTimeout_001, Function | MediumTest | Level1)459 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessDisconnectTimeout_001, Function | MediumTest | Level1)
460 {
461     if (cellularMachine == nullptr) {
462         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
463         cellularMachine = machine->CreateCellularDataConnect(0);
464         cellularMachine->Init();
465     }
466     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
467     cellularMachine = nullptr;
468     disconnecting->stateMachine_ = cellularMachine;
469     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT, 0);
470     disconnecting->ProcessDisconnectTimeout(event);
471     disconnecting->StateEnd();
472     EXPECT_EQ(disconnecting->isActive_, false);
473 }
474 
475 /**
476  * @tc.number   Disconnecting_ProcessRilAdapterHostDied_002
477  * @tc.name     test function branch
478  * @tc.desc     Function test
479  */
HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilAdapterHostDied_002, Function | MediumTest | Level1)480 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilAdapterHostDied_002, Function | MediumTest | Level1)
481 {
482     if (cellularMachine == nullptr) {
483         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
484         cellularMachine = machine->CreateCellularDataConnect(0);
485         cellularMachine->Init();
486     }
487     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
488     cellularMachine->inActiveState_ = nullptr;
489     disconnecting->stateMachine_ = cellularMachine;
490     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT, 0);
491     disconnecting->ProcessRilAdapterHostDied(event);
492     EXPECT_EQ(cellularMachine->IsDisconnectingState(), false);
493 }
494 
495 /**
496  * @tc.number   Activating_RilActivatePdpContextDone_001
497  * @tc.name     test function branch
498  * @tc.desc     Function test
499  */
HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_001, Function | MediumTest | Level1)500 HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_001, Function | MediumTest | Level1)
501 {
502     if (cellularMachine == nullptr) {
503         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
504         cellularMachine = machine->CreateCellularDataConnect(0);
505         cellularMachine->Init();
506     }
507     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
508     cellularMachine = nullptr;
509     activating->stateMachine_ = cellularMachine;
510     auto event = AppExecFwk::InnerEvent::Get(0);
511     bool result = activating->RilActivatePdpContextDone(event);
512     EXPECT_EQ(result, false);
513 }
514 
515 /**
516  * @tc.number   Activating_RilActivatePdpContextDone_002
517  * @tc.name     test function branch
518  * @tc.desc     Function test
519  */
HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_002, Function | MediumTest | Level1)520 HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_002, Function | MediumTest | Level1)
521 {
522     if (cellularMachine == nullptr) {
523         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
524         cellularMachine = machine->CreateCellularDataConnect(0);
525         cellularMachine->Init();
526     }
527     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
528     cellularMachine->connectId_ = 1;
529     activating->stateMachine_ = cellularMachine;
530     std::shared_ptr<SetupDataCallResultInfo> setupDataCallResultInfo = std::make_shared<SetupDataCallResultInfo>();
531     setupDataCallResultInfo->flag = 2;
532     auto event = AppExecFwk::InnerEvent::Get(0, setupDataCallResultInfo);
533     bool result = activating->RilActivatePdpContextDone(event);
534     EXPECT_EQ(result, false);
535 }
536 
537 /**
538  * @tc.number   Activating_RilActivatePdpContextDone_003
539  * @tc.name     test function branch
540  * @tc.desc     Function test
541  */
HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_003, Function | MediumTest | Level1)542 HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_003, Function | MediumTest | Level1)
543 {
544     if (cellularMachine == nullptr) {
545         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
546         cellularMachine = machine->CreateCellularDataConnect(0);
547         cellularMachine->Init();
548     }
549     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
550     cellularMachine->connectId_ = 1;
551     activating->stateMachine_ = cellularMachine;
552     std::shared_ptr<SetupDataCallResultInfo> setupDataCallResultInfo = std::make_shared<SetupDataCallResultInfo>();
553     setupDataCallResultInfo->flag = 1;
554     setupDataCallResultInfo->reason = 1;
555     auto event = AppExecFwk::InnerEvent::Get(0, setupDataCallResultInfo);
556     bool result = activating->RilActivatePdpContextDone(event);
557     EXPECT_EQ(result, true);
558 }
559 
560 /**
561  * @tc.number   Activating_RilActivatePdpContextDone_004
562  * @tc.name     test function branch
563  * @tc.desc     Function test
564  */
HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_004, Function | MediumTest | Level1)565 HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_004, Function | MediumTest | Level1)
566 {
567     if (cellularMachine == nullptr) {
568         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
569         cellularMachine = machine->CreateCellularDataConnect(0);
570         cellularMachine->Init();
571     }
572     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
573     cellularMachine->connectId_ = 1;
574     activating->stateMachine_ = cellularMachine;
575     std::shared_ptr<SetupDataCallResultInfo> setupDataCallResultInfo = std::make_shared<SetupDataCallResultInfo>();
576     setupDataCallResultInfo->flag = 1;
577     setupDataCallResultInfo->reason = 0;
578     setupDataCallResultInfo->active = 0;
579     auto event = AppExecFwk::InnerEvent::Get(0, setupDataCallResultInfo);
580     bool result = activating->RilActivatePdpContextDone(event);
581     EXPECT_EQ(result, true);
582 }
583 
584 /**
585  * @tc.number   Activating_RilActivatePdpContextDone_005
586  * @tc.name     test function branch
587  * @tc.desc     Function test
588  */
HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_005, Function | MediumTest | Level1)589 HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_005, Function | MediumTest | Level1)
590 {
591     if (cellularMachine == nullptr) {
592         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
593         cellularMachine = machine->CreateCellularDataConnect(0);
594         cellularMachine->Init();
595     }
596     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
597     cellularMachine->connectId_ = 1;
598     activating->stateMachine_ = cellularMachine;
599     std::shared_ptr<SetupDataCallResultInfo> setupDataCallResultInfo = std::make_shared<SetupDataCallResultInfo>();
600     setupDataCallResultInfo->flag = 1;
601     setupDataCallResultInfo->reason = 0;
602     setupDataCallResultInfo->active = 1;
603     setupDataCallResultInfo->cid = 99;
604     auto event = AppExecFwk::InnerEvent::Get(0, setupDataCallResultInfo);
605     bool result = activating->RilActivatePdpContextDone(event);
606     EXPECT_EQ(result, true);
607 }
608 
609 /**
610  * @tc.number   Activating_RilErrorResponse_001
611  * @tc.name     test function branch
612  * @tc.desc     Function test
613  */
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_001, Function | MediumTest | Level1)614 HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_001, Function | MediumTest | Level1)
615 {
616     if (cellularMachine == nullptr) {
617         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
618         cellularMachine = machine->CreateCellularDataConnect(0);
619         cellularMachine->Init();
620     }
621     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
622     cellularMachine->connectId_ = 1;
623     activating->stateMachine_ = cellularMachine;
624     std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
625     radioResponseInfo->flag = 12;
626     auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
627     bool result = activating->RilErrorResponse(event);
628     EXPECT_EQ(result, false);
629 }
630 
631 /**
632  * @tc.number   Activating_RilErrorResponse_002
633  * @tc.name     test function branch
634  * @tc.desc     Function test
635  */
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_002, Function | MediumTest | Level1)636 HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_002, Function | MediumTest | Level1)
637 {
638     if (cellularMachine == nullptr) {
639         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
640         cellularMachine = machine->CreateCellularDataConnect(0);
641         cellularMachine->Init();
642     }
643     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
644     cellularMachine->connectId_ = 1;
645     activating->stateMachine_ = cellularMachine;
646     std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
647     radioResponseInfo->flag = 1;
648     radioResponseInfo->error = ErrType::ERR_GENERIC_FAILURE;
649     auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
650     bool result = activating->RilErrorResponse(event);
651     EXPECT_EQ(result, true);
652 }
653 
654 /**
655  * @tc.number   Activating_RilErrorResponse_003
656  * @tc.name     test function branch
657  * @tc.desc     Function test
658  */
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_003, Function | MediumTest | Level1)659 HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_003, Function | MediumTest | Level1)
660 {
661     if (cellularMachine == nullptr) {
662         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
663         cellularMachine = machine->CreateCellularDataConnect(0);
664         cellularMachine->Init();
665     }
666     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
667     cellularMachine->connectId_ = 1;
668     activating->stateMachine_ = cellularMachine;
669     std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
670     radioResponseInfo->flag = 1;
671     radioResponseInfo->error = ErrType::ERR_INVALID_RESPONSE;
672     auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
673     bool result = activating->RilErrorResponse(event);
674     EXPECT_EQ(result, true);
675 }
676 
677 /**
678  * @tc.number   Activating_RilErrorResponse_004
679  * @tc.name     test function branch
680  * @tc.desc     Function test
681  */
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_004, Function | MediumTest | Level1)682 HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_004, Function | MediumTest | Level1)
683 {
684     if (cellularMachine == nullptr) {
685         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
686         cellularMachine = machine->CreateCellularDataConnect(0);
687         cellularMachine->Init();
688     }
689     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
690     cellularMachine->connectId_ = 1;
691     activating->stateMachine_ = cellularMachine;
692     std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
693     radioResponseInfo->flag = 1;
694     radioResponseInfo->error = ErrType::NONE;
695     auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
696     bool result = activating->RilErrorResponse(event);
697     EXPECT_EQ(result, true);
698 }
699 
700 /**
701  * @tc.number   Activating_RilErrorResponse_005
702  * @tc.name     test function branch
703  * @tc.desc     Function test
704  */
HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_005, Function | MediumTest | Level1)705 HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_005, Function | MediumTest | Level1)
706 {
707     if (cellularMachine == nullptr) {
708         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
709         cellularMachine = machine->CreateCellularDataConnect(0);
710         cellularMachine->Init();
711     }
712     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
713     cellularMachine = nullptr;
714     activating->stateMachine_ = cellularMachine;
715     auto event = AppExecFwk::InnerEvent::Get(0);
716     bool result = activating->RilErrorResponse(event);
717     EXPECT_EQ(result, false);
718 }
719 
720 /**
721  * @tc.number   Active_CellularDataStateMachine_001
722  * @tc.name     test function branch
723  * @tc.desc     Function test
724  */
HWTEST_F(CellularStateMachineTest, Active_CellularDataStateMachine_001, Function | MediumTest | Level1)725 HWTEST_F(CellularStateMachineTest, Active_CellularDataStateMachine_001, Function | MediumTest | Level1)
726 {
727     if (cellularMachine == nullptr) {
728         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
729         cellularMachine = machine->CreateCellularDataConnect(0);
730         cellularMachine->Init();
731     }
732     auto active = static_cast<Active *>(cellularMachine->activeState_.GetRefPtr());
733     cellularMachine = nullptr;
734     active->stateMachine_ = cellularMachine;
735     active->StateBegin();
736     auto event = AppExecFwk::InnerEvent::Get(0);
737     bool result = active->ProcessDisconnectDone(event);
738     EXPECT_EQ(result, false);
739     result = active->ProcessDisconnectAllDone(event);
740     EXPECT_EQ(result, false);
741     result = active->ProcessLostConnection(event);
742     EXPECT_EQ(result, false);
743     result = active->ProcessLinkCapabilityChanged(event);
744     EXPECT_EQ(result, false);
745     result = active->ProcessDataConnectionRoamOn(event);
746     EXPECT_EQ(result, false);
747     active->RefreshConnectionBandwidths();
748     result = active->ProcessDataConnectionRoamOff(event);
749     EXPECT_EQ(result, false);
750     active->RefreshTcpBufferSizes();
751     result = active->ProcessDataConnectionVoiceCallStartedOrEnded(event);
752     EXPECT_EQ(result, false);
753 }
754 } // namespace Telephony
755 } // namespace OHOS