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 */
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 */
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 */
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 */
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->stateMachineEventHandler_->destState_, cellularMachine->inActiveState_);
171 }
172
173 /**
174 * @tc.number Activating_ProcessConnectTimeout_002
175 * @tc.name test function branch
176 * @tc.desc Function test
177 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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_FALSE(cellularMachine->IsInactiveState());
354 }
355
356 /**
357 * @tc.number Disconnecting_ProcessRilDeactivateDataCall_003
358 * @tc.name test function branch
359 * @tc.desc Function test
360 */
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_FALSE(cellularMachine->IsInactiveState());
375 }
376
377 /**
378 * @tc.number Disconnecting_ProcessRilDeactivateDataCall_004
379 * @tc.name test function branch
380 * @tc.desc Function test
381 */
382 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilDeactivateDataCall_004, 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 disconnecting->stateMachine_ = cellularMachine;
391 cellularMachine->connectId_ = 1;
392 std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
393 radioResponseInfo->flag = 1;
394 radioResponseInfo->error = ErrType::ERR_GENERIC_FAILURE;
395 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT, radioResponseInfo);
396 disconnecting->ProcessRilDeactivateDataCall(event);
397 EXPECT_FALSE(cellularMachine->IsInactiveState());
398 }
399
400 /**
401 * @tc.number Disconnecting_StateProcess_001
402 * @tc.name test function branch
403 * @tc.desc Function test
404 */
405 HWTEST_F(CellularStateMachineTest, Disconnecting_StateProcess_001, Function | MediumTest | Level1)
406 {
407 if (cellularMachine == nullptr) {
408 std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
409 cellularMachine = machine->CreateCellularDataConnect(0);
410 cellularMachine->Init();
411 }
412 auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
413 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_RIL_DEACTIVATE_DATA_CALL);
414 bool result = disconnecting->StateProcess(event);
415 EXPECT_EQ(result, true);
416 event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_DISCONNECT_TIMEOUT_CHECK);
417 result = disconnecting->StateProcess(event);
418 EXPECT_EQ(result, true);
419 event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_RIL_ADAPTER_HOST_DIED);
420 result = disconnecting->StateProcess(event);
421 EXPECT_EQ(result, true);
422 event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_CONNECT);
423 result = disconnecting->StateProcess(event);
424 EXPECT_EQ(result, true);
425 event = AppExecFwk::InnerEvent::Get(0);
426 result = disconnecting->StateProcess(event);
427 EXPECT_EQ(result, false);
428 }
429
430 /**
431 * @tc.number Disconnecting_StateProcess_002
432 * @tc.name test function branch
433 * @tc.desc Function test
434 */
435 HWTEST_F(CellularStateMachineTest, Disconnecting_StateProcess_002, Function | MediumTest | Level1)
436 {
437 if (cellularMachine == nullptr) {
438 std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
439 cellularMachine = machine->CreateCellularDataConnect(0);
440 cellularMachine->Init();
441 }
442 auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
443 cellularMachine = nullptr;
444 disconnecting->stateMachine_ = cellularMachine;
445 auto event = AppExecFwk::InnerEvent::Get(RadioEvent::RADIO_RIL_DEACTIVATE_DATA_CALL);
446 bool result = disconnecting->StateProcess(event);
447 EXPECT_EQ(result, false);
448 }
449
450 /**
451 * @tc.number InactiveStateProcess_001
452 * @tc.name test function branch
453 * @tc.desc Function test
454 */
455 HWTEST_F(CellularStateMachineTest, InactiveStateProcess_001, Function | MediumTest | Level1)
456 {
457 if (cellularMachine == nullptr) {
458 std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
459 cellularMachine = machine->CreateCellularDataConnect(0);
460 cellularMachine->Init();
461 }
462 auto inactive = static_cast<Inactive *>(cellularMachine->inActiveState_.GetRefPtr());
463 inactive->stateMachine_ = cellularMachine;
464 sptr<ApnHolder> apnHolder;
465 int32_t profileId = 0;
466 int32_t radioTechnology = 0;
467 bool nonTrafficUseOnly = false;
468 bool roamingState = false;
469 bool userDataRoaming = false;
470 std::shared_ptr<DataConnectionParams> dataConnectionParams = std::make_shared<DataConnectionParams>(apnHolder,
471 profileId, radioTechnology, nonTrafficUseOnly, roamingState, userDataRoaming);
472 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT, dataConnectionParams);
473 bool result = inactive->StateProcess(event);
474 EXPECT_EQ(result, true);
475 }
476
477 /**
478 * @tc.number Disconnecting_ProcessDisconnectTimeout_001
479 * @tc.name test function branch
480 * @tc.desc Function test
481 */
482 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessDisconnectTimeout_001, Function | MediumTest | Level1)
483 {
484 if (cellularMachine == nullptr) {
485 std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
486 cellularMachine = machine->CreateCellularDataConnect(0);
487 cellularMachine->Init();
488 }
489 auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
490 cellularMachine = nullptr;
491 disconnecting->stateMachine_ = cellularMachine;
492 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT, 0);
493 disconnecting->ProcessDisconnectTimeout(event);
494 disconnecting->StateEnd();
495 EXPECT_EQ(disconnecting->isActive_, false);
496 }
497
498 /**
499 * @tc.number Disconnecting_ProcessRilAdapterHostDied_002
500 * @tc.name test function branch
501 * @tc.desc Function test
502 */
503 HWTEST_F(CellularStateMachineTest, Disconnecting_ProcessRilAdapterHostDied_002, Function | MediumTest | Level1)
504 {
505 if (cellularMachine == nullptr) {
506 std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
507 cellularMachine = machine->CreateCellularDataConnect(0);
508 cellularMachine->Init();
509 }
510 auto disconnecting = static_cast<Disconnecting *>(cellularMachine->disconnectingState_.GetRefPtr());
511 cellularMachine->inActiveState_ = nullptr;
512 disconnecting->stateMachine_ = cellularMachine;
513 auto event = AppExecFwk::InnerEvent::Get(CellularDataEventCode::MSG_SM_DISCONNECT, 0);
514 disconnecting->ProcessRilAdapterHostDied(event);
515 EXPECT_EQ(cellularMachine->IsDisconnectingState(), false);
516 }
517
518 /**
519 * @tc.number Activating_RilActivatePdpContextDone_001
520 * @tc.name test function branch
521 * @tc.desc Function test
522 */
523 HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_001, Function | MediumTest | Level1)
524 {
525 if (cellularMachine == nullptr) {
526 std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
527 cellularMachine = machine->CreateCellularDataConnect(0);
528 cellularMachine->Init();
529 }
530 auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
531 cellularMachine = nullptr;
532 activating->stateMachine_ = cellularMachine;
533 auto event = AppExecFwk::InnerEvent::Get(0);
534 bool result = activating->RilActivatePdpContextDone(event);
535 EXPECT_EQ(result, false);
536 }
537
538 /**
539 * @tc.number Activating_RilActivatePdpContextDone_002
540 * @tc.name test function branch
541 * @tc.desc Function test
542 */
543 HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_002, Function | MediumTest | Level1)
544 {
545 if (cellularMachine == nullptr) {
546 std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
547 cellularMachine = machine->CreateCellularDataConnect(0);
548 cellularMachine->Init();
549 }
550 auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
551 cellularMachine->connectId_ = 1;
552 activating->stateMachine_ = cellularMachine;
553 std::shared_ptr<SetupDataCallResultInfo> setupDataCallResultInfo = std::make_shared<SetupDataCallResultInfo>();
554 setupDataCallResultInfo->flag = 2;
555 auto event = AppExecFwk::InnerEvent::Get(0, setupDataCallResultInfo);
556 bool result = activating->RilActivatePdpContextDone(event);
557 EXPECT_EQ(result, false);
558 }
559
560 /**
561 * @tc.number Activating_RilActivatePdpContextDone_003
562 * @tc.name test function branch
563 * @tc.desc Function test
564 */
565 HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_003, 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 = 1;
578 auto event = AppExecFwk::InnerEvent::Get(0, setupDataCallResultInfo);
579 bool result = activating->RilActivatePdpContextDone(event);
580 EXPECT_EQ(result, true);
581 }
582
583 /**
584 * @tc.number Activating_RilActivatePdpContextDone_004
585 * @tc.name test function branch
586 * @tc.desc Function test
587 */
588 HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_004, Function | MediumTest | Level1)
589 {
590 if (cellularMachine == nullptr) {
591 std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
592 cellularMachine = machine->CreateCellularDataConnect(0);
593 cellularMachine->Init();
594 }
595 auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
596 cellularMachine->connectId_ = 1;
597 activating->stateMachine_ = cellularMachine;
598 std::shared_ptr<SetupDataCallResultInfo> setupDataCallResultInfo = std::make_shared<SetupDataCallResultInfo>();
599 setupDataCallResultInfo->flag = 1;
600 setupDataCallResultInfo->reason = 0;
601 setupDataCallResultInfo->active = 0;
602 auto event = AppExecFwk::InnerEvent::Get(0, setupDataCallResultInfo);
603 bool result = activating->RilActivatePdpContextDone(event);
604 EXPECT_EQ(result, true);
605 }
606
607 /**
608 * @tc.number Activating_RilActivatePdpContextDone_005
609 * @tc.name test function branch
610 * @tc.desc Function test
611 */
612 HWTEST_F(CellularStateMachineTest, Activating_RilActivatePdpContextDone_005, Function | MediumTest | Level1)
613 {
614 if (cellularMachine == nullptr) {
615 std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
616 cellularMachine = machine->CreateCellularDataConnect(0);
617 cellularMachine->Init();
618 }
619 auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
620 cellularMachine->connectId_ = 1;
621 activating->stateMachine_ = cellularMachine;
622 std::shared_ptr<SetupDataCallResultInfo> setupDataCallResultInfo = std::make_shared<SetupDataCallResultInfo>();
623 setupDataCallResultInfo->flag = 1;
624 setupDataCallResultInfo->reason = 0;
625 setupDataCallResultInfo->active = 1;
626 setupDataCallResultInfo->cid = 99;
627 auto event = AppExecFwk::InnerEvent::Get(0, setupDataCallResultInfo);
628 bool result = activating->RilActivatePdpContextDone(event);
629 EXPECT_EQ(result, true);
630 }
631
632 /**
633 * @tc.number Activating_RilErrorResponse_001
634 * @tc.name test function branch
635 * @tc.desc Function test
636 */
637 HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_001, Function | MediumTest | Level1)
638 {
639 if (cellularMachine == nullptr) {
640 std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
641 cellularMachine = machine->CreateCellularDataConnect(0);
642 cellularMachine->Init();
643 }
644 auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
645 cellularMachine->connectId_ = 1;
646 activating->stateMachine_ = cellularMachine;
647 std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
648 radioResponseInfo->flag = 12;
649 auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
650 bool result = activating->RilErrorResponse(event);
651 EXPECT_EQ(result, false);
652 }
653
654 /**
655 * @tc.number Activating_RilErrorResponse_002
656 * @tc.name test function branch
657 * @tc.desc Function test
658 */
659 HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_002, 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_GENERIC_FAILURE;
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_003
679 * @tc.name test function branch
680 * @tc.desc Function test
681 */
682 HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_003, 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::ERR_INVALID_RESPONSE;
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_004
702 * @tc.name test function branch
703 * @tc.desc Function test
704 */
705 HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_004, 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->connectId_ = 1;
714 activating->stateMachine_ = cellularMachine;
715 std::shared_ptr<RadioResponseInfo> radioResponseInfo = std::make_shared<RadioResponseInfo>();
716 radioResponseInfo->flag = 1;
717 radioResponseInfo->error = ErrType::NONE;
718 auto event = AppExecFwk::InnerEvent::Get(0, radioResponseInfo);
719 bool result = activating->RilErrorResponse(event);
720 EXPECT_EQ(result, true);
721 }
722
723 /**
724 * @tc.number Activating_RilErrorResponse_005
725 * @tc.name test function branch
726 * @tc.desc Function test
727 */
728 HWTEST_F(CellularStateMachineTest, Activating_RilErrorResponse_005, Function | MediumTest | Level1)
729 {
730 if (cellularMachine == nullptr) {
731 std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
732 cellularMachine = machine->CreateCellularDataConnect(0);
733 cellularMachine->Init();
734 }
735 auto activating = static_cast<Activating *>(cellularMachine->activatingState_.GetRefPtr());
736 cellularMachine = nullptr;
737 activating->stateMachine_ = cellularMachine;
738 auto event = AppExecFwk::InnerEvent::Get(0);
739 bool result = activating->RilErrorResponse(event);
740 EXPECT_EQ(result, false);
741 }
742
743 /**
744 * @tc.number Active_CellularDataStateMachine_001
745 * @tc.name test function branch
746 * @tc.desc Function test
747 */
748 HWTEST_F(CellularStateMachineTest, Active_CellularDataStateMachine_001, Function | MediumTest | Level1)
749 {
750 if (cellularMachine == nullptr) {
751 std::shared_ptr<CellularMachineTest> machine = std::make_shared<CellularMachineTest>();
752 cellularMachine = machine->CreateCellularDataConnect(0);
753 cellularMachine->Init();
754 }
755 auto active = static_cast<Active *>(cellularMachine->activeState_.GetRefPtr());
756 cellularMachine = nullptr;
757 active->stateMachine_ = cellularMachine;
758 active->StateBegin();
759 auto event = AppExecFwk::InnerEvent::Get(0);
760 bool result = active->ProcessDisconnectDone(event);
761 EXPECT_EQ(result, false);
762 result = active->ProcessDisconnectAllDone(event);
763 EXPECT_EQ(result, false);
764 result = active->ProcessLostConnection(event);
765 EXPECT_EQ(result, false);
766 result = active->ProcessLinkCapabilityChanged(event);
767 EXPECT_EQ(result, false);
768 result = active->ProcessDataConnectionRoamOn(event);
769 EXPECT_EQ(result, false);
770 active->RefreshConnectionBandwidths();
771 result = active->ProcessDataConnectionRoamOff(event);
772 EXPECT_EQ(result, false);
773 active->RefreshTcpBufferSizes();
774 result = active->ProcessDataConnectionVoiceCallStartedOrEnded(event);
775 EXPECT_EQ(result, false);
776 }
777 } // namespace Telephony
778 } // namespace OHOS