1 /*
2 * Copyright (c) 2022-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 #include <securec.h>
18
19 #include "lnn_service_mock.h"
20 #include "softbus_adapter_mem.h"
21 #include "softbus_common.h"
22 #include "softbus_errcode.h"
23 #include "lnn_sync_item_info.h"
24 #include "lnn_sync_item_info.c"
25 #include "lnn_net_ledger_mock.h"
26 #include "lnn_sync_info_mock.h"
27 #include "lnn_net_builder_mock.h"
28
29 #define TEST_VALID_PEER_NETWORKID "12345678"
30 #define TEST_VALID_PEER_NETWORKID1 "123456"
31 #define TEST_VALID_PEER_NETWORKID2 "1234"
32 #define TEST_VALID_UDID_LEN 32
33 #define TEST_TARGET_BSSID "targetBssid"
34 #define TEST_SSID "ssid"
35 #define TEST_PRE_SHARED_KEY "preSharedKey"
36 #define TEST_INT_VALUE 1
37 #define INVALID_WIFI_MAX_CONFIG_SIZE 11
38 namespace OHOS {
39 using namespace testing;
40 using namespace testing::ext;
41
42 class LNNSyncInfoItemTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp();
47 void TearDown();
48 };
49
SetUpTestCase()50 void LNNSyncInfoItemTest::SetUpTestCase()
51 {
52 }
53
TearDownTestCase()54 void LNNSyncInfoItemTest::TearDownTestCase()
55 {
56 }
57
SetUp()58 void LNNSyncInfoItemTest::SetUp()
59 {
60 }
61
TearDown()62 void LNNSyncInfoItemTest::TearDown()
63 {
64 }
65
66 /*
67 * @tc.name: WIFI_CONNECT_TO_TARGET_AP_TEST_001
68 * @tc.desc: test WifiConnectToTargetAp
69 * @tc.type: FUNC
70 * @tc.require:
71 */
72 HWTEST_F(LNNSyncInfoItemTest, WIFI_CONNECT_TO_TARGET_AP_TEST_001, TestSize.Level1)
73 {
74 SoftBusWifiDevConf *result1 = static_cast<SoftBusWifiDevConf *>(SoftBusCalloc(sizeof(SoftBusWifiDevConf)));
75 EXPECT_TRUE(result1 != nullptr);
76 EXPECT_EQ(EOK, strcpy_s(result1->ssid, WIFI_MAX_SSID_LEN, TEST_SSID));
77 SoftBusWifiDevConf *result2 = static_cast<SoftBusWifiDevConf *>(SoftBusCalloc(sizeof(SoftBusWifiDevConf)));
78 EXPECT_TRUE(result2 != nullptr);
79 EXPECT_EQ(EOK, strcpy_s(result2->ssid, WIFI_MAX_SSID_LEN, TEST_SSID));
80 SoftBusWifiDevConf *result3 = static_cast<SoftBusWifiDevConf *>(SoftBusCalloc(sizeof(SoftBusWifiDevConf)));
81 EXPECT_TRUE(result3 != nullptr);
82 EXPECT_EQ(EOK, strcpy_s(result3->ssid, WIFI_MAX_SSID_LEN, TEST_SSID));
83 SoftBusWifiDevConf *result4 = static_cast<SoftBusWifiDevConf *>(SoftBusCalloc(sizeof(SoftBusWifiDevConf)));
84 EXPECT_TRUE(result4 != nullptr);
85 EXPECT_EQ(EOK, strcpy_s(result4->ssid, WIFI_MAX_SSID_LEN, TEST_SSID));
86 SoftBusWifiDevConf *result5 = static_cast<SoftBusWifiDevConf *>(SoftBusCalloc(sizeof(SoftBusWifiDevConf)));
87 EXPECT_TRUE(result5 != nullptr);
88 EXPECT_EQ(EOK, strcpy_s(result5->ssid, WIFI_MAX_SSID_LEN, TEST_SSID));
89 NiceMock<LnnServicetInterfaceMock> LnnServiceMock;
90 EXPECT_CALL(LnnServiceMock, SoftBusGetWifiDeviceConfig)
91 .WillOnce(DoAll(SetArgPointee<0>(*result1), SetArgPointee<1>(INVALID_WIFI_MAX_CONFIG_SIZE),
92 Return(SOFTBUS_ERR)))
93 .WillOnce(DoAll(SetArgPointee<0>(*result2), SetArgPointee<1>(INVALID_WIFI_MAX_CONFIG_SIZE),
94 Return(SOFTBUS_OK)))
95 .WillOnce(DoAll(SetArgPointee<0>(*result3), SetArgPointee<1>(WIFI_MAX_CONFIG_SIZE),
96 Return(SOFTBUS_OK)))
97 .WillOnce(DoAll(SetArgPointee<0>(*result4), SetArgPointee<1>(WIFI_MAX_CONFIG_SIZE),
98 Return(SOFTBUS_OK)))
99 .WillOnce(DoAll(SetArgPointee<0>(*result5), SetArgPointee<1>(WIFI_MAX_CONFIG_SIZE),
100 Return(SOFTBUS_OK)));
101 const unsigned char targetBssid[] = "123456";
102 int32_t ret = WifiConnectToTargetAp(targetBssid, TEST_VALID_PEER_NETWORKID1);
103 EXPECT_EQ(ret, SOFTBUS_ERR);
104 ret = WifiConnectToTargetAp(targetBssid, TEST_VALID_PEER_NETWORKID1);
105 EXPECT_EQ(ret, SOFTBUS_ERR);
106 EXPECT_CALL(LnnServiceMock, SoftBusDisconnectDevice).WillOnce(Return(SOFTBUS_ERR))
107 .WillRepeatedly(Return(SOFTBUS_OK));
108 EXPECT_CALL(LnnServiceMock, SoftBusConnectToDevice).WillOnce(Return(SOFTBUS_ERR))
109 .WillRepeatedly(Return(SOFTBUS_OK));
110 ret = WifiConnectToTargetAp(targetBssid, TEST_VALID_PEER_NETWORKID1);
111 EXPECT_EQ(ret, SOFTBUS_ERR);
112 ret = WifiConnectToTargetAp(targetBssid, TEST_VALID_PEER_NETWORKID1);
113 EXPECT_EQ(ret, SOFTBUS_ERR);
114 ret = WifiConnectToTargetAp(targetBssid, TEST_VALID_PEER_NETWORKID1);
115 EXPECT_EQ(ret, SOFTBUS_OK);
116 }
117
118 /*
119 * @tc.name: LNN_SEND_TRANS_REQ_TEST_001
120 * @tc.desc: test LnnSendTransReq
121 * @tc.type: FUNC
122 * @tc.require:I5PRUD
123 */
124 HWTEST_F(LNNSyncInfoItemTest, LNN_SEND_TRANS_REQ_TEST_001, TestSize.Level1)
125 {
126 NiceMock<LnnNetLedgertInterfaceMock> LedgerMock;
127 EXPECT_CALL(LedgerMock, LnnSetDLBssTransInfo).WillOnce(Return(SOFTBUS_ERR))
128 .WillRepeatedly(Return(SOFTBUS_OK));
129 NiceMock<LnnSyncInfoInterfaceMock> SyncInfoMock;
130 EXPECT_CALL(SyncInfoMock, LnnSendSyncInfoMsg).WillOnce(Return(SOFTBUS_ERR))
131 .WillRepeatedly(Return(SOFTBUS_OK));
132 BssTransInfo transInfo;
133 (void)memset_s(&transInfo, sizeof(BssTransInfo), 0, sizeof(BssTransInfo));
134 EXPECT_EQ(EOK, strcpy_s(transInfo.ssid, WIFI_SSID_LEN, TEST_VALID_PEER_NETWORKID1));
135 EXPECT_EQ(EOK, strcpy_s((char *)transInfo.targetBssid, WIFI_MAC_LEN, TEST_VALID_PEER_NETWORKID2));
136 int32_t ret = LnnSendTransReq(TEST_VALID_PEER_NETWORKID, &transInfo);
137 EXPECT_EQ(ret, SOFTBUS_ERR);
138 ret = LnnSendTransReq(TEST_VALID_PEER_NETWORKID, &transInfo);
139 EXPECT_EQ(ret, SOFTBUS_ERR);
140 ret = LnnSendTransReq(TEST_VALID_PEER_NETWORKID, &transInfo);
141 EXPECT_EQ(ret, SOFTBUS_OK);
142 ret = LnnSendTransReq(nullptr, &transInfo);
143 EXPECT_EQ(ret, SOFTBUS_ERR);
144 ret = LnnSendTransReq(TEST_VALID_PEER_NETWORKID, nullptr);
145 EXPECT_EQ(ret, SOFTBUS_ERR);
146 }
147
148 /*
149 * @tc.name: LNN_ONRECEIVE_DEVICE_NAME_TEST_001
150 * @tc.desc: test OnReceiveDeviceName
151 * @tc.type: FUNC
152 * @tc.require:
153 */
154 HWTEST_F(LNNSyncInfoItemTest, LNN_ONRECEIVE_DEVICE_NAME_TEST_001, TestSize.Level1)
155 {
156 NiceMock<LnnNetLedgertInterfaceMock> LedgerMock;
157 NiceMock<LnnSyncInfoInterfaceMock> SyncInfoMock;
158 EXPECT_CALL(LedgerMock, LnnConvertDlId).WillRepeatedly(Return(SOFTBUS_ERR));
159 EXPECT_CALL(SyncInfoMock, LnnRegSyncInfoHandler).WillRepeatedly(Return(SOFTBUS_OK));
160 OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, nullptr, nullptr, TEST_VALID_UDID_LEN);
161 uint8_t msg[WIFI_SSID_LEN] = {1, 2, 3, 4, 5};
162 OnReceiveDeviceName(LNN_INFO_TYPE_BATTERY_INFO, nullptr, msg, TEST_VALID_UDID_LEN);
163 OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, nullptr, msg, TEST_VALID_UDID_LEN);
164 int32_t ret = LnnInitOffline();
165 EXPECT_EQ(ret, SOFTBUS_OK);
166 }
167
168 /*
169 * @tc.name: LNN_ONRECEIVE_TRANS_REQ_MSG_TEST_001
170 * @tc.desc: test OnReceiveTransReqMsg
171 * @tc.type: FUNC
172 * @tc.require:
173 */
174 HWTEST_F(LNNSyncInfoItemTest, LNN_ONRECEIVE_TRANS_REQ_MSG_TEST_001, TestSize.Level1)
175 {
176 NiceMock<LnnNetLedgertInterfaceMock> LedgerMock;
177 NiceMock<LnnSyncInfoInterfaceMock> SyncInfoMock;
178 EXPECT_CALL(LedgerMock, LnnConvertDlId).WillOnce(Return(SOFTBUS_ERR))
179 .WillRepeatedly(Return(SOFTBUS_OK));
180 EXPECT_CALL(LedgerMock, LnnSetDLDeviceInfoName).WillOnce(Return(SOFTBUS_ERR))
181 .WillRepeatedly(Return(SOFTBUS_OK));
182 EXPECT_CALL(SyncInfoMock, LnnRegSyncInfoHandler).WillRepeatedly(Return(SOFTBUS_ERR));
183 OnReceiveTransReqMsg(LNN_INFO_TYPE_TOPO_UPDATE, nullptr, nullptr, TEST_VALID_UDID_LEN);
184 OnReceiveTransReqMsg(LNN_INFO_TYPE_BSS_TRANS, nullptr, nullptr, TEST_VALID_UDID_LEN);
185 OnReceiveTransReqMsg(LNN_INFO_TYPE_BSS_TRANS, nullptr, nullptr, TEST_VALID_UDID_LEN);
186 OnReceiveTransReqMsg(LNN_INFO_TYPE_BSS_TRANS, nullptr, nullptr, TEST_VALID_UDID_LEN);
187 int32_t ret = LnnInitOffline();
188 EXPECT_EQ(ret, SOFTBUS_ERR);
189 }
190
191 /*
192 * @tc.name: LNN_ONRECEIVE_BR_OFFLINE_TEST_001
193 * @tc.desc: test OnReceiveBrOffline
194 * @tc.type: FUNC
195 * @tc.require:
196 */
197 HWTEST_F(LNNSyncInfoItemTest, LNN_ONRECEIVE_BR_OFFLINE_TEST_001, TestSize.Level1)
198 {
199 NiceMock<LnnNetLedgertInterfaceMock> LedgerMock;
200 EXPECT_CALL(LedgerMock, LnnConvertDlId).WillOnce(Return(SOFTBUS_ERR))
201 .WillRepeatedly(Return(SOFTBUS_OK));
202 EXPECT_CALL(LedgerMock, LnnGetCnnCode).WillOnce(Return(INVALID_CONNECTION_CODE_VALUE))
203 .WillRepeatedly(Return(SOFTBUS_OK));
204 uint32_t len = sizeof(int32_t);
205 uint32_t tmpMsg;
206 const uint8_t *msg = reinterpret_cast<const uint8_t *>(&tmpMsg);
207 OnReceiveBrOffline(LNN_INFO_TYPE_P2P_INFO, nullptr, nullptr, len);
208 OnReceiveBrOffline(LNN_INFO_TYPE_OFFLINE, nullptr, nullptr, len);
209 OnReceiveBrOffline(LNN_INFO_TYPE_OFFLINE, nullptr, msg, len + 1);
210 OnReceiveBrOffline(LNN_INFO_TYPE_OFFLINE, nullptr, msg, len);
211 OnReceiveBrOffline(LNN_INFO_TYPE_OFFLINE, nullptr, msg, len);
212 OnReceiveBrOffline(LNN_INFO_TYPE_OFFLINE, nullptr, msg, len);
213 }
214
215 /*
216 * @tc.name: FILL_TARGET_WIFI_CONFIG_TEST_001
217 * @tc.desc: test FillTargetWifiConfig
218 * @tc.type: FUNC
219 * @tc.require:I5PRUD
220 */
221 HWTEST_F(LNNSyncInfoItemTest, FILL_TARGET_WIFI_CONFIG_TEST_001, TestSize.Level1)
222 {
223 SoftBusWifiDevConf conWifiConf = { .securityType = TEST_INT_VALUE, .isHiddenSsid = TEST_INT_VALUE, };
224 EXPECT_EQ(EOK, strcpy_s(conWifiConf.preSharedKey, WIFI_MAX_KEY_LEN, TEST_PRE_SHARED_KEY));
225 SoftBusWifiDevConf targetWifiConf;
226 (void)memset_s(&targetWifiConf, sizeof(SoftBusWifiDevConf), 0, sizeof(SoftBusWifiDevConf));
227 const unsigned char *targetBssid = reinterpret_cast<const unsigned char *>(const_cast<char *>(TEST_PRE_SHARED_KEY));
228 int32_t ret = FillTargetWifiConfig(targetBssid, TEST_SSID, &conWifiConf, &targetWifiConf);
229 EXPECT_EQ(ret, SOFTBUS_OK);
230 }
231 } // namespace OHOS
232
233