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 }