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 #include <gtest/gtest.h>
16 #include "internal_message.h"
17 #include "sta_define.h"
18 #include "define.h"
19 #include "sta_state_machine.h"
20 #include "sta_service.h"
21 #include "wifi_app_state_aware.h"
22 #include "wifi_internal_msg.h"
23 #include "wifi_msg.h"
24 #include "mock_wifi_config_center.h"
25 #include "mock_wifi_settings.h"
26 #include "mock_if_config.h"
27 #include "mock_wifi_manager.h"
28 #include "mock_wifi_sta_hal_interface.h"
29 #include "wifi_error_no.h"
30
31 using ::testing::_;
32 using ::testing::AtLeast;
33 using ::testing::DoAll;
34 using ::testing::Eq;
35 using ::testing::Return;
36 using ::testing::SetArgReferee;
37 using ::testing::StrEq;
38 using ::testing::TypedEq;
39 using ::testing::ext::TestSize;
40
strcpy_s(char * strDest,size_t destMax,const char * strSrc)41 errno_t strcpy_s(char *strDest, size_t destMax, const char *strSrc)
42 {
43 int retCode = memcpy_s(strDest, destMax, strSrc, strlen(strSrc));
44 if (retCode != 0) {
45 return 1;
46 }
47 return 1;
48 }
49
DealDhcpOfferReport(const OHOS::Wifi::IpInfo & ipInfo,int instId)50 void DealDhcpOfferReport(const OHOS::Wifi::IpInfo &ipInfo, int instId)
51 {
52 }
53
54 namespace OHOS {
55 namespace Wifi {
56 static const std::string RANDOMMAC_SSID = "testwifi";
57 static const std::string RANDOMMAC_PASSWORD = "testwifi";
58 static const std::string RANDOMMAC_BSSID = "01:23:45:67:89:a0";
59 static constexpr int NAPI_MAX_STR_LENT = 127;
60 static constexpr int MIN_5G_FREQUENCY = 5160;
61 static constexpr int INVALID_RSSI1 = -128;
62 static constexpr int GATE_WAY = 124;
63 constexpr int TWO = 2;
64
65 class StaStateMachineTest : public testing::Test {
66 public:
SetUpTestCase()67 static void SetUpTestCase() {}
TearDownTestCase()68 static void TearDownTestCase()
69 {
70 WifiAppStateAware& wifiAppStateAware = WifiAppStateAware::GetInstance();
71 wifiAppStateAware.appChangeEventHandler.reset();
72 wifiAppStateAware.mAppStateObserver = nullptr;
73 }
SetUp()74 virtual void SetUp()
75 {
76 EXPECT_CALL(WifiConfigCenter::GetInstance(), GetLinkedInfo(_, _)).Times(testing::AtLeast(0));
77 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveDisconnectedReason(_, _)).Times(testing::AtLeast(0));
78 pStaStateMachine.reset(new StaStateMachine());
79 pStaStateMachine->InitStaStateMachine();
80 pStaStateMachine->InitWifiLinkedInfo();
81 pStaStateMachine->InitLastWifiLinkedInfo();
82 }
TearDown()83 virtual void TearDown()
84 {
85 pStaStateMachine.reset();
86 }
87 std::unique_ptr<StaStateMachine> pStaStateMachine;
88
ConfigStaticIpAddressSuccess1()89 void ConfigStaticIpAddressSuccess1()
90 {
91 EXPECT_CALL(WifiConfigCenter::GetInstance(), GetIpInfo(_, _)).Times(AtLeast(0));
92 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveLinkedInfo(_, _)).Times(AtLeast(0));
93 pStaStateMachine->currentTpType = IPTYPE_IPV4;
94 pStaStateMachine->getIpSucNum = 1;
95 pStaStateMachine->isRoam = false;
96 StaticIpAddress staticIpAddress;
97 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveIpInfo(_, _)).Times(AtLeast(0));
98 EXPECT_CALL(WifiConfigCenter::GetInstance(), GetStaIfaceName()).WillRepeatedly(Return("sta"));
99 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveLinkedInfo(_, _)).Times(AtLeast(0));
100 EXPECT_CALL(WifiManager::GetInstance(), DealStaConnChanged(_, _, _)).Times(AtLeast(0));
101 pStaStateMachine->pDhcpResultNotify->pStaStateMachine = nullptr;
102 EXPECT_TRUE(pStaStateMachine->ConfigStaticIpAddress(staticIpAddress));
103 }
104
ConfigStaticIpAddressSuccess2()105 void ConfigStaticIpAddressSuccess2()
106 {
107 EXPECT_CALL(WifiConfigCenter::GetInstance(), GetIpInfo(_, _)).Times(AtLeast(0));
108 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveLinkedInfo(_, _)).Times(AtLeast(0));
109 EXPECT_CALL(WifiConfigCenter::GetInstance(), GetStaIfaceName()).WillRepeatedly(Return("sta"));
110 pStaStateMachine->currentTpType = IPTYPE_IPV6;
111 pStaStateMachine->getIpSucNum = 1;
112 pStaStateMachine->isRoam = false;
113 StaticIpAddress staticIpAddress;
114 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveIpInfo(_, _)).Times(AtLeast(0));
115 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveLinkedInfo(_, _)).Times(AtLeast(0));
116 EXPECT_CALL(WifiManager::GetInstance(), DealStaConnChanged(_, _, _)).Times(AtLeast(0));
117 pStaStateMachine->pDhcpResultNotify->pStaStateMachine = nullptr;
118 EXPECT_TRUE(pStaStateMachine->ConfigStaticIpAddress(staticIpAddress));
119 }
120
ConfigStaticIpAddressSuccess3()121 void ConfigStaticIpAddressSuccess3()
122 {
123 EXPECT_CALL(WifiConfigCenter::GetInstance(), GetIpInfo(_, _)).Times(AtLeast(0));
124 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveLinkedInfo(_, _)).Times(AtLeast(0));
125 pStaStateMachine->currentTpType = IPTYPE_MIX;
126 pStaStateMachine->getIpSucNum = 1;
127 pStaStateMachine->isRoam = false;
128 StaticIpAddress staticIpAddress;
129 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveIpInfo(_, _)).Times(AtLeast(0));
130 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveLinkedInfo(_, _)).Times(AtLeast(0));
131 EXPECT_CALL(WifiManager::GetInstance(), DealStaConnChanged(_, _, _)).Times(AtLeast(0));
132 EXPECT_CALL(WifiConfigCenter::GetInstance(), GetStaIfaceName()).WillRepeatedly(Return("sta"));
133 pStaStateMachine->pDhcpResultNotify->pStaStateMachine = nullptr;
134 EXPECT_TRUE(pStaStateMachine->ConfigStaticIpAddress(staticIpAddress));
135 }
136
ConfigStaticIpAddressFail()137 void ConfigStaticIpAddressFail()
138 {
139 pStaStateMachine->currentTpType = IPTYPE_BUTT;
140 StaticIpAddress staticIpAddress;
141 pStaStateMachine->getIpSucNum = 1;
142 pStaStateMachine->isRoam = false;
143 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveIpInfo(_, _)).Times(AtLeast(0));
144 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveLinkedInfo(_, _)).Times(AtLeast(0));
145 EXPECT_CALL(WifiConfigCenter::GetInstance(), GetStaIfaceName()).WillRepeatedly(Return("sta"));
146 EXPECT_FALSE(pStaStateMachine->ConfigStaticIpAddress(staticIpAddress));
147 }
148
ReplaceEmptyDnsTest()149 void ReplaceEmptyDnsTest()
150 {
151 DhcpResult *result = nullptr;
152 pStaStateMachine->ReplaceEmptyDns(result);
153 DhcpResult resultO;
154 std::string dns = "0.0.0.0";
155 pStaStateMachine->ReplaceEmptyDns(&resultO);
156 memcpy_s(resultO.strOptDns2, NAPI_MAX_STR_LENT, dns.c_str(), dns.length());
157 pStaStateMachine->ReplaceEmptyDns(&resultO);
158 memcpy_s(resultO.strOptDns1, NAPI_MAX_STR_LENT, dns.c_str(), dns.length());
159 memset_s(resultO.strOptDns2, NAPI_MAX_STR_LENT, 0x0, NAPI_MAX_STR_LENT);
160 pStaStateMachine->ReplaceEmptyDns(&resultO);
161 memcpy_s(resultO.strOptDns1, NAPI_MAX_STR_LENT, dns.c_str(), dns.length());
162 memcpy_s(resultO.strOptDns2, NAPI_MAX_STR_LENT, dns.c_str(), dns.length());
163 pStaStateMachine->ReplaceEmptyDns(&resultO);
164 }
165
SetExternalSimTest()166 void SetExternalSimTest()
167 {
168 int value = 1;
169 MockWifiStaHalInterface::GetInstance().SetRetResult(WIFI_HAL_OPT_FAILED);
170 pStaStateMachine->SetExternalSim("wlan0", EAP_METHOD_NONE, value);
171 }
172
FillSuiteB192CfgTest()173 void FillSuiteB192CfgTest()
174 {
175 WifiHalDeviceConfig halDeviceConfig;
176 halDeviceConfig.keyMgmt = "WPA-EAP";
177 pStaStateMachine->FillSuiteB192Cfg(halDeviceConfig);
178 }
179
ConvertDeviceCfgSuccess()180 void ConvertDeviceCfgSuccess()
181 {
182 std::vector<WifiScanInfo> scanInfoList;
183 WifiScanInfo temp;
184 temp.ssid = "123";
185 temp.bssid ="456";
186 temp.capabilities = "PSK+SAE";
187 scanInfoList.push_back(temp);
188 WifiDeviceConfig config;
189 config.keyMgmt = "WEP";
190 config.ssid = "123";
191 EXPECT_CALL(WifiConfigCenter::GetInstance(), GetScanInfoList(_))
192 .WillOnce(DoAll(SetArgReferee<0>(scanInfoList), Return(0)));
193 EXPECT_EQ(WIFI_OPT_SUCCESS, pStaStateMachine->ConvertDeviceCfg(config));
194 }
195
GetGsmAuthResponseWithoutLengthTest()196 void GetGsmAuthResponseWithoutLengthTest()
197 {
198 EapSimGsmAuthParam param;
199 param.rands.push_back("30303a35353a44443a66663a4d4d");
200 pStaStateMachine->GetGsmAuthResponseWithoutLength(param);
201 }
202
GetGsmAuthResponseWithLengthTest()203 void GetGsmAuthResponseWithLengthTest()
204 {
205 EapSimGsmAuthParam param;
206 param.rands.push_back("30303a35353a44443a66663a4d4d");
207 pStaStateMachine->GetGsmAuthResponseWithLength(param);
208 }
209
StartDetectTimerTest()210 void StartDetectTimerTest()
211 {
212 int detectType = DETECT_TYPE_PERIODIC;
213 pStaStateMachine->StartDetectTimer(detectType);
214 }
215
DealApRoamingStateTimeoutTest()216 void DealApRoamingStateTimeoutTest()
217 {
218 InternalMessagePtr msg = nullptr;
219 pStaStateMachine->DealApRoamingStateTimeout(msg);
220 }
221
SaveDhcpResultTest()222 void SaveDhcpResultTest()
223 {
224 DhcpResult *dest = nullptr;
225 DhcpResult *source = nullptr;
226 pStaStateMachine->pDhcpResultNotify->SaveDhcpResult(dest, source);
227 DhcpResult destObj;
228 DhcpResult sourceObj;
229 pStaStateMachine->pDhcpResultNotify->SaveDhcpResult(&destObj, &sourceObj);
230 }
231
SaveDhcpResultExtTest()232 void SaveDhcpResultExtTest()
233 {
234 DhcpResult *dest = nullptr;
235 DhcpResult *source = nullptr;
236 pStaStateMachine->pDhcpResultNotify->SaveDhcpResultExt(dest, source);
237 DhcpResult destObj;
238 DhcpResult sourceObj;
239 pStaStateMachine->pDhcpResultNotify->SaveDhcpResultExt(&destObj, &sourceObj);
240 }
241
TryToSaveIpV4ResultExtTest()242 void TryToSaveIpV4ResultExtTest()
243 {
244 IpInfo ipInfo;
245 IpV6Info ipv6Info;
246 DhcpResult *result = nullptr;
247 pStaStateMachine->pDhcpResultNotify->TryToSaveIpV4ResultExt(ipInfo, ipv6Info, result);
248 DhcpResult result1;
249 pStaStateMachine->pDhcpResultNotify->TryToSaveIpV4ResultExt(ipInfo, ipv6Info, &result1);
250 }
251
TryToSaveIpV4ResultTest()252 void TryToSaveIpV4ResultTest()
253 {
254 IpInfo ipInfo;
255 IpV6Info ipv6Info;
256 DhcpResult *result = nullptr;
257 pStaStateMachine->pDhcpResultNotify->TryToSaveIpV4Result(ipInfo, ipv6Info, result);
258 DhcpResult result1;
259 pStaStateMachine->pDhcpResultNotify->TryToSaveIpV4Result(ipInfo, ipv6Info, &result1);
260 }
261
TryToSaveIpV6ResultTest()262 void TryToSaveIpV6ResultTest()
263 {
264 IpInfo ipInfo;
265 IpV6Info ipv6Info;
266 DhcpResult *result = nullptr;
267 pStaStateMachine->pDhcpResultNotify->TryToSaveIpV6Result(ipInfo, ipv6Info, result);
268 DhcpResult result1;
269 if (snprintf_s(result1.strOptClientId, sizeof(result1.strOptClientId), sizeof(result1.strOptClientId) - 1,
270 "%s", "0.0.0.1") < 0) {
271 return;
272 }
273 if (snprintf_s(result1.strOptRouter1, sizeof(result1.strOptRouter1), sizeof(result1.strOptRouter1) - 1,
274 "%s", "0.0.0.1") < 0) {
275 return;
276 }
277 result1.iptype = 0;
278 ipv6Info.linkIpV6Address = "0";
279 ipv6Info.globalIpV6Address = "0";
280 ipv6Info.randGlobalIpV6Address = "0";
281 ipv6Info.gateway = "0";
282 ipv6Info.netmask = "0";
283 ipv6Info.primaryDns = "0";
284 ipv6Info.secondDns = "0";
285 ipv6Info.uniqueLocalAddress1 = "0";
286 ipv6Info.uniqueLocalAddress2 = "0";
287 ipv6Info.dnsAddr.push_back("11");
288 StaStateMachine staStateMachine;
289 pStaStateMachine->pDhcpResultNotify->SetStaStateMachine(&staStateMachine);
290 pStaStateMachine->pDhcpResultNotify->TryToSaveIpV6Result(ipInfo, ipv6Info, &result1);
291 }
292
SetConnectMethodTest()293 void SetConnectMethodTest()
294 {
295 int connectMethod = NETWORK_SELECTED_BY_AUTO;
296 pStaStateMachine->SetConnectMethod(connectMethod);
297 connectMethod = NETWORK_SELECTED_BY_USER;
298 pStaStateMachine->SetConnectMethod(connectMethod);
299 }
300
InvokeOnDhcpOfferReportTest()301 void InvokeOnDhcpOfferReportTest()
302 {
303 IpInfo ipInfo;
304 StaServiceCallback callback;
305 callback.OnDhcpOfferReport = DealDhcpOfferReport;
306 pStaStateMachine->RegisterStaServiceCallback(callback);
307 pStaStateMachine->InvokeOnDhcpOfferReport(ipInfo);
308 }
309
FillSuiteB192CfgTest2()310 void FillSuiteB192CfgTest2()
311 {
312 WifiHalDeviceConfig halDeviceConfig;
313 halDeviceConfig.keyMgmt = "WPA-EAP-SUITE-B-192";
314 pStaStateMachine->FillSuiteB192Cfg(halDeviceConfig);
315 }
316
DealSignalPollResultTest()317 void DealSignalPollResultTest()
318 {
319 EXPECT_CALL(WifiConfigCenter::GetInstance(), SetWifiLinkedStandardAndMaxSpeed(_)).Times(testing::AtLeast(0));
320 pStaStateMachine->DealSignalPollResult();
321 pStaStateMachine->linkedInfo.lastTxPackets = 1;
322 pStaStateMachine->linkedInfo.lastRxPackets = 1;
323 pStaStateMachine->linkedInfo.lastPacketDirection = 1;
324 pStaStateMachine->DealSignalPacketChanged(0, 0);
325 }
ConvertDeviceCfgSuccess1()326 void ConvertDeviceCfgSuccess1()
327 {
328 std::vector<WifiScanInfo> scanInfoList;
329 WifiScanInfo temp;
330 temp.ssid = "123";
331 temp.bssid ="456";
332 temp.capabilities = "PSK+SAE";
333 scanInfoList.push_back(temp);
334 WifiDeviceConfig config;
335 config.keyMgmt = "SAE";
336 config.ssid = "123";
337 EXPECT_CALL(WifiConfigCenter::GetInstance(), GetScanInfoList(_))
338 .WillRepeatedly(DoAll(SetArgReferee<0>(scanInfoList), Return(0)));
339 EXPECT_EQ(WIFI_OPT_SUCCESS, pStaStateMachine->ConvertDeviceCfg(config));
340 }
341
SetExternalSimTest1()342 void SetExternalSimTest1()
343 {
344 int value = 1;
345 MockWifiStaHalInterface::GetInstance().SetRetResult(WIFI_HAL_OPT_OK);
346 pStaStateMachine->SetExternalSim("wlan0", EAP_METHOD_NONE, value);
347 }
348
UpdateLinkInfoRssiTest()349 void UpdateLinkInfoRssiTest()
350 {
351 WifiStaHalInterface::GetInstance().mInfo.frequency = MIN_5G_FREQUENCY;
352 WifiStaHalInterface::GetInstance().mInfo.txrate = MIN_5G_FREQUENCY;
353 WifiStaHalInterface::GetInstance().mInfo.rxrate = MIN_5G_FREQUENCY;
354 MockWifiStaHalInterface::GetInstance().SetRetResult(WIFI_HAL_OPT_OK);
355 int rssi = INVALID_RSSI1;
356 int outRssi = pStaStateMachine->UpdateLinkInfoRssi(rssi);
357 EXPECT_EQ(outRssi, INVALID_RSSI_VALUE);
358 }
CurrentIsRandomizedMacTest()359 void CurrentIsRandomizedMacTest()
360 {
361 MockWifiStaHalInterface::GetInstance().SetRetResult(WIFI_HAL_OPT_OK);
362 pStaStateMachine->CurrentIsRandomizedMac();
363 }
364
HilinkSaveConfigTest()365 void HilinkSaveConfigTest()
366 {
367 WifiDeviceConfig deviceConfig;
368 EXPECT_CALL(WifiSettings::GetInstance(), GetDeviceConfig(deviceConfig.bssid, DEVICE_CONFIG_INDEX_BSSID, _))
369 .Times(AtLeast(0)).WillOnce(DoAll(SetArgReferee<TWO>(deviceConfig), Return(-1)));
370 pStaStateMachine->HilinkSaveConfig();
371 }
372
DealConnectionEventSuccess()373 void DealConnectionEventSuccess()
374 {
375 EXPECT_CALL(WifiSettings::GetInstance(), SetDeviceAfterConnect(_)).Times(testing::AtLeast(0));
376 EXPECT_CALL(WifiSettings::GetInstance(), SetDeviceState(_, _, _)).Times(testing::AtLeast(0));
377 EXPECT_CALL(WifiSettings::GetInstance(), SyncDeviceConfig()).Times(testing::AtLeast(0));
378 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveLinkedInfo(_, _)).Times(AtLeast(0));
379 EXPECT_CALL(WifiConfigCenter::GetInstance(), SetUserLastSelectedNetworkId(_, _)).Times(testing::AtLeast(0));
380 pStaStateMachine->wpsState = SetupMethod::INVALID;
381 InternalMessagePtr msg = std::make_shared<InternalMessage>();
382 pStaStateMachine->m_hilinkFlag = true;
383 pStaStateMachine->DealConnectionEvent(msg);
384 }
385
DealWpaWrongPskEventFail1()386 void DealWpaWrongPskEventFail1()
387 {
388 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveLinkedInfo(_, _)).Times(testing::AtLeast(0));
389 EXPECT_CALL(WifiManager::GetInstance(), DealStaConnChanged(_, _, _)).Times(testing::AtLeast(0));
390 EXPECT_CALL(WifiSettings::GetInstance(), GetDeviceConfig(_, _))
391 .WillOnce(Return(1))
392 .WillRepeatedly(Return(0));
393 InternalMessagePtr msg = std::make_shared<InternalMessage>();
394 std::string bssid = "wifitest";
395 msg->SetMessageObj(bssid);
396 msg->SetMessageName(WIFI_SVR_CMD_STA_REPORT_DISCONNECT_REASON_EVENT);
397 pStaStateMachine->DealWpaLinkFailEvent(msg);
398 }
399
DealWpaWrongPskEventFail2()400 void DealWpaWrongPskEventFail2()
401 {
402 EXPECT_CALL(WifiConfigCenter::GetInstance(), SaveLinkedInfo(_, _)).Times(testing::AtLeast(0));
403 EXPECT_CALL(WifiManager::GetInstance(), DealStaConnChanged(_, _, _)).Times(testing::AtLeast(0));
404 EXPECT_CALL(WifiSettings::GetInstance(), GetDeviceConfig(_, _))
405 .WillOnce(Return(1))
406 .WillRepeatedly(Return(0));
407 InternalMessagePtr msg = std::make_shared<InternalMessage>();
408 std::string bssid = "wifitest";
409 msg->SetMessageObj(bssid);
410 msg->SetMessageName(WIFI_SVR_CMD_STA_WPS_TIMEOUT_EVNET);
411 pStaStateMachine->DealWpaLinkFailEvent(msg);
412 }
413
DealStartWpsCmdSuccess()414 void DealStartWpsCmdSuccess()
415 {
416 EXPECT_CALL(WifiManager::GetInstance(), DealWpsChanged(_, _, _));
417 pStaStateMachine->wpsState = SetupMethod::INVALID;
418 InternalMessagePtr msg = std::make_shared<InternalMessage>();
419 std::string bssid = "wifitest";
420 msg->SetMessageObj(bssid);
421 MockWifiStaHalInterface::GetInstance().SetRetResult(WIFI_HAL_OPT_OK);
422 pStaStateMachine->DealStartWpsCmd(msg);
423 }
424
DealScreenStateChangedEventTest()425 void DealScreenStateChangedEventTest()
426 {
427 InternalMessagePtr msg = std::make_shared<InternalMessage>();
428 msg->SetParam1(static_cast<int>(MODE_STATE_OPEN));
429 pStaStateMachine->DealScreenStateChangedEvent(msg);
430 msg->SetParam1(static_cast<int>(MODE_STATE_CLOSE));
431 pStaStateMachine->DealScreenStateChangedEvent(msg);
432 }
433
DealCancelWpsCmdSuccess1()434 void DealCancelWpsCmdSuccess1()
435 {
436 EXPECT_CALL(WifiSettings::GetInstance(), GetDeviceConfig(_)).WillRepeatedly(Return(-1));
437 EXPECT_CALL(WifiManager::GetInstance(), DealWpsChanged(_, _, _));
438 pStaStateMachine->wpsState = SetupMethod::PBC;
439 InternalMessagePtr msg = std::make_shared<InternalMessage>();
440 MockWifiStaHalInterface::GetInstance().SetRetResult(WIFI_HAL_OPT_OK);
441 pStaStateMachine->DealCancelWpsCmd(msg);
442 }
443
DealCancelWpsCmdSuccess2()444 void DealCancelWpsCmdSuccess2()
445 {
446 EXPECT_CALL(WifiSettings::GetInstance(), GetDeviceConfig(_)).WillRepeatedly(Return(-1));
447 EXPECT_CALL(WifiManager::GetInstance(), DealWpsChanged(_, _, _));
448 pStaStateMachine->wpsState = SetupMethod::DISPLAY;
449 InternalMessagePtr msg = std::make_shared<InternalMessage>();
450 MockWifiStaHalInterface::GetInstance().SetRetResult(WIFI_HAL_OPT_OK);
451 pStaStateMachine->DealCancelWpsCmd(msg);
452 }
453
DealCancelWpsCmdSuccess3()454 void DealCancelWpsCmdSuccess3()
455 {
456 EXPECT_CALL(WifiSettings::GetInstance(), GetDeviceConfig(_)).WillRepeatedly(Return(-1));
457 EXPECT_CALL(WifiManager::GetInstance(), DealWpsChanged(_, _, _)).Times(AtLeast(0));
458 pStaStateMachine->wpsState = SetupMethod::KEYPAD;
459 InternalMessagePtr msg = std::make_shared<InternalMessage>();
460 MockWifiStaHalInterface::GetInstance().SetRetResult(WIFI_HAL_OPT_OK);
461 pStaStateMachine->DealCancelWpsCmd(msg);
462 }
463
DealCancelWpsCmdFail1()464 void DealCancelWpsCmdFail1()
465 {
466 EXPECT_CALL(WifiManager::GetInstance(), DealWpsChanged(_, _, _)).Times(AtLeast(0));
467 pStaStateMachine->wpsState = SetupMethod::PBC;
468 InternalMessagePtr msg = std::make_shared<InternalMessage>();
469 MockWifiStaHalInterface::GetInstance().SetRetResult(WIFI_HAL_OPT_OK);
470 pStaStateMachine->DealCancelWpsCmd(msg);
471 }
472
DealCancelWpsCmdFail2()473 void DealCancelWpsCmdFail2()
474 {
475 EXPECT_CALL(WifiManager::GetInstance(), DealWpsChanged(_, _, _)).Times(AtLeast(0));
476 pStaStateMachine->wpsState = SetupMethod::DISPLAY;
477 InternalMessagePtr msg = std::make_shared<InternalMessage>();
478 MockWifiStaHalInterface::GetInstance().SetRetResult(WIFI_HAL_OPT_OK);
479 pStaStateMachine->DealCancelWpsCmd(msg);
480 }
481
DealCancelWpsCmdFail3()482 void DealCancelWpsCmdFail3()
483 {
484 EXPECT_CALL(WifiManager::GetInstance(), DealWpsChanged(_, _, _)).Times(AtLeast(0));
485 pStaStateMachine->wpsState = SetupMethod::KEYPAD;
486 InternalMessagePtr msg = std::make_shared<InternalMessage>();
487 MockWifiStaHalInterface::GetInstance().SetRetResult(WIFI_HAL_OPT_OK);
488 pStaStateMachine->DealCancelWpsCmd(msg);
489 pStaStateMachine->DealCancelWpsCmd(nullptr);
490 }
CanArpReachableTest()491 void CanArpReachableTest()
492 {
493 IpInfo ipInfo;
494 ipInfo.gateway =GATE_WAY;
495 EXPECT_CALL(WifiConfigCenter::GetInstance(), GetIpInfo(_, _))
496 .WillRepeatedly(DoAll(SetArgReferee<0>(ipInfo), Return(0)));
497 pStaStateMachine->CanArpReachable();
498 }
PortalExpiredDetectTest()499 void PortalExpiredDetectTest()
500 {
501 pStaStateMachine->portalState = PortalState::AUTHED;
502 pStaStateMachine->portalExpiredDetectCount = PORTAL_EXPERIED_DETECT_MAX_COUNT;
503 pStaStateMachine->PortalExpiredDetect();
504 }
505 };
506
507 HWTEST_F(StaStateMachineTest, ConfigStaticIpAddressSuccess1, TestSize.Level1)
508 {
509 ConfigStaticIpAddressSuccess1();
510 }
511
512 HWTEST_F(StaStateMachineTest, ConfigStaticIpAddressSuccess2, TestSize.Level1)
513 {
514 ConfigStaticIpAddressSuccess2();
515 }
516
517 HWTEST_F(StaStateMachineTest, ConfigStaticIpAddressSuccess3, TestSize.Level1)
518 {
519 ConfigStaticIpAddressSuccess3();
520 }
521
522 HWTEST_F(StaStateMachineTest, ConfigStaticIpAddressFail, TestSize.Level1)
523 {
524 ConfigStaticIpAddressFail();
525 }
526
527 HWTEST_F(StaStateMachineTest, ReplaceEmptyDnsTest, TestSize.Level1)
528 {
529 ReplaceEmptyDnsTest();
530 }
531
532 HWTEST_F(StaStateMachineTest, SetExternalSimTest, TestSize.Level1)
533 {
534 SetExternalSimTest();
535 }
536
537 HWTEST_F(StaStateMachineTest, FillSuiteB192CfgTest, TestSize.Level1)
538 {
539 FillSuiteB192CfgTest();
540 }
541
542 HWTEST_F(StaStateMachineTest, ConvertDeviceCfgSuccess, TestSize.Level1)
543 {
544 ConvertDeviceCfgSuccess();
545 }
546
547 HWTEST_F(StaStateMachineTest, GetGsmAuthResponseWithoutLengthTest, TestSize.Level1)
548 {
549 GetGsmAuthResponseWithoutLengthTest();
550 }
551
552 HWTEST_F(StaStateMachineTest, GetGsmAuthResponseWithLengthTest, TestSize.Level1)
553 {
554 GetGsmAuthResponseWithLengthTest();
555 }
556
557 HWTEST_F(StaStateMachineTest, StartDetectTimerTest, TestSize.Level1)
558 {
559 StartDetectTimerTest();
560 }
561
562 HWTEST_F(StaStateMachineTest, DealApRoamingStateTimeoutTest, TestSize.Level1)
563 {
564 DealApRoamingStateTimeoutTest();
565 }
566
567 HWTEST_F(StaStateMachineTest, SaveDhcpResultTest, TestSize.Level1)
568 {
569 SaveDhcpResultTest();
570 }
571
572 HWTEST_F(StaStateMachineTest, SaveDhcpResultExtTest, TestSize.Level1)
573 {
574 SaveDhcpResultExtTest();
575 }
576
577 HWTEST_F(StaStateMachineTest, TryToSaveIpV4ResultExtTest, TestSize.Level1)
578 {
579 TryToSaveIpV4ResultExtTest();
580 }
581
582 HWTEST_F(StaStateMachineTest, TryToSaveIpV4ResultTest, TestSize.Level1)
583 {
584 TryToSaveIpV4ResultTest();
585 }
586
587 HWTEST_F(StaStateMachineTest, TryToSaveIpV6ResultTest, TestSize.Level1)
588 {
589 TryToSaveIpV6ResultTest();
590 }
591
592 HWTEST_F(StaStateMachineTest, SetConnectMethodTest, TestSize.Level1)
593 {
594 SetConnectMethodTest();
595 }
596
597 HWTEST_F(StaStateMachineTest, SetExternalSimTest1, TestSize.Level1)
598 {
599 SetExternalSimTest1();
600 }
601
602 HWTEST_F(StaStateMachineTest, UpdateLinkInfoRssiTest, TestSize.Level1)
603 {
604 UpdateLinkInfoRssiTest();
605 }
606
607 HWTEST_F(StaStateMachineTest, CurrentIsRandomizedMacTest, TestSize.Level1)
608 {
609 CurrentIsRandomizedMacTest();
610 }
611
612 HWTEST_F(StaStateMachineTest, HilinkSaveConfigTest, TestSize.Level1)
613 {
614 HilinkSaveConfigTest();
615 }
616
617 HWTEST_F(StaStateMachineTest, DealConnectionEventSuccess, TestSize.Level1)
618 {
619 DealConnectionEventSuccess();
620 }
621
622 HWTEST_F(StaStateMachineTest, DealWpaWrongPskEventFail1, TestSize.Level1)
623 {
624 DealWpaWrongPskEventFail1();
625 }
626
627 HWTEST_F(StaStateMachineTest, DealWpaWrongPskEventFail2, TestSize.Level1)
628 {
629 DealWpaWrongPskEventFail2();
630 }
631
632 HWTEST_F(StaStateMachineTest, DealStartWpsCmdSuccess, TestSize.Level1)
633 {
634 DealStartWpsCmdSuccess();
635 }
636
637 HWTEST_F(StaStateMachineTest, DealScreenStateChangedEventTest, TestSize.Level1)
638 {
639 DealScreenStateChangedEventTest();
640 }
641
642 HWTEST_F(StaStateMachineTest, InvokeOnDhcpOfferReportTest, TestSize.Level1)
643 {
644 InvokeOnDhcpOfferReportTest();
645 }
646
647 HWTEST_F(StaStateMachineTest, DealCancelWpsCmdSuccess1, TestSize.Level1)
648 {
649 DealCancelWpsCmdSuccess1();
650 }
651
652 HWTEST_F(StaStateMachineTest, DealCancelWpsCmdSuccess2, TestSize.Level1)
653 {
654 DealCancelWpsCmdSuccess2();
655 }
656
657 HWTEST_F(StaStateMachineTest, DealCancelWpsCmdSuccess3, TestSize.Level1)
658 {
659 DealCancelWpsCmdSuccess3();
660 }
661
662 HWTEST_F(StaStateMachineTest, DealCancelWpsCmdFail1, TestSize.Level1)
663 {
664 DealCancelWpsCmdFail1();
665 }
666
667 HWTEST_F(StaStateMachineTest, DealCancelWpsCmdFail2, TestSize.Level1)
668 {
669 DealCancelWpsCmdFail2();
670 }
671
672 HWTEST_F(StaStateMachineTest, DealCancelWpsCmdFail3, TestSize.Level1)
673 {
674 DealCancelWpsCmdFail3();
675 }
676
677 HWTEST_F(StaStateMachineTest, CanArpReachableTest, TestSize.Level1)
678 {
679 CanArpReachableTest();
680 }
681
682 HWTEST_F(StaStateMachineTest, PortalExpiredDetectTest, TestSize.Level1)
683 {
684 PortalExpiredDetectTest();
685 }
686 }
687 }