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 EXPECT_TRUE(p2pIface->GetSupportFreqs(1, frequencies) == HDF_SUCCESS); 76 } 77 78 HWTEST_F(WifiP2pIfaceTest, SetMacAddressTest, TestSize.Level1) 79 { 80 HDF_LOGI("SetMacAddressTest started"); 81 if (p2pIface == nullptr) { 82 HDF_LOGE("iface is null"); 83 return; 84 } 85 EXPECT_TRUE(p2pIface->SetMacAddress(TEST_MAC) == HDF_ERR_NOT_SUPPORT); 86 } 87 88 HWTEST_F(WifiP2pIfaceTest, SetCountryCodeTest, TestSize.Level1) 89 { 90 HDF_LOGI("SetCountryCodeTest started"); 91 if (p2pIface == nullptr) { 92 HDF_LOGE("iface is null"); 93 return; 94 } 95 EXPECT_TRUE(p2pIface->SetCountryCode("CN") == HDF_ERR_NOT_SUPPORT); 96 } 97 98 HWTEST_F(WifiP2pIfaceTest, GetPowerModeTest, TestSize.Level1) 99 { 100 HDF_LOGI("GetPowerModeTest started"); 101 if (p2pIface == nullptr) { 102 HDF_LOGE("iface is null"); 103 return; 104 } 105 int32_t mode; 106 EXPECT_TRUE(p2pIface->GetPowerMode(mode) == HDF_ERR_NOT_SUPPORT); 107 } 108 109 HWTEST_F(WifiP2pIfaceTest, SetPowerModeTest, TestSize.Level1) 110 { 111 HDF_LOGI("SetPowerModeTest started"); 112 if (p2pIface == nullptr) { 113 HDF_LOGE("iface is null"); 114 return; 115 } 116 EXPECT_TRUE(p2pIface->SetPowerMode(0) == HDF_ERR_NOT_SUPPORT); 117 } 118 119 HWTEST_F(WifiP2pIfaceTest, GetIfaceCapTest, TestSize.Level1) 120 { 121 HDF_LOGI("GetIfaceCapTest started"); 122 if (p2pIface == nullptr) { 123 HDF_LOGE("iface is null"); 124 return; 125 } 126 uint32_t cap; 127 EXPECT_TRUE(p2pIface->GetIfaceCap(cap) == HDF_SUCCESS); 128 } 129 130 HWTEST_F(WifiP2pIfaceTest, StartScanTest, TestSize.Level1) 131 { 132 HDF_LOGI("StartScanTest started"); 133 if (p2pIface == nullptr) { 134 HDF_LOGE("iface is null"); 135 return; 136 } 137 ScanParams scanParam; 138 scanParam.bssid = TEST_MAC; 139 EXPECT_TRUE(p2pIface->StartScan(scanParam) == HDF_ERR_NOT_SUPPORT); 140 } 141 142 HWTEST_F(WifiP2pIfaceTest, GetScanInfosTest, TestSize.Level1) 143 { 144 HDF_LOGI("GetScanInfosTest started"); 145 if (p2pIface == nullptr) { 146 HDF_LOGE("iface is null"); 147 return; 148 } 149 std::vector<ScanResultsInfo> scanResult; 150 EXPECT_TRUE(p2pIface->GetScanInfos(scanResult) == HDF_ERR_NOT_SUPPORT); 151 } 152 153 HWTEST_F(WifiP2pIfaceTest, StartPnoScanTest, TestSize.Level1) 154 { 155 HDF_LOGI("StartPnoScanTest started"); 156 if (p2pIface == nullptr) { 157 HDF_LOGE("iface is null"); 158 return; 159 } 160 PnoScanParams pnoParam; 161 pnoParam.min2gRssi = 1; 162 EXPECT_TRUE(p2pIface->StartPnoScan(pnoParam) == HDF_ERR_NOT_SUPPORT); 163 } 164 165 HWTEST_F(WifiP2pIfaceTest, StopPnoScanTest, TestSize.Level1) 166 { 167 HDF_LOGI("StopPnoScanTest started"); 168 if (p2pIface == nullptr) { 169 HDF_LOGE("iface is null"); 170 return; 171 } 172 EXPECT_TRUE(p2pIface->StopPnoScan() == HDF_ERR_NOT_SUPPORT); 173 } 174 175 HWTEST_F(WifiP2pIfaceTest, GetSignalPollInfoTest, TestSize.Level1) 176 { 177 HDF_LOGI("GetSignalPollInfoTest started"); 178 if (p2pIface == nullptr) { 179 HDF_LOGE("iface is null"); 180 return; 181 } 182 SignalPollResult info; 183 EXPECT_TRUE(p2pIface->GetSignalPollInfo(info) == HDF_ERR_NOT_SUPPORT); 184 } 185 186 HWTEST_F(WifiP2pIfaceTest, SetDpiMarkRuleTest, TestSize.Level1) 187 { 188 HDF_LOGI("SetDpiMarkRuleTest started"); 189 if (p2pIface == nullptr) { 190 HDF_LOGE("iface is null"); 191 return; 192 } 193 EXPECT_TRUE(p2pIface->SetDpiMarkRule(0, 0, 0) == HDF_ERR_NOT_SUPPORT); 194 } 195 196 HWTEST_F(WifiP2pIfaceTest, EnablePowerModeTest, TestSize.Level1) 197 { 198 HDF_LOGI("EnablePowerModeTest started"); 199 if (p2pIface == nullptr) { 200 HDF_LOGE("iface is null"); 201 return; 202 } 203 EXPECT_TRUE(p2pIface->EnablePowerMode(0) == HDF_ERR_NOT_SUPPORT); 204 } 205 }