1 /*
2 * Copyright (c) 2025 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 <fstream>
18
19 #include "eth_eap_profile.h"
20 #include "eap_hdi_wpa_manager.h"
21 #include "netmgr_ext_log_wrapper.h"
22 #include "net_manager_constants.h"
23
24 #ifdef GTEST_API_
25 #define private public
26 #define protected public
27 #endif
28
29 namespace OHOS {
30 namespace NetManagerStandard {
31 namespace {
32 using namespace testing::ext;
33 }
34
35 static constexpr const char* CONFIG_PATH = "/data/service/el1/public/eth/";
36 static constexpr const char* ETH_NAME = "eth0";
37
38 class EapHdiWpaManagerTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp();
43 void TearDown();
44 };
45
SetUpTestCase()46 void EapHdiWpaManagerTest::SetUpTestCase() {};
47
TearDownTestCase()48 void EapHdiWpaManagerTest::TearDownTestCase() {};
49
SetUp()50 void EapHdiWpaManagerTest::SetUp() {};
51
TearDown()52 void EapHdiWpaManagerTest::TearDown() {};
53
54 HWTEST_F(EapHdiWpaManagerTest, LoadEthernetHdiServiceTest001, TestSize.Level1)
55 {
56 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
57 EXPECT_EQ(manager_->LoadEthernetHdiService(), NETMANAGER_EXT_SUCCESS);
58 manager_->iEthernet_ = nullptr;
59 EXPECT_NE(manager_->LoadEthernetHdiService(), NETMANAGER_EXT_SUCCESS);
60 manager_->devMgr_ = nullptr;
61 EXPECT_NE(manager_->LoadEthernetHdiService(), NETMANAGER_EXT_SUCCESS);
62 EXPECT_NE(manager_->LoadEthernetHdiService(), NETMANAGER_EXT_SUCCESS);
63 }
64
65 HWTEST_F(EapHdiWpaManagerTest, StartEapTest001, TestSize.Level1)
66 {
67 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
68 std::string ifName = "eth0";
69 EthEapProfile profile;
70 manager_->LoadEthernetHdiService();
71 EXPECT_NE(manager_->StartEap(ifName, profile), NETMANAGER_EXT_SUCCESS);
72 manager_->iEthernet_ = nullptr;
73 EXPECT_NE(manager_->StartEap(ifName, profile), NETMANAGER_EXT_SUCCESS);
74 }
75
76 HWTEST_F(EapHdiWpaManagerTest, StopEapTest001, TestSize.Level1)
77 {
78 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
79 std::string ifName = "eth0";
80 manager_->LoadEthernetHdiService();
81 EXPECT_NE(manager_->StopEap(ifName), NETMANAGER_EXT_SUCCESS);
82 manager_->devMgr_ = nullptr;
83 EXPECT_NE(manager_->StopEap(ifName), NETMANAGER_EXT_SUCCESS);
84 manager_->iEthernet_ = nullptr;
85 EXPECT_NE(manager_->StopEap(ifName), NETMANAGER_EXT_SUCCESS);
86 }
87
88 HWTEST_F(EapHdiWpaManagerTest, SetEapConfigTest001, TestSize.Level1)
89 {
90 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
91 EthEapProfile profile;
92 std::string ifName = "eth0";
93 EXPECT_EQ(manager_->SetEapConfig(profile, ifName), NETMANAGER_EXT_SUCCESS);
94 profile.eapMethod = EapMethod::EAP_PEAP;
95 EXPECT_EQ(manager_->SetEapConfig(profile, ifName), NETMANAGER_EXT_SUCCESS);
96 profile.eapMethod = EapMethod::EAP_TTLS;
97 EXPECT_EQ(manager_->SetEapConfig(profile, ifName), NETMANAGER_EXT_SUCCESS);
98 profile.eapMethod = EapMethod::EAP_TLS;
99 EXPECT_EQ(manager_->SetEapConfig(profile, ifName), NETMANAGER_EXT_SUCCESS);
100 profile.eapMethod = EapMethod::EAP_PWD;
101 EXPECT_EQ(manager_->SetEapConfig(profile, ifName), NETMANAGER_EXT_SUCCESS);
102 profile.eapMethod = EapMethod::EAP_NONE;
103 EXPECT_EQ(manager_->SetEapConfig(profile, ifName), NETMANAGER_EXT_SUCCESS);
104 }
105
106 HWTEST_F(EapHdiWpaManagerTest, RemoveHistoryCtrl001, TestSize.Level1)
107 {
108 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
109 std::string destPath = std::string(CONFIG_PATH) + "a.txt";
110 std::ofstream file;
111 file.open(destPath, std::ios::out);
112 if (file.is_open()) {
113 file << "test" << std::endl;
114 file.close();
115 }
116 manager_->RemoveHistoryCtrl();
117 EXPECT_EQ(manager_->iEthernet_, nullptr);
118 }
119
120 HWTEST_F(EapHdiWpaManagerTest, EapShellCmdTest001, TestSize.Level1)
121 {
122 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
123 std::string ifName = "eth0";
124 std::string cmd = "EAP_AUTH 2:1:1";
125 manager_->LoadEthernetHdiService();
126 EXPECT_NE(manager_->EapShellCmd(ifName, cmd), NETMANAGER_EXT_SUCCESS);
127 manager_->iEthernet_ = nullptr;
128 EXPECT_NE(manager_->EapShellCmd(ifName, cmd), NETMANAGER_EXT_SUCCESS);
129 }
130
131 HWTEST_F(EapHdiWpaManagerTest, RegisterEapEventCallbackTest001, TestSize.Level1)
132 {
133 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
134 std::string ifName = "eth0";
135 manager_->LoadEthernetHdiService();
136 EXPECT_NE(manager_->RegisterEapEventCallback(ifName), NETMANAGER_EXT_SUCCESS);
137 manager_->iEthernet_ = nullptr;
138 EXPECT_NE(manager_->RegisterEapEventCallback(ifName), NETMANAGER_EXT_SUCCESS);
139 }
140
141 HWTEST_F(EapHdiWpaManagerTest, UnregisterEapEventCallbackTest001, TestSize.Level1)
142 {
143 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
144 std::string ifName = "eth0";
145 manager_->LoadEthernetHdiService();
146 EXPECT_NE(manager_->UnregisterEapEventCallback(ifName), NETMANAGER_EXT_SUCCESS);
147 manager_->iEthernet_ = nullptr;
148 EXPECT_NE(manager_->UnregisterEapEventCallback(ifName), NETMANAGER_EXT_SUCCESS);
149 }
150
151 HWTEST_F(EapHdiWpaManagerTest, Phase2MethodToStrTest001, TestSize.Level1)
152 {
153 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
154 EapMethod eap = EapMethod::EAP_NONE;
155 Phase2Method method = Phase2Method::PHASE2_GTC;
156 std::string resultStr = "auth=NONE";
157 EXPECT_NE(manager_->Phase2MethodToStr(eap, method), resultStr);
158 eap = EapMethod::EAP_NONE;
159 method = Phase2Method::PHASE2_GTC;
160 EXPECT_NE(manager_->Phase2MethodToStr(eap, method), resultStr);
161 eap = EapMethod::EAP_TTLS;
162 method = Phase2Method::PHASE2_GTC;
163 EXPECT_NE(manager_->Phase2MethodToStr(eap, method), resultStr);
164 eap = EapMethod::EAP_TTLS;
165 method = Phase2Method::PHASE2_NONE;
166 EXPECT_EQ(manager_->Phase2MethodToStr(eap, method), resultStr);
167 eap = EapMethod::EAP_TTLS;
168 method = Phase2Method::PHASE2_GTC;
169 EXPECT_NE(manager_->Phase2MethodToStr(eap, method), resultStr);
170 eap = EapMethod::EAP_NONE;
171 method = Phase2Method::PHASE2_NONE;
172 EXPECT_EQ(manager_->Phase2MethodToStr(eap, method), resultStr);
173 }
174
175 HWTEST_F(EapHdiWpaManagerTest, WriteEapConfigToFile001, TestSize.Level1)
176 {
177 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
178 std::string context = "test";
179 EXPECT_TRUE(manager_->WriteEapConfigToFile(context));
180 }
181
182 HWTEST_F(EapHdiWpaManagerTest, OnEapEventReport001, TestSize.Level1)
183 {
184 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
185 const char *value = "1:1:1:3:111:111";
186 const char *ifName = "eth0";
187 EXPECT_NE(manager_->OnEapEventReport(nullptr, ifName, value), NETMANAGER_EXT_SUCCESS);
188 value = "1:1:1:3";
189 EXPECT_NE(manager_->OnEapEventReport(nullptr, ifName, value), NETMANAGER_EXT_SUCCESS);
190 }
191
192 HWTEST_F(EapHdiWpaManagerTest, ConvertStrToInt001, TestSize.Level1)
193 {
194 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
195 std::string value = "1:1:1:3:111";
196 int32_t res;
197 EXPECT_FALSE(manager_->ConvertStrToInt(value, res));
198 value = "10";
199 EXPECT_TRUE(manager_->ConvertStrToInt(value, res));
200 }
201
202 HWTEST_F(EapHdiWpaManagerTest, RegisterCustomEapCallbackTest001, TestSize.Level1)
203 {
204 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
205 std::string ifName = "eth0";
206 std::string regCmd = "2:277:278";
207 manager_->LoadEthernetHdiService();
208 EXPECT_NE(manager_->RegisterCustomEapCallback(ifName, regCmd), NETMANAGER_EXT_SUCCESS);
209 manager_->iEthernet_ = nullptr;
210 EXPECT_NE(manager_->RegisterCustomEapCallback(ifName, regCmd), NETMANAGER_EXT_SUCCESS);
211 }
212
213 HWTEST_F(EapHdiWpaManagerTest, ReplyCustomEapDataTest001, TestSize.Level1)
214 {
215 std::shared_ptr<EapHdiWpaManager> manager_ = std::make_shared<EapHdiWpaManager>();
216 std::string ifName = "eth0";
217 int32_t result = 1;
218 std::string regCmd = "2:277:278";
219 sptr<EapData> eapData =new (std::nothrow) EapData();
220 eapData->eapCode = 1;
221 eapData->eapType = 13;
222 eapData->msgId = 55;
223 eapData->bufferLen = 4;
224 std::vector<uint8_t> tmp = {0x11, 0x12};
225 eapData->eapBuffer = tmp;
226 manager_->LoadEthernetHdiService();
227 EXPECT_NE(manager_->ReplyCustomEapData(ifName, result, eapData), NETMANAGER_EXT_SUCCESS);
228 manager_->iEthernet_ = nullptr;
229 EXPECT_NE(manager_->ReplyCustomEapData(ifName, result, eapData), NETMANAGER_EXT_SUCCESS);
230 }
231
232 } // namespace NetManagerStandard
233 } // namespace OHOS
234