1 /*
2 * Copyright (c) 2023-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
18 #ifdef GTEST_API_
19 #define private public
20 #define protected public
21 #endif
22
23 #include "ethernet_service_stub.h"
24 #include "i_ethernet_service.h"
25 #include "net_manager_constants.h"
26
27 namespace OHOS {
28 namespace NetManagerStandard {
29 namespace {
30 constexpr const char *TEST_STRING = "test";
31
32 class MockEthernetServiceStubTest : public EthernetServiceStub {
33 public:
34 MockEthernetServiceStubTest() = default;
~MockEthernetServiceStubTest()35 ~MockEthernetServiceStubTest() override {}
GetMacAddress(std::vector<MacAddressInfo> & mai)36 int32_t GetMacAddress(std::vector<MacAddressInfo> &mai) override
37 {
38 return 0;
39 }
40
SetIfaceConfig(const std::string & iface,sptr<InterfaceConfiguration> & ic)41 int32_t SetIfaceConfig(const std::string &iface, sptr<InterfaceConfiguration> &ic) override
42 {
43 return 0;
44 }
45
GetIfaceConfig(const std::string & iface,sptr<InterfaceConfiguration> & ic)46 int32_t GetIfaceConfig(const std::string &iface, sptr<InterfaceConfiguration> &ic) override
47 {
48 return 0;
49 }
50
IsIfaceActive(const std::string & iface,int32_t & activeStatus)51 int32_t IsIfaceActive(const std::string &iface, int32_t &activeStatus) override
52 {
53 return 0;
54 }
55
GetAllActiveIfaces(std::vector<std::string> & activeIfaces)56 int32_t GetAllActiveIfaces(std::vector<std::string> &activeIfaces) override
57 {
58 return 0;
59 }
60
ResetFactory()61 int32_t ResetFactory() override
62 {
63 return 0;
64 }
65
RegisterIfacesStateChanged(const sptr<InterfaceStateCallback> & callback)66 int32_t RegisterIfacesStateChanged(const sptr<InterfaceStateCallback> &callback) override
67 {
68 return 0;
69 }
70
UnregisterIfacesStateChanged(const sptr<InterfaceStateCallback> & callback)71 int32_t UnregisterIfacesStateChanged(const sptr<InterfaceStateCallback> &callback) override
72 {
73 return 0;
74 }
75
SetInterfaceUp(const std::string & iface)76 int32_t SetInterfaceUp(const std::string &iface) override
77 {
78 return 0;
79 }
80
SetInterfaceDown(const std::string & iface)81 int32_t SetInterfaceDown(const std::string &iface) override
82 {
83 return 0;
84 }
85
GetInterfaceConfig(const std::string & iface,OHOS::nmd::InterfaceConfigurationParcel & config)86 int32_t GetInterfaceConfig(const std::string &iface, OHOS::nmd::InterfaceConfigurationParcel &config) override
87 {
88 return 0;
89 }
90
SetInterfaceConfig(const std::string & iface,OHOS::nmd::InterfaceConfigurationParcel & cfg)91 int32_t SetInterfaceConfig(const std::string &iface, OHOS::nmd::InterfaceConfigurationParcel &cfg) override
92 {
93 return 0;
94 }
95 };
96 } // namespace
97
98 using namespace testing::ext;
99 class EthernetServiceStubTest : public testing::Test {
100 public:
101 static void SetUpTestCase();
102 static void TearDownTestCase();
103 void SetUp();
104 void TearDown();
105 static inline std::shared_ptr<EthernetServiceStub> instance_ = std::make_shared<MockEthernetServiceStubTest>();
106 };
107
SetUpTestCase()108 void EthernetServiceStubTest::SetUpTestCase() {}
109
TearDownTestCase()110 void EthernetServiceStubTest::TearDownTestCase() {}
111
SetUp()112 void EthernetServiceStubTest::SetUp() {}
113
TearDown()114 void EthernetServiceStubTest::TearDown() {}
115
116 /**
117 * @tc.name: OnGetMacAddressTest001
118 * @tc.desc: Test EthernetServiceStub OnGetMacAddress.
119 * @tc.type: FUNC
120 */
121 HWTEST_F(EthernetServiceStubTest, OnGetMacAddressTest001, TestSize.Level1)
122 {
123 MessageParcel data;
124 if (!data.WriteInterfaceToken(EthernetServiceStub::GetDescriptor())) {
125 return;
126 }
127 if (!data.WriteString(TEST_STRING)) {
128 return;
129 }
130 MessageParcel reply;
131 MessageOption option;
132 int32_t ret = instance_->OnRemoteRequest(
133 static_cast<uint32_t>(EthernetInterfaceCode::CMD_GET_MAC_ADDR_INFO), data, reply, option);
134 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
135 }
136
137 /**
138 * @tc.name: OnSetIfaceConfigTest001
139 * @tc.desc: Test EthernetServiceStub OnSetIfaceConfig.
140 * @tc.type: FUNC
141 */
142 HWTEST_F(EthernetServiceStubTest, OnSetIfaceConfigTest001, TestSize.Level1)
143 {
144 MessageParcel data;
145 if (!data.WriteInterfaceToken(EthernetServiceStub::GetDescriptor())) {
146 return;
147 }
148 if (!data.WriteString(TEST_STRING)) {
149 return;
150 }
151 MessageParcel reply;
152 MessageOption option;
153 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(EthernetInterfaceCode::CMD_SET_IF_CFG),
154 data, reply, option);
155 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_LOCAL_PTR_NULL);
156 }
157
158 /**
159 * @tc.name: OnGetIfaceConfigTest001
160 * @tc.desc: Test EthernetServiceStub OnGetIfaceConfig.
161 * @tc.type: FUNC
162 */
163 HWTEST_F(EthernetServiceStubTest, OnGetIfaceConfigTest001, TestSize.Level1)
164 {
165 MessageParcel data;
166 if (!data.WriteInterfaceToken(EthernetServiceStub::GetDescriptor())) {
167 return;
168 }
169 if (!data.WriteString(TEST_STRING)) {
170 return;
171 }
172 MessageParcel reply;
173 MessageOption option;
174 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(EthernetInterfaceCode::CMD_GET_IF_CFG),
175 data, reply, option);
176 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
177 }
178
179 /**
180 * @tc.name: OnIsIfaceActiveTest001
181 * @tc.desc: Test EthernetServiceStub OnIsIfaceActive.
182 * @tc.type: FUNC
183 */
184 HWTEST_F(EthernetServiceStubTest, OnIsIfaceActiveTest001, TestSize.Level1)
185 {
186 MessageParcel data;
187 if (!data.WriteInterfaceToken(EthernetServiceStub::GetDescriptor())) {
188 return;
189 }
190 if (!data.WriteString(TEST_STRING)) {
191 return;
192 }
193 MessageParcel reply;
194 MessageOption option;
195 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(EthernetInterfaceCode::CMD_IS_ACTIVATE),
196 data, reply, option);
197 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
198 }
199
200 /**
201 * @tc.name: OnGetAllActiveIfacesTest001
202 * @tc.desc: Test EthernetServiceStub OnGetAllActiveIfaces.
203 * @tc.type: FUNC
204 */
205 HWTEST_F(EthernetServiceStubTest, OnGetAllActiveIfacesTest001, TestSize.Level1)
206 {
207 MessageParcel data;
208 if (!data.WriteInterfaceToken(EthernetServiceStub::GetDescriptor())) {
209 return;
210 }
211 MessageParcel reply;
212 MessageOption option;
213 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(EthernetInterfaceCode::CMD_GET_ACTIVATE_INTERFACE),
214 data, reply, option);
215 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
216 }
217
218 /**
219 * @tc.name: OnResetFactoryTest001
220 * @tc.desc: Test EthernetServiceStub OnResetFactory.
221 * @tc.type: FUNC
222 */
223 HWTEST_F(EthernetServiceStubTest, OnResetFactoryTest001, TestSize.Level1)
224 {
225 MessageParcel data;
226 if (!data.WriteInterfaceToken(EthernetServiceStub::GetDescriptor())) {
227 return;
228 }
229 MessageParcel reply;
230 MessageOption option;
231 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(EthernetInterfaceCode::CMD_RESET_FACTORY),
232 data, reply, option);
233 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
234 }
235
236 /**
237 * @tc.name: OnRegisterIfacesStateChangedTest001
238 * @tc.desc: Test EthernetServiceStub OnRegisterIfacesStateChanged.
239 * @tc.type: FUNC
240 */
241 HWTEST_F(EthernetServiceStubTest, OnRegisterIfacesStateChangedTest001, TestSize.Level1)
242 {
243 MessageParcel data;
244 if (!data.WriteInterfaceToken(EthernetServiceStub::GetDescriptor())) {
245 return;
246 }
247 MessageParcel reply;
248 MessageOption option;
249 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(EthernetInterfaceCode::CMD_REGISTER_INTERFACE_CB),
250 data, reply, option);
251 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_LOCAL_PTR_NULL);
252 }
253
254 /**
255 * @tc.name: OnUnregisterIfacesStateChangedTest001
256 * @tc.desc: Test EthernetServiceStub OnUnregisterIfacesStateChanged.
257 * @tc.type: FUNC
258 */
259 HWTEST_F(EthernetServiceStubTest, OnUnregisterIfacesStateChangedTest001, TestSize.Level1)
260 {
261 MessageParcel data;
262 if (!data.WriteInterfaceToken(EthernetServiceStub::GetDescriptor())) {
263 return;
264 }
265 MessageParcel reply;
266 MessageOption option;
267 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(EthernetInterfaceCode::CMD_UNREGISTER_INTERFACE_CB),
268 data, reply, option);
269 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_LOCAL_PTR_NULL);
270 }
271
272 /**
273 * @tc.name: OnSetInterfaceUpTest001
274 * @tc.desc: Test EthernetServiceStub OnSetInterfaceUp.
275 * @tc.type: FUNC
276 */
277 HWTEST_F(EthernetServiceStubTest, OnSetInterfaceUpTest001, TestSize.Level1)
278 {
279 MessageParcel data;
280 if (!data.WriteInterfaceToken(EthernetServiceStub::GetDescriptor())) {
281 return;
282 }
283 if (!data.WriteString(TEST_STRING)) {
284 return;
285 }
286 MessageParcel reply;
287 MessageOption option;
288 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(EthernetInterfaceCode::CMD_SET_INTERFACE_UP),
289 data, reply, option);
290 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
291 }
292
293 /**
294 * @tc.name: OnSetInterfaceDownTest001
295 * @tc.desc: Test EthernetServiceStub OnSetInterfaceDown.
296 * @tc.type: FUNC
297 */
298 HWTEST_F(EthernetServiceStubTest, OnSetInterfaceDownTest001, TestSize.Level1)
299 {
300 MessageParcel data;
301 if (!data.WriteInterfaceToken(EthernetServiceStub::GetDescriptor())) {
302 return;
303 }
304 if (!data.WriteString(TEST_STRING)) {
305 return;
306 }
307 MessageParcel reply;
308 MessageOption option;
309 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(EthernetInterfaceCode::CMD_SET_INTERFACE_DOWN),
310 data, reply, option);
311 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
312 }
313
314 /**
315 * @tc.name: OnGetInterfaceConfigTest001
316 * @tc.desc: Test EthernetServiceStub OnGetInterfaceConfig.
317 * @tc.type: FUNC
318 */
319 HWTEST_F(EthernetServiceStubTest, OnGetInterfaceConfigTest001, TestSize.Level1)
320 {
321 MessageParcel data;
322 if (!data.WriteInterfaceToken(EthernetServiceStub::GetDescriptor())) {
323 return;
324 }
325 if (!data.WriteString(TEST_STRING)) {
326 return;
327 }
328 MessageParcel reply;
329 MessageOption option;
330 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(EthernetInterfaceCode::CMD_GET_INTERFACE_CONFIG),
331 data, reply, option);
332 EXPECT_EQ(ret, NETMANAGER_EXT_SUCCESS);
333 }
334
335 /**
336 * @tc.name: OnSetInterfaceConfigTest001
337 * @tc.desc: Test EthernetServiceStub OnSetInterfaceConfig.
338 * @tc.type: FUNC
339 */
340 HWTEST_F(EthernetServiceStubTest, OnSetInterfaceConfigTest001, TestSize.Level1)
341 {
342 MessageParcel data;
343 if (!data.WriteInterfaceToken(EthernetServiceStub::GetDescriptor())) {
344 return;
345 }
346 if (!data.WriteString(TEST_STRING)) {
347 return;
348 }
349 if (!data.WriteString(TEST_STRING)) {
350 return;
351 }
352 if (!data.WriteString(TEST_STRING)) {
353 return;
354 }
355 if (!data.WriteString(TEST_STRING)) {
356 return;
357 }
358 MessageParcel reply;
359 MessageOption option;
360 int32_t ret = instance_->OnRemoteRequest(static_cast<uint32_t>(EthernetInterfaceCode::CMD_SET_INTERFACE_CONFIG),
361 data, reply, option);
362 EXPECT_EQ(ret, NETMANAGER_EXT_ERR_INVALID_PARAMETER);
363 }
364 } // namespace NetManagerStandard
365 } // namespace OHOS
366