1 /*
2 * Copyright (c) 2022 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 <securec.h>
18
19 #include "bus_center_event.h"
20 #include "lnn_ip_network_impl_mock.h"
21 #include "lnn_ip_network_impl.c"
22 #include "lnn_net_ledger_mock.h"
23 #include "lnn_network_manager.h"
24 #include "lnn_physical_subnet_manager.h"
25 #include "lnn_trans_mock.h"
26 #include "message_handler.h"
27 #include "softbus_adapter_mem.h"
28 #include "softbus_common.h"
29 #include "softbus_errcode.h"
30
31 #define BLE_DISABLE 0
32 #define SIZE 20
33 #define LNN_DEFAULT_IF_NAME_BR "br0"
34 namespace OHOS {
35 using namespace testing::ext;
36 using namespace testing;
37 LnnProtocolManager self;
38 LnnNetIfMgr netifMgr;
39 constexpr char WLAN_IP1[] = "127.0.0.1";
40 constexpr char WLAN_IP2[] = "127.0.0.2";
41 constexpr char IFNAME_TEST0[] = "wlan0";
42 constexpr char IFNAME_TEST1[] = "wlan1";
43 class LNNIpNetworkImplMockTest : public testing::Test {
44 public:
45 static void SetUpTestCase();
46 static void TearDownTestCase();
47 void SetUp();
48 void TearDown();
49 };
50
SetUpTestCase()51 void LNNIpNetworkImplMockTest::SetUpTestCase()
52 {
53 LooperInit();
54 }
55
TearDownTestCase()56 void LNNIpNetworkImplMockTest::TearDownTestCase()
57 {
58 LooperDeinit();
59 }
60
SetUp()61 void LNNIpNetworkImplMockTest::SetUp()
62 {
63 }
64
TearDown()65 void LNNIpNetworkImplMockTest::TearDown()
66 {
67 }
68
69 /*
70 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_001
71 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
72 * @tc.type: FUNC
73 * @tc.require: I5OMIK
74 */
75 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_001, TestSize.Level1)
76 {
77 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
78 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
79
80 ListenerModule ret = LnnGetIpListenerModule(LNN_LISTENER_MODE_PROXY);
81 EXPECT_TRUE(ret == PROXY);
82
83 ret = LnnGetIpListenerModule(LNN_LISTENER_MODE_DIRECT);
84 EXPECT_TRUE(ret == DIRECT_CHANNEL_SERVER_WIFI);
85
86 EXPECT_CALL(ipMock, LnnRegistPhysicalSubnet).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
87
88 memset_s(&self, sizeof(LnnProtocolManager), 0, sizeof(LnnProtocolManager));
89 memset_s(&netifMgr, sizeof(LnnNetIfMgr), 0, sizeof(LnnNetIfMgr));
90 strcpy_s(netifMgr.ifName, sizeof("name"), "name");
91 int32_t res = LnnEnableIpProtocol(nullptr, nullptr);
92 EXPECT_TRUE(res == SOFTBUS_ERR);
93 res = LnnEnableIpProtocol(&self, &netifMgr);
94 EXPECT_TRUE(res == SOFTBUS_ERR);
95 res = LnnEnableIpProtocol(&self, &netifMgr);
96 EXPECT_TRUE(res == SOFTBUS_OK);
97
98 EXPECT_CALL(ipMock, LnnRegisterEventHandler).WillOnce(Return(SOFTBUS_ERR)).
99 WillRepeatedly(Return(SOFTBUS_OK));
100 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo).WillOnce(Return(SOFTBUS_ERR)).
101 WillRepeatedly(Return(SOFTBUS_OK));
102
103 res = LnnInitIpProtocol(&self);
104 EXPECT_TRUE(res == SOFTBUS_ERR);
105 res = LnnInitIpProtocol(&self);
106 EXPECT_TRUE(res == SOFTBUS_ERR);
107 res = LnnInitIpProtocol(&self);
108 EXPECT_TRUE(res == SOFTBUS_OK);
109
110 WifiStateChangeEventHandler(nullptr);
111 LnnEventBasicInfo info = {
112 .event = LNN_EVENT_WIFI_STATE_CHANGED,
113 };
114 WifiStateChangeEventHandler(&info);
115 }
116
117 /*
118 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_002
119 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
120 * @tc.type: FUNC
121 * @tc.require: I5OMIK
122 */
123 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_002, TestSize.Level1)
124 {
125 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
126 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
127 EXPECT_CALL(ipMock, LnnNotifyPhysicalSubnetStatusChanged).WillRepeatedly(Return());
128 EXPECT_CALL(ipMock, LnnVisitPhysicalSubnet).WillRepeatedly(Return(true));
129 EXPECT_CALL(ipMock, LnnIsLinkReady).WillRepeatedly(Return(true));
130 EXPECT_CALL(ipMock, GetNetworkIpByIfName).WillRepeatedly(Return(SOFTBUS_OK));
131 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
132 VisitNextChoice visit = NotifyWlanAddressChanged(&netifMgr, nullptr);
133 EXPECT_TRUE(visit == CHOICE_VISIT_NEXT);
134 netifMgr.type = LNN_NETIF_TYPE_WLAN;
135 visit = NotifyWlanAddressChanged(&netifMgr, nullptr);
136 EXPECT_TRUE(visit == CHOICE_VISIT_NEXT);
137
138 LnnProtocolManager lnnProtocolManager = {
139 .id = LNN_PROTOCOL_IP,
140 };
141 LnnPhysicalSubnet subnet = {
142 .protocol = &lnnProtocolManager,
143 .status = LNN_SUBNET_RUNNING,
144 };
145
146 OnIpNetifStatusChanged(&subnet, nullptr);
147 OnSoftbusIpNetworkDisconnected(&subnet);
148 subnet.status = LNN_SUBNET_IDLE;
149 OnIpNetifStatusChanged(&subnet, nullptr);
150 OnSoftbusIpNetworkDisconnected(&subnet);
151 }
152
153 /*
154 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_003
155 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
156 * @tc.type: FUNC
157 * @tc.require: I5OMIK
158 */
159 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_003, TestSize.Level1)
160 {
161 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
162 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
163 EXPECT_CALL(ipMock, GetNetworkIpByIfName).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
164 int32_t ret = GetAvailableIpAddr(IFNAME_TEST0, const_cast<char *>(WLAN_IP1), SIZE);
165 EXPECT_TRUE(ret == SOFTBUS_ERR);
166 ret = GetAvailableIpAddr(IFNAME_TEST1, const_cast<char *>(WLAN_IP2), SIZE);
167 EXPECT_TRUE(ret == SOFTBUS_OK);
168
169 EXPECT_CALL(ipMock, GetNetworkIpByIfName).WillRepeatedly(LnnIpNetworkImplInterfaceMock::
170 ActionOfGetNetworkIpByIfName);
171 LnnPhysicalSubnet subnet = {
172 .ifName = "noDeviceName",
173 .status = LNN_SUBNET_RUNNING,
174 };
175
176 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetLocalStrInfo2);
177 IpSubnetManagerEvent res = GetIpEventInRunning(&subnet);
178 EXPECT_TRUE(res == IP_SUBNET_MANAGER_EVENT_IF_DOWN);
179
180 strcpy_s(subnet.ifName, sizeof("DeviceName"), "DeviceName");
181 res = GetIpEventInRunning(&subnet);
182 EXPECT_TRUE(res != IP_SUBNET_MANAGER_EVENT_MAX);
183 }
184
185 /*
186 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_004
187 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
188 * @tc.type: FUNC
189 * @tc.require: I5OMIK
190 */
191 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_004, TestSize.Level1)
192 {
193 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
194 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
195 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_ERR)).
196 WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetLocalStrInfo2);
197 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
198 int32_t ret = RequestMainPort("lo", "127.0.0.1");
199 EXPECT_TRUE(ret == SOFTBUS_ERR);
200 ret = RequestMainPort("lol", "127.0.0.1");
201 EXPECT_TRUE(ret == SOFTBUS_ERR);
202 ret = RequestMainPort("lol", "127.0.0.2");
203 EXPECT_TRUE(ret == SOFTBUS_ERR);
204 ret = RequestMainPort("lol", "127.0.0.2");
205 EXPECT_TRUE(ret == SOFTBUS_ERR);
206 ret = RequestMainPort("deviceName", "127.0.0.2");
207 EXPECT_TRUE(ret == SOFTBUS_ERR);
208 ret = RequestMainPort("deviceName", "127.0.0.2");
209 EXPECT_TRUE(ret == SOFTBUS_OK);
210
211 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
212 EXPECT_CALL(ipMock, AuthStartListening).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
213 EXPECT_CALL(ledgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
214 ret = OpenAuthPort();
215 EXPECT_TRUE(ret == SOFTBUS_ERR);
216 ret = OpenAuthPort();
217 EXPECT_TRUE(ret == SOFTBUS_ERR);
218 ret = OpenAuthPort();
219 EXPECT_TRUE(ret == SOFTBUS_OK);
220 ret = OpenIpLink();
221 EXPECT_TRUE(ret == SOFTBUS_OK);
222
223 EXPECT_CALL(ipMock, LnnIsLinkReady).WillRepeatedly(Return(true));
224 EXPECT_CALL(ipMock, GetNetworkIpByIfName).WillRepeatedly(LnnIpNetworkImplInterfaceMock::
225 ActionOfGetNetworkIpByIfName);
226 LnnPhysicalSubnet subnet = {
227 .ifName = "deviceName",
228 .status = LNN_SUBNET_RUNNING,
229 };
230 ret = EnableIpSubnet(&subnet);
231 EXPECT_TRUE(ret == SOFTBUS_ERR);
232 }
233 /*
234 * @tc.name: LNN_IP_NETWORK_IMPL_TEST_005
235 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
236 * @tc.type: FUNC
237 * @tc.require: I5OMIK
238 */
239 HWTEST_F(LNNIpNetworkImplMockTest, LNN_IP_NETWORK_IMPL_TEST_005, TestSize.Level1)
240 {
241 NiceMock<LnnIpNetworkImplInterfaceMock> ipMock;
242 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
243 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_ERR)).
244 WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetLocalStrInfo2);
245 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
246 int32_t ret = ReleaseMainPort("deviceName");
247 EXPECT_TRUE(ret == SOFTBUS_ERR);
248 ret = ReleaseMainPort("deviceName1");
249 EXPECT_TRUE(ret == SOFTBUS_ERR);
250 ret = ReleaseMainPort("deviceName");
251 EXPECT_TRUE(ret == SOFTBUS_OK);
252
253 EXPECT_CALL(ipMock, LnnGetAddrTypeByIfName).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
254 EXPECT_CALL(ipMock, LnnRequestLeaveByAddrType).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
255 LeaveOldIpNetwork(nullptr);
256 LeaveOldIpNetwork(nullptr);
257 LeaveOldIpNetwork(nullptr);
258
259 EXPECT_CALL(ledgerMock, LnnSetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_OK));
260 EXPECT_CALL(ipMock, ConnStopLocalListening).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
261 CloseProxyPort();
262 CloseProxyPort();
263 }
264 } // namespace OHOS
265