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 #include <cstddef>
19 #include <cstdlib>
20 #include <cstring>
21 
22 #include "lnn_connection_addr_utils.h"
23 #include "lnn_log.h"
24 #include "softbus_adapter_mem.h"
25 #include "softbus_errcode.h"
26 #include "softbus_def.h"
27 #include "softbus_common.h"
28 
29 namespace OHOS {
30 using namespace testing::ext;
31 using namespace testing;
32 constexpr char NODE1_BR_MAC[] = "12345TTU";
33 constexpr char NODE1_BLE_MAC[] = "23456TTU";
34 constexpr uint8_t NODE1_UDID_HASH[] = "node1hash";
35 constexpr char NODE1_IP[] = "10.146.181.134";
36 constexpr uint16_t NODE1_PORT = 10;
37 constexpr int32_t NODE1_SESSION_ID = 100;
38 constexpr int32_t NODE1_CHANNEL_ID = 100;
39 constexpr int32_t NODE1_SESSION_TYPE = 100;
40 constexpr char NODE2_BR_MAC[] = "56789TTU";
41 constexpr char NODE2_BLE_MAC[] = "67890TTU";
42 constexpr uint8_t NODE2_UDID_HASH[] = "node2hash";
43 constexpr char NODE2_IP[] = "10.147.182.135";
44 constexpr uint16_t NODE2_PORT = 20;
45 constexpr int32_t NODE2_SESSION_ID = 200;
46 constexpr int32_t NODE2_CHANNEL_ID = 200;
47 constexpr int32_t NODE2_SESSION_TYPE = 200;
48 class LNNConnAddrUtilsTest : public testing::Test {
49 public:
50     static void SetUpTestCase();
51     static void TearDownTestCase();
52     void SetUp();
53     void TearDown();
54 };
55 
SetUpTestCase()56 void LNNConnAddrUtilsTest::SetUpTestCase() {}
57 
TearDownTestCase()58 void LNNConnAddrUtilsTest::TearDownTestCase() {}
59 
SetUp()60 void LNNConnAddrUtilsTest::SetUp()
61 {
62     LNN_LOGI(LNN_TEST, "LNNConnAddrUtilsTest start");
63 }
64 
TearDown()65 void LNNConnAddrUtilsTest::TearDown() {}
66 
67 /*
68 * @tc.name: LNN_IS_SAME_CONNECTION_ADDR_Test_001
69 * @tc.desc: lnn is same connection addr test
70 * @tc.type: FUNC
71 * @tc.require:
72 */
73 HWTEST_F(LNNConnAddrUtilsTest, LNN_IS_SAME_CONNECTION_ADDR_Test_001, TestSize.Level1)
74 {
75     ConnectionAddr addr1;
76     ConnectionAddr addr2;
77     (void)memset_s(&addr1, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
78     (void)memset_s(&addr2, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
79     (void)strcpy_s(addr1.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
80     (void)strcpy_s(addr1.info.ble.bleMac, BT_MAC_LEN, NODE1_BLE_MAC);
81     (void)memcpy_s(addr1.info.ble.udidHash, UDID_HASH_LEN, NODE1_UDID_HASH, UDID_HASH_LEN);
82     (void)strcpy_s(addr1.info.ip.ip, IP_STR_MAX_LEN, NODE1_IP);
83     addr1.info.ip.port = NODE1_PORT;
84     addr1.info.session.sessionId = NODE1_SESSION_ID;
85     addr1.info.session.channelId = NODE1_CHANNEL_ID;
86     addr1.info.session.type = NODE1_SESSION_TYPE;
87     (void)strcpy_s(addr2.info.br.brMac, BT_MAC_LEN, NODE2_BR_MAC);
88     (void)strcpy_s(addr2.info.ble.bleMac, BT_MAC_LEN, NODE2_BLE_MAC);
89     (void)memcpy_s(addr2.info.ble.udidHash, UDID_HASH_LEN, NODE2_UDID_HASH, UDID_HASH_LEN);
90     (void)strcpy_s(addr2.info.ip.ip, IP_STR_MAX_LEN, NODE2_IP);
91     addr2.info.ip.port = NODE2_PORT;
92     addr2.info.session.sessionId = NODE2_SESSION_ID;
93     addr2.info.session.channelId = NODE2_CHANNEL_ID;
94     addr2.info.session.type = NODE2_SESSION_TYPE;
95     addr1.type = CONNECTION_ADDR_BR;
96     addr2.type = CONNECTION_ADDR_BLE;
97     EXPECT_TRUE(!LnnIsSameConnectionAddr(nullptr, nullptr, false));
98     EXPECT_TRUE(!LnnIsSameConnectionAddr(&addr1, &addr2, false));
99     addr2.type = CONNECTION_ADDR_BR;
100     EXPECT_TRUE(!LnnIsSameConnectionAddr(&addr1, &addr2, false));
101     EXPECT_TRUE(LnnIsSameConnectionAddr(&addr1, &addr1, false));
102     addr1.type = CONNECTION_ADDR_BLE;
103     EXPECT_TRUE(!LnnIsSameConnectionAddr(&addr1, &addr2, false));
104     EXPECT_TRUE(LnnIsSameConnectionAddr(&addr1, &addr1, false));
105     addr1.type = CONNECTION_ADDR_WLAN;
106     addr2.type = CONNECTION_ADDR_WLAN;
107     EXPECT_TRUE(!LnnIsSameConnectionAddr(&addr1, &addr2, false));
108     EXPECT_TRUE(LnnIsSameConnectionAddr(&addr1, &addr1, false));
109     addr1.type = CONNECTION_ADDR_ETH;
110     addr2.type = CONNECTION_ADDR_ETH;
111     EXPECT_TRUE(!LnnIsSameConnectionAddr(&addr1, &addr2, false));
112     EXPECT_TRUE(LnnIsSameConnectionAddr(&addr1, &addr1, false));
113     addr1.type = CONNECTION_ADDR_SESSION;
114     addr2.type = CONNECTION_ADDR_SESSION;
115     EXPECT_TRUE(!LnnIsSameConnectionAddr(&addr1, &addr2, false));
116     EXPECT_TRUE(LnnIsSameConnectionAddr(&addr1, &addr1, false));
117     addr1.type = CONNECTION_ADDR_MAX;
118     addr2.type = CONNECTION_ADDR_MAX;
119     EXPECT_TRUE(!LnnIsSameConnectionAddr(&addr1, &addr2, false));
120 }
121 
122 /*
123 * @tc.name: LNN_CONVERT_ADDR_TO_OPTION_Test_001
124 * @tc.desc: lnn convert addr to option test
125 * @tc.type: FUNC
126 * @tc.require:
127 */
128 HWTEST_F(LNNConnAddrUtilsTest, LNN_CONVERT_ADDR_TO_OPTION_Test_001, TestSize.Level1)
129 {
130     ConnectionAddr addr;
131     ConnectOption option;
132     (void)memset_s(&addr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
133     (void)memset_s(&option, sizeof(ConnectOption), 0, sizeof(ConnectOption));
134     addr.type = CONNECTION_ADDR_BR;
135     (void)strcpy_s(addr.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
136     (void)strcpy_s(addr.info.ble.bleMac, BT_MAC_LEN, NODE1_BLE_MAC);
137     (void)memcpy_s(addr.info.ble.udidHash, UDID_HASH_LEN, NODE1_UDID_HASH, UDID_HASH_LEN);
138     (void)strcpy_s(addr.info.ip.ip, IP_STR_MAX_LEN, NODE1_IP);
139     addr.info.ip.port = NODE1_PORT;
140     EXPECT_TRUE(!LnnConvertAddrToOption(nullptr, nullptr));
141     EXPECT_TRUE(LnnConvertAddrToOption(&addr, &option));
142     addr.type = CONNECTION_ADDR_BLE;
143     EXPECT_TRUE(LnnConvertAddrToOption(&addr, &option));
144     addr.type = CONNECTION_ADDR_WLAN;
145     EXPECT_TRUE(LnnConvertAddrToOption(&addr, &option));
146     addr.type = CONNECTION_ADDR_ETH;
147     EXPECT_TRUE(LnnConvertAddrToOption(&addr, &option));
148     addr.type = CONNECTION_ADDR_MAX;
149     EXPECT_TRUE(!LnnConvertAddrToOption(&addr, &option));
150 }
151 
152 /*
153 * @tc.name: LNN_CONVERT_OPTION_TO_ADDR_Test_001
154 * @tc.desc: lnn convert option to addr test
155 * @tc.type: FUNC
156 * @tc.require:
157 */
158 HWTEST_F(LNNConnAddrUtilsTest, LNN_CONVERT_OPTION_TO_ADDR_Test_001, TestSize.Level1)
159 {
160     ConnectionAddr addr;
161     ConnectOption option;
162     (void)memset_s(&addr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
163     (void)memset_s(&option, sizeof(ConnectOption), 0, sizeof(ConnectOption));
164     option.type = CONNECT_BR;
165     (void)strcpy_s(option.brOption.brMac, BT_MAC_LEN, NODE1_BR_MAC);
166     (void)strcpy_s(option.bleOption.bleMac, BT_MAC_LEN, NODE1_BLE_MAC);
167     (void)strcpy_s(option.socketOption.addr, IP_STR_MAX_LEN, NODE1_IP);
168     option.socketOption.protocol = LNN_PROTOCOL_IP;
169     option.socketOption.port = NODE1_PORT;
170     EXPECT_TRUE(!LnnConvertOptionToAddr(nullptr, nullptr, CONNECTION_ADDR_BR));
171     EXPECT_TRUE(LnnConvertOptionToAddr(&addr, &option, CONNECTION_ADDR_BR));
172     option.type = CONNECT_BLE;
173     EXPECT_TRUE(LnnConvertOptionToAddr(&addr, &option, CONNECTION_ADDR_BR));
174     option.type = CONNECT_TCP;
175     EXPECT_TRUE(LnnConvertOptionToAddr(&addr, &option, CONNECTION_ADDR_BR));
176     option.socketOption.protocol = LNN_PROTOCOL_BLE;
177     EXPECT_TRUE(!LnnConvertOptionToAddr(&addr, &option, CONNECTION_ADDR_BR));
178     option.type = CONNECT_TYPE_MAX;
179     EXPECT_TRUE(!LnnConvertOptionToAddr(&addr, &option, CONNECTION_ADDR_BR));
180 }
181 
182 /*
183 * @tc.name: LNN_CONV_ADDR_TYPE_TO_DISC_TYPE_Test_001
184 * @tc.desc: lnn convert option to addr test
185 * @tc.type: FUNC
186 * @tc.require:
187 */
188 HWTEST_F(LNNConnAddrUtilsTest, LNN_CONV_ADDR_TYPE_TO_DISC_TYPE_Test_001, TestSize.Level1)
189 {
190     EXPECT_TRUE(LnnConvAddrTypeToDiscType(CONNECTION_ADDR_WLAN) == DISCOVERY_TYPE_WIFI);
191     EXPECT_TRUE(LnnConvAddrTypeToDiscType(CONNECTION_ADDR_ETH) == DISCOVERY_TYPE_WIFI);
192     EXPECT_TRUE(LnnConvAddrTypeToDiscType(CONNECTION_ADDR_BR) == DISCOVERY_TYPE_BR);
193     EXPECT_TRUE(LnnConvAddrTypeToDiscType(CONNECTION_ADDR_BLE) == DISCOVERY_TYPE_BLE);
194     EXPECT_TRUE(LnnConvAddrTypeToDiscType(CONNECTION_ADDR_SESSION) == DISCOVERY_TYPE_BLE);
195     EXPECT_TRUE(LnnConvAddrTypeToDiscType(CONNECTION_ADDR_MAX) == DISCOVERY_TYPE_COUNT);
196 }
197 
198 /*
199 * @tc.name: LNN_DISC_TYPE_TO_CONN_ADDR_TYPE_Test_001
200 * @tc.desc: lnn disc type to conn addr type test
201 * @tc.type: FUNC
202 * @tc.require:
203 */
204 HWTEST_F(LNNConnAddrUtilsTest, LNN_DISC_TYPE_TO_CONN_ADDR_TYPE_Test_001, TestSize.Level1)
205 {
206     EXPECT_TRUE(LnnDiscTypeToConnAddrType(DISCOVERY_TYPE_WIFI) == CONNECTION_ADDR_WLAN);
207     EXPECT_TRUE(LnnDiscTypeToConnAddrType(DISCOVERY_TYPE_BLE) == CONNECTION_ADDR_BLE);
208     EXPECT_TRUE(LnnDiscTypeToConnAddrType(DISCOVERY_TYPE_BR) == CONNECTION_ADDR_BR);
209     EXPECT_TRUE(LnnDiscTypeToConnAddrType(DISCOVERY_TYPE_COUNT) == CONNECTION_ADDR_MAX);
210 }
211 
212 /*
213 * @tc.name: LNN_CONVER_ADDR_TO_AUTH_CONN_INFO_Test_001
214 * @tc.desc: lnn conver addr to auth conn info test
215 * @tc.type: FUNC
216 * @tc.require:
217 */
218 HWTEST_F(LNNConnAddrUtilsTest, LNN_CONVER_ADDR_TO_AUTH_CONN_INFO_Test_001, TestSize.Level1)
219 {
220     ConnectionAddr addr;
221     AuthConnInfo connInfo;
222     (void)memset_s(&addr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
223     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
224     addr.type = CONNECTION_ADDR_BR;
225     (void)strcpy_s(addr.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
226     (void)strcpy_s(addr.info.ble.bleMac, BT_MAC_LEN, NODE1_BLE_MAC);
227     (void)memcpy_s(addr.info.ble.udidHash, UDID_HASH_LEN, NODE1_UDID_HASH, UDID_HASH_LEN);
228     (void)strcpy_s(addr.info.ip.ip, IP_STR_MAX_LEN, NODE1_IP);
229     addr.info.ip.port = NODE1_PORT;
230     EXPECT_TRUE(!LnnConvertAddrToAuthConnInfo(nullptr, nullptr));
231     EXPECT_TRUE(LnnConvertAddrToAuthConnInfo(&addr, &connInfo));
232     addr.type = CONNECTION_ADDR_BLE;
233     EXPECT_TRUE(LnnConvertAddrToAuthConnInfo(&addr, &connInfo));
234     addr.type = CONNECTION_ADDR_ETH;
235     EXPECT_TRUE(LnnConvertAddrToAuthConnInfo(&addr, &connInfo));
236     addr.type = CONNECTION_ADDR_WLAN;
237     EXPECT_TRUE(LnnConvertAddrToAuthConnInfo(&addr, &connInfo));
238     addr.type = CONNECTION_ADDR_MAX;
239     EXPECT_TRUE(!LnnConvertAddrToAuthConnInfo(&addr, &connInfo));
240 }
241 
242 /*
243 * @tc.name: LNN_CONVER_AUTH_CONN_INFO_TO_ADDR_Test_001
244 * @tc.desc: lnn conver addr to auth conn info test
245 * @tc.type: FUNC
246 * @tc.require:
247 */
248 HWTEST_F(LNNConnAddrUtilsTest, LNN_CONVER_AUTH_CONN_INFO_TO_ADDR_Test_001, TestSize.Level1)
249 {
250     ConnectionAddr addr;
251     AuthConnInfo connInfo;
252     (void)memset_s(&addr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
253     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
254     (void)strcpy_s(connInfo.info.brInfo.brMac, BT_MAC_LEN, NODE1_BR_MAC);
255     (void)strcpy_s(connInfo.info.bleInfo.bleMac, BT_MAC_LEN, NODE1_BLE_MAC);
256     (void)strcpy_s(connInfo.info.ipInfo.ip, IP_STR_MAX_LEN, NODE1_IP);
257     connInfo.info.ipInfo.port = NODE1_PORT;
258     EXPECT_TRUE(!LnnConvertAuthConnInfoToAddr(nullptr, nullptr, CONNECTION_ADDR_WLAN));
259     connInfo.type = AUTH_LINK_TYPE_BR;
260     EXPECT_TRUE(LnnConvertAuthConnInfoToAddr(&addr, &connInfo, CONNECTION_ADDR_WLAN));
261     connInfo.type = AUTH_LINK_TYPE_BLE;
262     EXPECT_TRUE(LnnConvertAuthConnInfoToAddr(&addr, &connInfo, CONNECTION_ADDR_WLAN));
263     connInfo.type = AUTH_LINK_TYPE_WIFI;
264     EXPECT_TRUE(LnnConvertAuthConnInfoToAddr(&addr, &connInfo, CONNECTION_ADDR_WLAN));
265     connInfo.type = AUTH_LINK_TYPE_P2P;
266     EXPECT_TRUE(!LnnConvertAuthConnInfoToAddr(&addr, &connInfo, CONNECTION_ADDR_WLAN));
267 }
268 } // namespace OHOS
269