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_p2p_iface.h" 19 20 using namespace testing::ext; 21 using namespace OHOS::HDI::Wlan::Chip::V1_0; 22 23 namespace WifiP2pIfaceTest { 24 const std::string P2P_IFNAME = "P2P0"; 25 const std::string TEST_MAC = "000000"; 26 27 class WifiP2pIfaceTest : public testing::Test { 28 public: SetUpTestCase()29 static void SetUpTestCase() {} TearDownTestCase()30 static void TearDownTestCase() {} SetUp()31 void SetUp() 32 { 33 std::weak_ptr<IfaceTool> ifaceTool = std::make_shared<IfaceTool>(); 34 WifiHalFn fn; 35 std::weak_ptr<WifiVendorHal> vendorHal = std::make_shared<WifiVendorHal>(ifaceTool, fn, true); 36 p2pIface = new (std::nothrow) WifiP2pIface(P2P_IFNAME, vendorHal, 37 std::make_shared<IfaceUtil>(ifaceTool)); 38 if (p2pIface == nullptr) { 39 HDF_LOGE("iface is null"); 40 return; 41 } 42 } TearDown()43 void TearDown() 44 { 45 HDF_LOGE("iface teardown"); 46 } 47 48 public: 49 sptr<WifiP2pIface> p2pIface; 50 }; 51 52 /** 53 * @tc.name: WifiP2pIfaceTest 54 * @tc.desc: WifiP2pIface 55 * @tc.type: FUNC 56 * @tc.require: 57 */ 58 HWTEST_F(WifiP2pIfaceTest, WifiP2pIfaceTest, TestSize.Level1) 59 { 60 HDF_LOGI("WifiP2pIfaceTest started"); 61 if (p2pIface == nullptr) { 62 HDF_LOGE("iface is null"); 63 return; 64 } 65 p2pIface->Invalidate(); 66 EXPECT_FALSE(p2pIface->IsValid()); 67 EXPECT_TRUE(p2pIface->GetName() == P2P_IFNAME); 68 IfaceType type = IfaceType::STA; 69 EXPECT_TRUE(p2pIface->GetIfaceType(type) == HDF_SUCCESS); 70 EXPECT_TRUE(type == IfaceType::P2P); 71 std::string name; 72 EXPECT_TRUE(p2pIface->GetIfaceName(name) == HDF_SUCCESS); 73 EXPECT_TRUE(name == P2P_IFNAME); 74 std::vector<uint32_t> frequencies; 75 if (p2pIface->vendorHal_.lock() != nullptr) { 76 EXPECT_TRUE(p2pIface->GetSupportFreqs(1, frequencies) == HDF_SUCCESS); 77 } 78 } 79 80 HWTEST_F(WifiP2pIfaceTest, SetMacAddressTest, TestSize.Level1) 81 { 82 HDF_LOGI("SetMacAddressTest started"); 83 if (p2pIface == nullptr) { 84 HDF_LOGE("iface is null"); 85 return; 86 } 87 EXPECT_TRUE(p2pIface->SetMacAddress(TEST_MAC) == HDF_ERR_NOT_SUPPORT); 88 } 89 90 HWTEST_F(WifiP2pIfaceTest, SetCountryCodeTest, TestSize.Level1) 91 { 92 HDF_LOGI("SetCountryCodeTest started"); 93 if (p2pIface == nullptr) { 94 HDF_LOGE("iface is null"); 95 return; 96 } 97 EXPECT_TRUE(p2pIface->SetCountryCode("CN") == HDF_ERR_NOT_SUPPORT); 98 } 99 100 HWTEST_F(WifiP2pIfaceTest, GetPowerModeTest, TestSize.Level1) 101 { 102 HDF_LOGI("GetPowerModeTest started"); 103 if (p2pIface == nullptr) { 104 HDF_LOGE("iface is null"); 105 return; 106 } 107 int32_t mode; 108 EXPECT_TRUE(p2pIface->GetPowerMode(mode) == HDF_ERR_NOT_SUPPORT); 109 } 110 111 HWTEST_F(WifiP2pIfaceTest, SetPowerModeTest, TestSize.Level1) 112 { 113 HDF_LOGI("SetPowerModeTest started"); 114 if (p2pIface == nullptr) { 115 HDF_LOGE("iface is null"); 116 return; 117 } 118 EXPECT_TRUE(p2pIface->SetPowerMode(0) == HDF_ERR_NOT_SUPPORT); 119 } 120 121 HWTEST_F(WifiP2pIfaceTest, GetIfaceCapTest, TestSize.Level1) 122 { 123 HDF_LOGI("GetIfaceCapTest started"); 124 if (p2pIface == nullptr) { 125 HDF_LOGE("iface is null"); 126 return; 127 } 128 uint32_t cap; 129 EXPECT_TRUE(p2pIface->GetIfaceCap(cap) == HDF_SUCCESS); 130 } 131 132 HWTEST_F(WifiP2pIfaceTest, StartScanTest, TestSize.Level1) 133 { 134 HDF_LOGI("StartScanTest started"); 135 if (p2pIface == nullptr) { 136 HDF_LOGE("iface is null"); 137 return; 138 } 139 ScanParams scanParam; 140 scanParam.bssid = TEST_MAC; 141 EXPECT_TRUE(p2pIface->StartScan(scanParam) == HDF_ERR_NOT_SUPPORT); 142 } 143 144 HWTEST_F(WifiP2pIfaceTest, GetScanInfosTest, TestSize.Level1) 145 { 146 HDF_LOGI("GetScanInfosTest started"); 147 if (p2pIface == nullptr) { 148 HDF_LOGE("iface is null"); 149 return; 150 } 151 std::vector<ScanResultsInfo> scanResult; 152 EXPECT_TRUE(p2pIface->GetScanInfos(scanResult) == HDF_ERR_NOT_SUPPORT); 153 } 154 155 HWTEST_F(WifiP2pIfaceTest, StartPnoScanTest, TestSize.Level1) 156 { 157 HDF_LOGI("StartPnoScanTest started"); 158 if (p2pIface == nullptr) { 159 HDF_LOGE("iface is null"); 160 return; 161 } 162 PnoScanParams pnoParam; 163 pnoParam.min2gRssi = 1; 164 EXPECT_TRUE(p2pIface->StartPnoScan(pnoParam) == HDF_ERR_NOT_SUPPORT); 165 } 166 167 HWTEST_F(WifiP2pIfaceTest, StopPnoScanTest, TestSize.Level1) 168 { 169 HDF_LOGI("StopPnoScanTest started"); 170 if (p2pIface == nullptr) { 171 HDF_LOGE("iface is null"); 172 return; 173 } 174 EXPECT_TRUE(p2pIface->StopPnoScan() == HDF_ERR_NOT_SUPPORT); 175 } 176 177 HWTEST_F(WifiP2pIfaceTest, GetSignalPollInfoTest, TestSize.Level1) 178 { 179 HDF_LOGI("GetSignalPollInfoTest started"); 180 if (p2pIface == nullptr) { 181 HDF_LOGE("iface is null"); 182 return; 183 } 184 SignalPollResult info; 185 EXPECT_TRUE(p2pIface->GetSignalPollInfo(info) == HDF_ERR_NOT_SUPPORT); 186 } 187 188 HWTEST_F(WifiP2pIfaceTest, SetDpiMarkRuleTest, TestSize.Level1) 189 { 190 HDF_LOGI("SetDpiMarkRuleTest started"); 191 if (p2pIface == nullptr) { 192 HDF_LOGE("iface is null"); 193 return; 194 } 195 EXPECT_TRUE(p2pIface->SetDpiMarkRule(0, 0, 0) == HDF_ERR_NOT_SUPPORT); 196 } 197 198 HWTEST_F(WifiP2pIfaceTest, EnablePowerModeTest, TestSize.Level1) 199 { 200 HDF_LOGI("EnablePowerModeTest started"); 201 if (p2pIface == nullptr) { 202 HDF_LOGE("iface is null"); 203 return; 204 } 205 EXPECT_TRUE(p2pIface->EnablePowerMode(0) == HDF_ERR_NOT_SUPPORT); 206 } 207 }