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 #include "core_service_client.h"
31 
32 namespace OHOS {
33 namespace Telephony {
34 using namespace testing::ext;
35 
36 static const int32_t SLEEP_TIME = 3;
37 
38 class CellularStateMachineTest : public testing::Test {
39 public:
40     static void SetUpTestCase();
41     static void TearDownTestCase();
42     static bool HasSimCard(const int32_t slotId);
43     void SetUp();
44     void TearDown();
45     std::shared_ptr<CellularDataStateMachine> cellularMachine;
46 };
SetUpTestCase()47 void CellularStateMachineTest::SetUpTestCase() {}
48 
TearDownTestCase()49 void CellularStateMachineTest::TearDownTestCase()
50 {
51     sleep(SLEEP_TIME);
52 }
53 
SetUp()54 void CellularStateMachineTest::SetUp() {}
55 
TearDown()56 void CellularStateMachineTest::TearDown() {}
57 
HasSimCard(const int32_t slotId)58 bool CellularStateMachineTest::HasSimCard(const int32_t slotId)
59 {
60     bool hasSimCard = false;
61     DelayedRefSingleton<CoreServiceClient>::GetInstance().HasSimCard(slotId, hasSimCard);
62     return hasSimCard;
63 }
64 
65 class CellularMachineTest : public TelEventHandler {
66 public:
CellularMachineTest()67     CellularMachineTest() : TelEventHandler("CellularDataStateMachineTest") {}
68     ~CellularMachineTest() = default;
69     std::shared_ptr<CellularDataStateMachine> CreateCellularDataConnect(int32_t slotId);
70 
71 public:
72     std::shared_ptr<CellularDataStateMachine> cellularDataStateMachine_ = nullptr;
73 };
74 
CreateCellularDataConnect(int32_t slotId)75 std::shared_ptr<CellularDataStateMachine> CellularMachineTest::CreateCellularDataConnect(int32_t slotId)
76 {
77     if (cellularDataStateMachine_ != nullptr) {
78         return cellularDataStateMachine_;
79     }
80     sptr<DataConnectionManager> connectionManager = std::make_unique<DataConnectionManager>(slotId).release();
81     if (connectionManager == nullptr) {
82         return nullptr;
83     }
84     connectionManager->Init();
85     cellularDataStateMachine_ = std::make_shared<CellularDataStateMachine>(
86         connectionManager, std::static_pointer_cast<TelEventHandler>(shared_from_this()));
87     return cellularDataStateMachine_;
88 }
89 
90 /**
91  * @tc.number   Active_RefreshTcpBufferSizes_001
92  * @tc.name     test function branch
93  * @tc.desc     Function test
94  */
95 HWTEST_F(CellularStateMachineTest, Active_RefreshTcpBufferSizes_001, Function | MediumTest | Level1)
96 {
97     if (cellularMachine == nullptr) {
98         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
99         cellularMachine = machine->CreateCellularDataConnect(0);
100         cellularMachine->Init();
101     }
102     auto active = static_cast<Active *>(cellularMachine->activeState_.GetRefPtr());
103     active->stateMachine_ = cellularMachine;
104     active->RefreshTcpBufferSizes();
105     ASSERT_TRUE(cellularMachine != nullptr);
106 }
107 
108 /**
109  * @tc.number   Activating_StateBegin_001
110  * @tc.name     test function branch
111  * @tc.desc     Function test
112  */
113 HWTEST_F(CellularStateMachineTest, Activating_StateBegin_001, Function | MediumTest | Level1)
114 {
115     if (cellularMachine == nullptr) {
116         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
117         cellularMachine = machine->CreateCellularDataConnect(0);
118         cellularMachine->Init();
119     }
120     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
121     activating->stateMachine_ = cellularMachine;
122     activating->StateBegin();
123     EXPECT_EQ(activating->isActive_, true);
124 }
125 
126 /**
127  * @tc.number   Activating_DataCallPdpError_001
128  * @tc.name     test function branch
129  * @tc.desc     Function test
130  */
131 HWTEST_F(CellularStateMachineTest, Activating_DataCallPdpError_001, Function | MediumTest | Level1)
132 {
133     if (cellularMachine == nullptr) {
134         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
135         cellularMachine = machine->CreateCellularDataConnect(0);
136         cellularMachine->Init();
137     }
138     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
139     auto result = activating->DataCallPdpError(96);
140     EXPECT_EQ(result, DisConnectionReason::REASON_CLEAR_CONNECTION);
141     result = activating->DataCallPdpError(114);
142     EXPECT_EQ(result, DisConnectionReason::REASON_CLEAR_CONNECTION);
143 }
144 
145 /**
146  * @tc.number   Activating_StateProcess_001
147  * @tc.name     test function branch
148  * @tc.desc     Function test
149  */
150 HWTEST_F(CellularStateMachineTest, Activating_StateProcess_001, Function | MediumTest | Level1)
151 {
152     if (cellularMachine == nullptr) {
153         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
154         cellularMachine = machine->CreateCellularDataConnect(0);
155         cellularMachine->Init();
156     }
157     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
158     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DRS_OR_RAT_CHANGED);
159     bool result = activating->StateProcess(event);
160     EXPECT_EQ(result, true);
161     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT);
162     result = activating->StateProcess(event);
163     EXPECT_EQ(result, true);
164     event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_RIL_SETUP_DATA_CALL);
165     result = activating->StateProcess(event);
166     EXPECT_EQ(result, false);
167     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_GET_LAST_FAIL_DONE);
168     result = activating->StateProcess(event);
169     EXPECT_EQ(result, true);
170     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_GET_RIL_BANDWIDTH);
171     result = activating->StateProcess(event);
172     EXPECT_EQ(result, false);
173     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_CONNECT_TIMEOUT_CHECK);
174     result = activating->StateProcess(event);
175     EXPECT_EQ(result, true);
176     event = AppExecFwk::InnerEvent::Get(0);
177     result = activating->StateProcess(event);
178     EXPECT_EQ(result, false);
179 }
180 
181 /**
182  * @tc.number   Activating_ProcessConnectTimeout_001
183  * @tc.name     test function branch
184  * @tc.desc     Function test
185  */
186 HWTEST_F(CellularStateMachineTest, Activating_ProcessConnectTimeout_001, Function | MediumTest | Level1)
187 {
188     if (!HasSimCard(DEFAULT_SIM_SLOT_ID)) {
189         return;
190     }
191     if (cellularMachine == nullptr) {
192         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
193         cellularMachine = machine->CreateCellularDataConnect(0);
194         cellularMachine->Init();
195     }
196     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
197     cellularMachine->connectId_ = 1;
198     activating->stateMachine_ = cellularMachine;
199     auto event = AppExecFwk::InnerEvent::Get(1);
200     activating->ProcessConnectTimeout(event);
201     EXPECT_EQ(cellularMachine->IsInactiveState(), true);
202 }
203 
204 /**
205  * @tc.number   Activating_ProcessConnectTimeout_002
206  * @tc.name     test function branch
207  * @tc.desc     Function test
208  */
209 HWTEST_F(CellularStateMachineTest, Activating_ProcessConnectTimeout_002, Function | MediumTest | Level1)
210 {
211     if (!HasSimCard(DEFAULT_SIM_SLOT_ID)) {
212         return;
213     }
214     if (cellularMachine == nullptr) {
215         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
216         cellularMachine = machine->CreateCellularDataConnect(0);
217         cellularMachine->Init();
218     }
219     auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
220     cellularMachine->connectId_ = 1;
221     activating->stateMachine_ = cellularMachine;
222     auto event = AppExecFwk::InnerEvent::Get(0);
223     activating->ProcessConnectTimeout(event);
224     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
225 }
226 
227 /**
228  * @tc.number   Disconnecting_StateBegin_001
229  * @tc.name     test function branch
230  * @tc.desc     Function test
231  */
232 HWTEST_F(CellularStateMachineTest, Disconnecting_StateBegin_001, Function | MediumTest | Level1)
233 {
234     if (cellularMachine == nullptr) {
235         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
236         cellularMachine = machine->CreateCellularDataConnect(0);
237         cellularMachine->Init();
238     }
239     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
240     disconnecting->stateMachine_ = cellularMachine;
241     disconnecting->StateBegin();
242     EXPECT_EQ(disconnecting->isActive_, true);
243 }
244 
245 /**
246  * @tc.number   Disconnecting_ProcessConnectTimeout_001
247  * @tc.name     test function branch
248  * @tc.desc     Function test
249  */
250 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessConnectTimeout_001, Function | MediumTest | Level1)
251 {
252     if (cellularMachine == nullptr) {
253         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
254         cellularMachine = machine->CreateCellularDataConnect(0);
255         cellularMachine->Init();
256     }
257     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
258     cellularMachine->connectId_ = 1;
259     disconnecting->stateMachine_ = cellularMachine;
260     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
261     disconnecting->ProcessDisconnectTimeout(event);
262     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
263 }
264 
265 /**
266  * @tc.number   Disconnecting_ProcessConnectTimeout_002
267  * @tc.name     test function branch
268  * @tc.desc     Function test
269  */
270 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessConnectTimeout_002, Function | MediumTest | Level1)
271 {
272     if (cellularMachine == nullptr) {
273         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
274         cellularMachine = machine->CreateCellularDataConnect(0);
275         cellularMachine->Init();
276     }
277     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
278     cellularMachine->connectId_ = 1;
279     disconnecting->stateMachine_ = cellularMachine;
280     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
281     disconnecting->ProcessDisconnectTimeout(event);
282     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
283 }
284 
285 /**
286  * @tc.number   Disconnecting_ProcessRilAdapterHostDied_001
287  * @tc.name     test function branch
288  * @tc.desc     Function test
289  */
290 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilAdapterHostDied_001, Function | MediumTest | Level1)
291 {
292     if (!HasSimCard(DEFAULT_SIM_SLOT_ID)) {
293         return;
294     }
295     if (cellularMachine == nullptr) {
296         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
297         cellularMachine = machine->CreateCellularDataConnect(0);
298         cellularMachine->Init();
299     }
300     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
301     disconnecting->stateMachine_ = cellularMachine;
302     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
303     disconnecting->ProcessRilAdapterHostDied(event);
304     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
305 }
306 
307 /**
308  * @tc.number   Disconnecting_ProcessRilDeactivateDataCall_001
309  * @tc.name     test function branch
310  * @tc.desc     Function test
311  */
312 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_001, Function | MediumTest | Level1)
313 {
314     if (!HasSimCard(DEFAULT_SIM_SLOT_ID)) {
315         return;
316     }
317     if (cellularMachine == nullptr) {
318         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
319         cellularMachine = machine->CreateCellularDataConnect(0);
320         cellularMachine->Init();
321     }
322     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
323     disconnecting->stateMachine_ = cellularMachine;
324     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
325     disconnecting->ProcessRilDeactivateDataCall(event);
326     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
327 }
328 
329 /**
330  * @tc.number   Disconnecting_ProcessRilDeactivateDataCall_002
331  * @tc.name     test function branch
332  * @tc.desc     Function test
333  */
334 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_002, Function | MediumTest | Level1)
335 {
336     if (!HasSimCard(DEFAULT_SIM_SLOT_ID)) {
337         return;
338     }
339     if (cellularMachine == nullptr) {
340         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
341         cellularMachine = machine->CreateCellularDataConnect(0);
342         cellularMachine->Init();
343     }
344     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
345     cellularMachine->stateMachineEventHandler_ = nullptr;
346     disconnecting->stateMachine_ = cellularMachine;
347     auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT);
348     disconnecting->ProcessRilDeactivateDataCall(event);
349     EXPECT_EQ(cellularMachine->IsInactiveState(), false);
350 }
351 
352 /**
353  * @tc.number   Disconnecting_StateProcess_001
354  * @tc.name     test function branch
355  * @tc.desc     Function test
356  */
357 HWTEST_F(CellularStateMachineTest, Disconnecting_StateProcess_001, Function | MediumTest | Level1)
358 {
359     if (cellularMachine == nullptr) {
360         std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
361         cellularMachine = machine->CreateCellularDataConnect(0);
362         cellularMachine->Init();
363     }
364     auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
365     auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_RIL_DEACTIVATE_DATA_CALL);
366     bool result = disconnecting->StateProcess(event);
367     EXPECT_EQ(result, true);
368     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DISCONNECT_TIMEOUT_CHECK);
369     result = disconnecting->StateProcess(event);
370     EXPECT_EQ(result, true);
371     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_RIL_ADAPTER_HOST_DIED);
372     result = disconnecting->StateProcess(event);
373     EXPECT_EQ(result, true);
374     event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT);
375     result = disconnecting->StateProcess(event);
376     EXPECT_EQ(result, true);
377     event = AppExecFwk::InnerEvent::Get(0);
378     result = disconnecting->StateProcess(event);
379     EXPECT_EQ(result, false);
380 }
381 } // namespace Telephony
382 } // namespace OHOS