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