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 16 #include <gtest/gtest.h> 17 #include <hdf_log.h> 18 #include "../../../chip/hdi_service/wifi_sta_iface.h" 19 #include "wifi_hal_fn.h" 20 21 using namespace testing::ext; 22 using namespace OHOS::HDI::Wlan::Chip::V2_0; 23 24 namespace WifiStaIfaceTest { 25 const std::string WLAN_IFNAME = "wlan0"; 26 const std::string AP_IFNAME = "wlan1"; 27 const std::string TEST_MAC = "000000"; 28 29 class WifiStaIfaceTest : public testing::Test { 30 public: SetUpTestCase()31 static void SetUpTestCase() {} TearDownTestCase()32 static void TearDownTestCase() {} SetUp()33 void SetUp() 34 { 35 std::vector<std::string> instances = {WLAN_IFNAME}; 36 ifaceTool = std::make_shared<IfaceTool>(); 37 ifaceUtil = std::make_shared<IfaceUtil>(ifaceTool); 38 WifiHalFn fn; 39 InitWifiHalFuncTable(&fn); 40 wifiVendorHalTest = std::make_shared<WifiVendorHal>(ifaceTool, fn, true); 41 staIface = new (std::nothrow) WifiStaIface(WLAN_IFNAME, wifiVendorHalTest, ifaceUtil); 42 testIface = new (std::nothrow) WifiStaIface(AP_IFNAME, wifiVendorHalTest, ifaceUtil); 43 } TearDown()44 void TearDown() 45 { 46 wifiVendorHalTest.reset(); 47 ifaceTool.reset(); 48 ifaceUtil.reset(); 49 } 50 51 public: 52 std::shared_ptr<WifiVendorHal> wifiVendorHalTest; 53 std::shared_ptr<IfaceTool> ifaceTool; 54 std::shared_ptr<IfaceUtil> ifaceUtil; 55 sptr<WifiStaIface> staIface; 56 sptr<WifiStaIface> testIface; 57 }; 58 59 /** 60 * @tc.name: WifiStaIfaceTest001 61 * @tc.desc: wifiStaIface 62 * @tc.type: FUNC 63 * @tc.require: 64 */ 65 HWTEST_F(WifiStaIfaceTest, WifiStaIfaceTest001, TestSize.Level1) 66 { 67 HDF_LOGI("WifiStaIfaceTest001 started"); 68 staIface->Invalidate(); 69 EXPECT_FALSE(staIface->IsValid()); 70 staIface->IsValid(); 71 EXPECT_TRUE(staIface->GetName() == WLAN_IFNAME); 72 IfaceType type = IfaceType::AP; 73 EXPECT_TRUE(staIface->GetIfaceType(type) == HDF_SUCCESS); 74 EXPECT_TRUE(type == IfaceType::STA); 75 std::string name; 76 EXPECT_TRUE(staIface->GetIfaceName(name) == HDF_SUCCESS); 77 EXPECT_TRUE(name == WLAN_IFNAME); 78 } 79 80 HWTEST_F(WifiStaIfaceTest, SetDpiMarkRuleTest, TestSize.Level1) 81 { 82 HDF_LOGI("SetDpiMarkRuleTest started"); 83 EXPECT_TRUE(staIface->SetDpiMarkRule(0, 0, 0) == HDF_SUCCESS); 84 EXPECT_TRUE(staIface->SetDpiMarkRule(1, 1, 1) == HDF_FAILURE); 85 EXPECT_TRUE(staIface->SetTxPower(0) == HDF_SUCCESS); 86 EXPECT_TRUE(staIface->SetTxPower(1) == HDF_FAILURE); 87 } 88 89 HWTEST_F(WifiStaIfaceTest, EnablePowerModeTest, TestSize.Level1) 90 { 91 HDF_LOGI("EnablePowerModeTest started"); 92 EXPECT_TRUE(staIface->EnablePowerMode(0) == HDF_SUCCESS); 93 uint32_t cap; 94 EXPECT_TRUE(staIface->GetIfaceCap(cap) == HDF_SUCCESS); 95 EXPECT_TRUE(testIface->GetIfaceCap(cap) == HDF_FAILURE); 96 } 97 98 HWTEST_F(WifiStaIfaceTest, GetSupportFreqsTest, TestSize.Level1) 99 { 100 HDF_LOGI("GetSupportFreqsTest started"); 101 std::vector<uint32_t> freqs; 102 EXPECT_TRUE(staIface->GetSupportFreqs(0, freqs) == HDF_SUCCESS); 103 EXPECT_TRUE(staIface->SetMacAddress(TEST_MAC) == HDF_SUCCESS); 104 EXPECT_TRUE(staIface->SetCountryCode("cn") == HDF_SUCCESS); 105 EXPECT_TRUE(staIface->SetPowerMode(0) == HDF_ERR_NOT_SUPPORT); 106 int32_t mode; 107 EXPECT_TRUE(staIface->GetPowerMode(mode) == HDF_ERR_NOT_SUPPORT); 108 } 109 110 HWTEST_F(WifiStaIfaceTest, RegisterChipIfaceCallBackTest, TestSize.Level1) 111 { 112 HDF_LOGI("RegisterChipIfaceCallBackTest started"); 113 sptr<IChipIfaceCallback> ifaceCallback; 114 EXPECT_TRUE(staIface->RegisterChipIfaceCallBack(ifaceCallback) == HDF_FAILURE); 115 EXPECT_TRUE(staIface->UnRegisterChipIfaceCallBack(ifaceCallback) == HDF_FAILURE); 116 } 117 118 HWTEST_F(WifiStaIfaceTest, ScanTest, TestSize.Level1) 119 { 120 HDF_LOGI("ScanTest started"); 121 ScanParams scanParam; 122 scanParam.fastConnectFlag = 0; 123 EXPECT_TRUE(staIface->StartScan(scanParam) == HDF_SUCCESS); 124 scanParam.fastConnectFlag = 1; 125 EXPECT_TRUE(staIface->StartScan(scanParam) == HDF_FAILURE); 126 std::vector<ScanResultsInfo> scanInfo; 127 staIface->GetScanInfos(scanInfo); 128 SignalPollResult signalPollResult; 129 staIface->GetSignalPollInfo(signalPollResult); 130 PnoScanParams pnoParam; 131 pnoParam.min2gRssi = 0; 132 EXPECT_TRUE(staIface->StartPnoScan(pnoParam) == HDF_SUCCESS); 133 pnoParam.min2gRssi = 1; 134 EXPECT_TRUE(staIface->StartPnoScan(pnoParam) == HDF_FAILURE); 135 EXPECT_TRUE(staIface->StopPnoScan() == HDF_SUCCESS); 136 } 137 }