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 <fcntl.h>
17 #include <gtest/gtest.h>
18 #include <iostream>
19 #include <memory>
20
21 #include "i_net_interface_callback.h"
22 #include "net_interface_config.h"
23 #include "net_interface_callback_stub.h"
24 #include "net_manager_constants.h"
25
26 namespace OHOS {
27 namespace NetManagerStandard {
28 using namespace testing::ext;
29 namespace {
30 constexpr uint64_t OUT_OF_RANGE_CODE = 100;
31 constexpr const char *TEST_IPV4_ADDR = "127.0.0.1";
32 constexpr const char *TEST_IFACE = "eth0";
33
34 class NetInterfaceCallbackStubTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp();
39 void TearDown();
40
41 static inline std::shared_ptr<NetInterfaceStateCallbackStub> instance_ =
42 std::make_shared<NetInterfaceStateCallbackStub>();
43 };
44
SetUpTestCase()45 void NetInterfaceCallbackStubTest::SetUpTestCase() {}
46
TearDownTestCase()47 void NetInterfaceCallbackStubTest::TearDownTestCase() {}
48
SetUp()49 void NetInterfaceCallbackStubTest::SetUp() {}
50
TearDown()51 void NetInterfaceCallbackStubTest::TearDown() {}
52
53 /**
54 * @tc.name: OnRemoteRequestTest001
55 * @tc.desc: Test NetInterfaceStateCallbackStub OnRemoteRequest.
56 * @tc.type: FUNC
57 */
58 HWTEST_F(NetInterfaceCallbackStubTest, OnRemoteRequestTest001, TestSize.Level1)
59 {
60 MessageParcel data;
61 MessageParcel reply;
62 MessageOption option;
63 int32_t ret = instance_->OnRemoteRequest(OUT_OF_RANGE_CODE, data, reply, option);
64 EXPECT_EQ(ret, NETMANAGER_ERR_DESCRIPTOR_MISMATCH);
65 }
66
67 /**
68 * @tc.name: OnRemoteRequestTest002
69 * @tc.desc: Test NetInterfaceStateCallbackStub OnRemoteRequest.
70 * @tc.type: FUNC
71 */
72 HWTEST_F(NetInterfaceCallbackStubTest, OnRemoteRequestTest002, TestSize.Level1)
73 {
74 MessageParcel data;
75 data.WriteInterfaceToken(NetInterfaceStateCallbackStub::GetDescriptor());
76 MessageParcel reply;
77 MessageOption option;
78 int32_t ret = instance_->OnRemoteRequest(OUT_OF_RANGE_CODE, data, reply, option);
79 EXPECT_EQ(ret, IPC_STUB_UNKNOW_TRANS_ERR);
80 }
81
82 /**
83 * @tc.name: OnInterfaceAddressUpdatedTest001
84 * @tc.desc: Test NetInterfaceStateCallbackStub OnInterfaceAddressUpdated.
85 * @tc.type: FUNC
86 */
87 HWTEST_F(NetInterfaceCallbackStubTest, OnInterfaceAddressUpdatedTest001, TestSize.Level1)
88 {
89 int32_t ret = NETMANAGER_SUCCESS;
90 MessageParcel data;
91 if (!data.WriteInterfaceToken(NetInterfaceStateCallbackStub::GetDescriptor())) {
92 ret = NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
93 }
94 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
95
96 ret = NETMANAGER_SUCCESS;
97 if (!data.WriteString(TEST_IPV4_ADDR)) {
98 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
99 }
100 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
101
102 if (!data.WriteString(TEST_IFACE)) {
103 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
104 }
105 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
106
107 int32_t flag = 0xffff;
108 if (!data.WriteInt32(flag)) {
109 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
110 }
111 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
112
113 int32_t scope = 1;
114 if (!data.WriteInt32(scope)) {
115 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
116 }
117 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
118
119 MessageParcel reply;
120 MessageOption option;
121 ret = instance_->OnRemoteRequest(static_cast<uint32_t>(InterfaceCallbackInterfaceCode::CMD_ON_IFACE_ADDR_UPDATED),
122 data, reply, option);
123 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
124 }
125
126 /**
127 * @tc.name: OnInterfaceAddressRemovedTest001
128 * @tc.desc: Test NetInterfaceStateCallbackStub OnInterfaceAddressRemoved.
129 * @tc.type: FUNC
130 */
131 HWTEST_F(NetInterfaceCallbackStubTest, OnInterfaceAddressRemovedTest001, TestSize.Level1)
132 {
133 int32_t ret = NETMANAGER_SUCCESS;
134 MessageParcel data;
135 if (!data.WriteInterfaceToken(NetInterfaceStateCallbackStub::GetDescriptor())) {
136 ret = NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
137 }
138 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
139
140 ret = NETMANAGER_SUCCESS;
141 if (!data.WriteString(TEST_IPV4_ADDR)) {
142 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
143 }
144 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
145
146 if (!data.WriteString(TEST_IFACE)) {
147 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
148 }
149 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
150
151 int32_t flag = 0xffff;
152 if (!data.WriteInt32(flag)) {
153 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
154 }
155 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
156
157 int32_t scope = 1;
158 if (!data.WriteInt32(scope)) {
159 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
160 }
161 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
162
163 MessageParcel reply;
164 MessageOption option;
165 ret = instance_->OnRemoteRequest(
166 static_cast<uint32_t>(InterfaceCallbackInterfaceCode::CMD_ON_IFACE_ADDR_REMOVED), data, reply, option);
167 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
168 }
169
170 /**
171 * @tc.name: OnInterfaceAddedTest001
172 * @tc.desc: Test NetInterfaceStateCallbackStub OnInterfaceAdded.
173 * @tc.type: FUNC
174 */
175 HWTEST_F(NetInterfaceCallbackStubTest, OnInterfaceAddedTest001, TestSize.Level1)
176 {
177 int32_t ret = NETMANAGER_SUCCESS;
178 MessageParcel data;
179 if (!data.WriteInterfaceToken(NetInterfaceStateCallbackStub::GetDescriptor())) {
180 ret = NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
181 }
182 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
183
184 if (!data.WriteString(TEST_IFACE)) {
185 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
186 }
187 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
188
189 MessageParcel reply;
190 MessageOption option;
191 ret = instance_->OnRemoteRequest(
192 static_cast<uint32_t>(InterfaceCallbackInterfaceCode::CMD_ON_IFACE_ADDED), data, reply, option);
193 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
194 }
195
196 /**
197 * @tc.name: OnInterfaceRemovedTest001
198 * @tc.desc: Test NetInterfaceStateCallbackStub OnInterfaceRemoved.
199 * @tc.type: FUNC
200 */
201 HWTEST_F(NetInterfaceCallbackStubTest, OnInterfaceRemovedTest001, TestSize.Level1)
202 {
203 int32_t ret = NETMANAGER_SUCCESS;
204 MessageParcel data;
205 if (!data.WriteInterfaceToken(NetInterfaceStateCallbackStub::GetDescriptor())) {
206 ret = NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
207 }
208 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
209
210 if (!data.WriteString(TEST_IFACE)) {
211 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
212 }
213 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
214
215 MessageParcel reply;
216 MessageOption option;
217 ret = instance_->OnRemoteRequest(
218 static_cast<uint32_t>(InterfaceCallbackInterfaceCode::CMD_ON_IFACE_REMOVED), data, reply, option);
219 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
220 }
221
222 /**
223 * @tc.name: OnInterfaceChangedTest001
224 * @tc.desc: Test NetInterfaceStateCallbackStub OnInterfaceChanged.
225 * @tc.type: FUNC
226 */
227 HWTEST_F(NetInterfaceCallbackStubTest, OnInterfaceChangedTest001, TestSize.Level1)
228 {
229 int32_t ret = NETMANAGER_SUCCESS;
230 MessageParcel data;
231 if (!data.WriteInterfaceToken(NetInterfaceStateCallbackStub::GetDescriptor())) {
232 ret = NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
233 }
234 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
235
236 if (!data.WriteString(TEST_IFACE)) {
237 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
238 }
239 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
240
241 if (!data.WriteBool(true)) {
242 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
243 }
244 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
245
246 MessageParcel reply;
247 MessageOption option;
248 ret = instance_->OnRemoteRequest(
249 static_cast<uint32_t>(InterfaceCallbackInterfaceCode::CMD_ON_IFACE_CHANGED), data, reply, option);
250 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
251 }
252
253 /**
254 * @tc.name: OnInterfaceLinkStateChangedTest001
255 * @tc.desc: Test NetInterfaceStateCallbackStub OnInterfaceLinkStateChanged.
256 * @tc.type: FUNC
257 */
258 HWTEST_F(NetInterfaceCallbackStubTest, OnInterfaceLinkStateChangedTest001, TestSize.Level1)
259 {
260 int32_t ret = NETMANAGER_SUCCESS;
261 MessageParcel data;
262 if (!data.WriteInterfaceToken(NetInterfaceStateCallbackStub::GetDescriptor())) {
263 ret = NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
264 }
265 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
266
267 if (!data.WriteString(TEST_IFACE)) {
268 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
269 }
270 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
271
272 if (!data.WriteBool(true)) {
273 ret = NETMANAGER_ERR_WRITE_DATA_FAIL;
274 }
275 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
276
277 MessageParcel reply;
278 MessageOption option;
279 ret = instance_->OnRemoteRequest(
280 static_cast<uint32_t>(InterfaceCallbackInterfaceCode::CMD_ON_IFACE_LINK_STATE_CHANGED), data, reply, option);
281 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
282 }
283 } // namespace
284 } // namespace NetManagerStandard
285 } // namespace OHOS