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 #include <securec.h>
18
19 #include "softbus_error_code.h"
20 #include "softbus_adapter_mem.h"
21 #include "lnn_lane_query.c"
22 #include "lnn_lane_query.h"
23 #include "lnn_lane_query_deps_mock.h"
24 #include "lnn_lane.h"
25
26 using namespace testing::ext;
27 using namespace testing;
28
29 namespace OHOS {
30 constexpr char NODE_NETWORK_ID[] = "111122223333abcdef";
31 constexpr uint32_t LOW_BW = 500 * 1024;
32 constexpr uint32_t MID_BW = 1000 * 1024;
33 constexpr uint32_t HIGH_BW = 160 * 1024 * 1024;
34
35 class LNNLaneQueryTest : public testing::Test {
36 public:
LNNLaneQueryTest()37 LNNLaneQueryTest()
38 {
39 }
~LNNLaneQueryTest()40 ~LNNLaneQueryTest()
41 {
42 }
43 static void SetUpTestCase(void);
44 static void TearDownTestCase(void);
SetUp()45 void SetUp() override
46 {
47 }
TearDown()48 void TearDown() override
49 {
50 }
51 };
52
SetUpTestCase(void)53 void LNNLaneQueryTest::SetUpTestCase(void)
54 {
55 }
56
TearDownTestCase(void)57 void LNNLaneQueryTest::TearDownTestCase(void)
58 {
59 }
60
PrejudgeAvailability(const char * remoteNetworkId,enum WifiDirectLinkType connectType)61 static int32_t PrejudgeAvailability(const char *remoteNetworkId, enum WifiDirectLinkType connectType)
62 {
63 (void)remoteNetworkId;
64 (void)connectType;
65 GTEST_LOG_(INFO) << "PrejudgeAvailability Enter";
66 return SOFTBUS_OK;
67 }
68
PrejudgeAvailabilityForP2p(const char * remoteNetworkId,enum WifiDirectLinkType connectType)69 static int32_t PrejudgeAvailabilityForP2p(const char *remoteNetworkId, enum WifiDirectLinkType connectType)
70 {
71 (void)remoteNetworkId;
72 (void)connectType;
73 GTEST_LOG_(INFO) << "PrejudgeAvailabilityForP2p Enter";
74 return V1_ERROR_GC_CONNECTED_TO_ANOTHER_DEVICE;
75 }
76
PrejudgeAvailabilityForHml(const char * remoteNetworkId,enum WifiDirectLinkType connectType)77 static int32_t PrejudgeAvailabilityForHml(const char *remoteNetworkId, enum WifiDirectLinkType connectType)
78 {
79 (void)remoteNetworkId;
80 (void)connectType;
81 GTEST_LOG_(INFO) << "PrejudgeAvailabilityForHml Enter";
82 return ERROR_LOCAL_THREE_VAP_CONFLICT;
83 }
84
85 struct WifiDirectManager g_manager = {
86 .prejudgeAvailability = PrejudgeAvailability,
87 };
88
89 struct WifiDirectManager g_managerp2p = {
90 .prejudgeAvailability = PrejudgeAvailabilityForP2p,
91 };
92
93 struct WifiDirectManager g_managerhml = {
94 .prejudgeAvailability = PrejudgeAvailabilityForHml,
95 };
96
97 /*
98 * @tc.name: LNN_QUERY_LANE_001
99 * @tc.desc: QueryLane
100 * @tc.type: FUNC
101 * @tc.require:
102 */
103 HWTEST_F(LNNLaneQueryTest, LNN_LANE_QUERY_001, TestSize.Level1)
104 {
105 NiceMock<LaneQueryDepsInterfaceMock> linkQueryMock;
106 EXPECT_CALL(linkQueryMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
107 QosInfo qosInfo = {0};
108 int32_t ret = LnnQueryLaneResource(nullptr, &qosInfo);
109 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
110
111 LaneQueryInfo query;
112 memset_s(&query, sizeof(LaneQueryInfo), 0, sizeof(LaneQueryInfo));
113 query.transType = LANE_T_BYTE;
114 EXPECT_EQ(strncpy_s(query.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
115
116 ret = LnnQueryLaneResource(&query, &qosInfo);
117 EXPECT_NE(ret, SOFTBUS_OK);
118
119 ret = LnnQueryLaneResource(&query, nullptr);
120 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
121
122 ret = LnnQueryLaneResource(&query, &qosInfo);
123 EXPECT_NE(ret, SOFTBUS_OK);
124
125 ret = LnnQueryLaneResource(&query, &qosInfo);
126 EXPECT_NE(ret, SOFTBUS_OK);
127 }
128
129 /*
130 * @tc.name: LNN_QUERY_LANE_002
131 * @tc.desc: QueryLane
132 * @tc.type: FUNC
133 * @tc.require:
134 */
135 HWTEST_F(LNNLaneQueryTest, LNN_LANE_QUERY_002, TestSize.Level1)
136 {
137 NiceMock<LaneQueryDepsInterfaceMock> linkQueryMock;
138 EXPECT_CALL(linkQueryMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
139 QosInfo qosInfo = {0};
140 int32_t ret = QueryLaneResource(nullptr, &qosInfo);
141 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
142
143 LaneQueryInfo query;
144 query.transType = LANE_T_BYTE;
145 EXPECT_EQ(strncpy_s(query.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
146 ret = QueryLaneResource(&query, nullptr);
147 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
148
149 qosInfo.minBW = LOW_BW;
150 ret = QueryLaneResource(&query, &qosInfo);
151 EXPECT_NE(ret, SOFTBUS_OK);
152
153 qosInfo.minBW = MID_BW;
154 ret = QueryLaneResource(&query, &qosInfo);
155 EXPECT_NE(ret, SOFTBUS_OK);
156 }
157
158 /*
159 * @tc.name: LNN_QUERY_LANE_003
160 * @tc.desc: QueryLane
161 * @tc.type: FUNC
162 * @tc.require:
163 */
164 HWTEST_F(LNNLaneQueryTest, LNN_LANE_QUERY_003, TestSize.Level1)
165 {
166 NiceMock<LaneQueryDepsInterfaceMock> linkQueryMock;
167 EXPECT_CALL(linkQueryMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
168 QosInfo qosInfo = {0};
169 LaneQueryInfo query;
170 query.transType = LANE_T_MSG;
171 EXPECT_EQ(strncpy_s(query.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
172
173 qosInfo.minBW = LOW_BW;
174 int32_t ret = QueryLaneResource(&query, &qosInfo);
175 EXPECT_NE(ret, SOFTBUS_OK);
176
177 qosInfo.minBW = MID_BW;
178 ret = QueryLaneResource(&query, &qosInfo);
179 EXPECT_NE(ret, SOFTBUS_OK);
180 }
181
182 /*
183 * @tc.name: LNN_QUERY_LANE_004
184 * @tc.desc: QueryLane
185 * @tc.type: FUNC
186 * @tc.require:
187 */
188 HWTEST_F(LNNLaneQueryTest, LNN_LANE_QUERY_004, TestSize.Level1)
189 {
190 NiceMock<LaneQueryDepsInterfaceMock> linkQueryMock;
191 EXPECT_CALL(linkQueryMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
192 QosInfo qosInfo = {0};
193 LaneQueryInfo query;
194 query.transType = LANE_T_FILE;
195 EXPECT_EQ(strncpy_s(query.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
196
197 qosInfo.minBW = LOW_BW;
198 int32_t ret = QueryLaneResource(&query, &qosInfo);
199 EXPECT_NE(ret, SOFTBUS_OK);
200
201 qosInfo.minBW = MID_BW;
202 ret = QueryLaneResource(&query, &qosInfo);
203 EXPECT_NE(ret, SOFTBUS_OK);
204
205 qosInfo.minBW = HIGH_BW;
206 ret = QueryLaneResource(&query, &qosInfo);
207 EXPECT_NE(ret, SOFTBUS_OK);
208 }
209
210 /*
211 * @tc.name: LNN_QUERY_LANE_005
212 * @tc.desc: QueryLane
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216 HWTEST_F(LNNLaneQueryTest, LNN_LANE_QUERY_005, TestSize.Level1)
217 {
218 NiceMock<LaneQueryDepsInterfaceMock> linkQueryMock;
219 EXPECT_CALL(linkQueryMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
220 QosInfo qosInfo = {0};
221 LaneQueryInfo query;
222 query.transType = LANE_T_RAW_STREAM;
223 EXPECT_EQ(strncpy_s(query.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
224
225 qosInfo.minBW = MID_BW;
226 int32_t ret = QueryLaneResource(&query, &qosInfo);
227 EXPECT_NE(ret, SOFTBUS_OK);
228
229 query.transType = LANE_T_COMMON_VIDEO;
230 ret = QueryLaneResource(&query, &qosInfo);
231 EXPECT_NE(ret, SOFTBUS_OK);
232
233 query.transType = LANE_T_COMMON_VOICE;
234 ret = QueryLaneResource(&query, &qosInfo);
235 EXPECT_NE(ret, SOFTBUS_OK);
236 }
237
238 /*
239 * @tc.name: LNN_QUERY_LANE_006
240 * @tc.desc: QueryLane
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(LNNLaneQueryTest, LNN_QUERY_LANE_006, TestSize.Level1)
245 {
246 NiceMock<LaneQueryDepsInterfaceMock> linkQueryMock;
247 EXPECT_CALL(linkQueryMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
248 QosInfo qosInfo = {0};
249 LaneQueryInfo query;
250 query.transType = LANE_T_RAW_STREAM;
251 EXPECT_EQ(strncpy_s(query.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
252 qosInfo.minBW = 0;
253 int32_t ret = QueryLaneResource(&query, &qosInfo);
254 EXPECT_NE(ret, SOFTBUS_OK);
255 }
256
257 /*
258 * @tc.name: LNN_QUERY_LANE_007
259 * @tc.desc: QueryLane
260 * @tc.type: FUNC
261 * @tc.require:
262 */
263 HWTEST_F(LNNLaneQueryTest, LNN_QUERY_LANE_007, TestSize.Level1)
264 {
265 LaneLinkType linkList[LANE_LINK_TYPE_BUTT];
266 (void)memset_s(linkList, sizeof(linkList), -1, sizeof(linkList));
267 uint32_t listNum = 0;
268 GetFileLaneLink(linkList, &listNum, false);
269 GetMsgLaneLink(linkList, &listNum, false);
270 GetBytesLaneLink(linkList, &listNum, false);
271 LaneTransType transType = LANE_T_MIX;
272 int32_t ret = GetLaneResource(transType, linkList, &listNum, false);
273 EXPECT_NE(ret, SOFTBUS_OK);
274 }
275
276 /*
277 * @tc.name: LNN_QUERY_LANE_008
278 * @tc.desc: QueryLane
279 * @tc.type: FUNC
280 * @tc.require:
281 */
282 HWTEST_F(LNNLaneQueryTest, LNN_QUERY_LANE_008, TestSize.Level1)
283 {
284 NiceMock<LaneQueryDepsInterfaceMock> linkQueryMock;
285 EXPECT_CALL(linkQueryMock, LnnGetLocalNumU32Info)
286 .WillRepeatedly(Return(SOFTBUS_OK));
287 EXPECT_CALL(linkQueryMock, LnnGetRemoteNumU32Info)
288 .WillOnce(Return(SOFTBUS_NOT_FIND)).WillRepeatedly(Return(SOFTBUS_OK));
289 uint32_t local;
290 uint32_t remote;
291 bool ret = GetNetCap(NODE_NETWORK_ID, &local, &remote);
292 EXPECT_FALSE(ret);
293 ret = GetNetCap(NODE_NETWORK_ID, &local, &remote);
294 EXPECT_TRUE(ret);
295 }
296
297 /*
298 * @tc.name: LNN_QUERY_LANE_009
299 * @tc.desc: QueryLane
300 * @tc.type: FUNC
301 * @tc.require:
302 */
303 HWTEST_F(LNNLaneQueryTest, LNN_QUERY_LANE_009, TestSize.Level1)
304 {
305 NiceMock<LaneQueryDepsInterfaceMock> linkQueryMock;
306 EXPECT_CALL(linkQueryMock, LnnGetLocalNumU32Info)
307 .WillOnce(Return(SOFTBUS_NOT_FIND))
308 .WillOnce(DoAll(SetArgPointee<1>(BIT_BLE), Return(SOFTBUS_OK)))
309 .WillRepeatedly(DoAll(SetArgPointee<1>(1 << BIT_BR), Return(SOFTBUS_OK)));
310 EXPECT_CALL(linkQueryMock, LnnGetRemoteNumU32Info)
311 .WillOnce(DoAll(SetArgPointee<2>(1 << BIT_BR), Return(SOFTBUS_OK)))
312 .WillOnce(DoAll(SetArgPointee<2>(BIT_BLE), Return(SOFTBUS_OK)))
313 .WillRepeatedly(DoAll(SetArgPointee<2>(1 << BIT_BR), Return(SOFTBUS_OK)));
314 int32_t ret = BrLinkState(NODE_NETWORK_ID);
315 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
316 ret = BrLinkState(NODE_NETWORK_ID);
317 EXPECT_EQ(ret, SOFTBUS_BLUETOOTH_OFF);
318 ret = BrLinkState(NODE_NETWORK_ID);
319 EXPECT_EQ(ret, SOFTBUS_BLUETOOTH_OFF);
320 ret = BrLinkState(NODE_NETWORK_ID);
321 EXPECT_EQ(ret, SOFTBUS_OK);
322 }
323
324 /*
325 * @tc.name: LNN_QUERY_LANE_010
326 * @tc.desc: QueryLane
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330 HWTEST_F(LNNLaneQueryTest, LNN_QUERY_LANE_010, TestSize.Level1)
331 {
332 NiceMock<LaneQueryDepsInterfaceMock> linkQueryMock;
333 EXPECT_CALL(linkQueryMock, LnnGetLocalNumU32Info)
334 .WillOnce(Return(SOFTBUS_NOT_FIND))
335 .WillOnce(DoAll(SetArgPointee<1>(BIT_BLE), Return(SOFTBUS_OK)))
336 .WillRepeatedly(DoAll(SetArgPointee<1>(1 << BIT_BLE), Return(SOFTBUS_OK)));
337 EXPECT_CALL(linkQueryMock, LnnGetRemoteNumU32Info)
338 .WillOnce(DoAll(SetArgPointee<2>(1 << BIT_BLE), Return(SOFTBUS_OK)))
339 .WillOnce(DoAll(SetArgPointee<2>(BIT_BLE), Return(SOFTBUS_OK)))
340 .WillRepeatedly(DoAll(SetArgPointee<2>(1 << BIT_BLE), Return(SOFTBUS_OK)));
341 int32_t ret = BleLinkState(NODE_NETWORK_ID);
342 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
343 ret = BleLinkState(NODE_NETWORK_ID);
344 EXPECT_EQ(ret, SOFTBUS_BLUETOOTH_OFF);
345 ret = BleLinkState(NODE_NETWORK_ID);
346 EXPECT_EQ(ret, SOFTBUS_BLUETOOTH_OFF);
347 ret = BleLinkState(NODE_NETWORK_ID);
348 EXPECT_EQ(ret, SOFTBUS_OK);
349 }
350
351 /*
352 * @tc.name: LNN_QUERY_LANE_011
353 * @tc.desc: QueryLane
354 * @tc.type: FUNC
355 * @tc.require:
356 */
357 HWTEST_F(LNNLaneQueryTest, LNN_QUERY_LANE_011, TestSize.Level1)
358 {
359 NiceMock<LaneQueryDepsInterfaceMock> linkQueryMock;
360 EXPECT_CALL(linkQueryMock, SoftBusIsWifiActive)
361 .WillRepeatedly(Return(true));
362 EXPECT_CALL(linkQueryMock, LnnGetRemoteNodeInfoById)
363 .WillOnce(Return(SOFTBUS_NETWORK_GET_NODE_INFO_ERR))
364 .WillRepeatedly(Return(SOFTBUS_OK));
365 EXPECT_CALL(linkQueryMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
366 EXPECT_CALL(linkQueryMock, LnnGetLocalNumU32Info)
367 .WillOnce(Return(SOFTBUS_NOT_FIND))
368 .WillOnce(DoAll(SetArgPointee<1>(BIT_BR), Return(SOFTBUS_OK)))
369 .WillRepeatedly(DoAll(SetArgPointee<1>(1 << BIT_WIFI), Return(SOFTBUS_OK)));
370 EXPECT_CALL(linkQueryMock, LnnGetRemoteNumU32Info)
371 .WillOnce(DoAll(SetArgPointee<2>(1 << BIT_WIFI), Return(SOFTBUS_OK)))
372 .WillOnce(DoAll(SetArgPointee<2>(BIT_BR), Return(SOFTBUS_OK)))
373 .WillRepeatedly(DoAll(SetArgPointee<2>(1 << BIT_WIFI), Return(SOFTBUS_OK)));
374 int32_t ret = WlanLinkState(NODE_NETWORK_ID);
375 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
376 ret = WlanLinkState(NODE_NETWORK_ID);
377 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
378 ret = WlanLinkState(NODE_NETWORK_ID);
379 EXPECT_EQ(ret, SOFTBUS_WIFI_DISCONNECT);
380 ret = WlanLinkState(NODE_NETWORK_ID);
381 EXPECT_EQ(ret, SOFTBUS_WIFI_DISCONNECT);
382 EXPECT_CALL(linkQueryMock, LnnHasDiscoveryType)
383 .WillOnce(Return(false)).WillOnce(Return(false)).WillOnce(Return(true))
384 .WillOnce(Return(false)).WillOnce(Return(true)).WillRepeatedly(Return(true));
385 ret = WlanLinkState(NODE_NETWORK_ID);
386 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
387 ret = WlanLinkState(NODE_NETWORK_ID);
388 EXPECT_EQ(ret, SOFTBUS_OK);
389 ret = WlanLinkState(NODE_NETWORK_ID);
390 EXPECT_EQ(ret, SOFTBUS_OK);
391 ret = WlanLinkState(NODE_NETWORK_ID);
392 EXPECT_EQ(ret, SOFTBUS_OK);
393 }
394
395 /*
396 * @tc.name: LNN_QUERY_LANE_012
397 * @tc.desc: QueryLane
398 * @tc.type: FUNC
399 * @tc.require:
400 */
401 HWTEST_F(LNNLaneQueryTest, LNN_QUERY_LANE_012, TestSize.Level1)
402 {
403 NiceMock<LaneQueryDepsInterfaceMock> linkQueryMock;
404 EXPECT_CALL(linkQueryMock, GetWifiDirectManager)
405 .WillOnce(Return(nullptr))
406 .WillRepeatedly(Return(&g_manager));
407 EXPECT_CALL(linkQueryMock, SoftBusGetWifiState)
408 .WillOnce(Return(SOFTBUS_WIFI_STATE_INACTIVE))
409 .WillOnce(Return(SOFTBUS_WIFI_STATE_DEACTIVATING))
410 .WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVE));
411 EXPECT_CALL(linkQueryMock, LnnGetLocalNumU32Info)
412 .WillOnce(Return(SOFTBUS_NOT_FIND))
413 .WillOnce(DoAll(SetArgPointee<1>(BIT_BLE), Return(SOFTBUS_OK)))
414 .WillRepeatedly(DoAll(SetArgPointee<1>(1 << BIT_WIFI_P2P), Return(SOFTBUS_OK)));
415 EXPECT_CALL(linkQueryMock, LnnGetRemoteNumU32Info)
416 .WillOnce(DoAll(SetArgPointee<2>(1 << BIT_WIFI_P2P), Return(SOFTBUS_OK)))
417 .WillOnce(DoAll(SetArgPointee<2>(BIT_BLE), Return(SOFTBUS_OK)))
418 .WillRepeatedly(DoAll(SetArgPointee<2>(1 << BIT_WIFI_P2P), Return(SOFTBUS_OK)));
419 int32_t ret = P2pLinkState(NODE_NETWORK_ID);
420 EXPECT_EQ(ret, SOFTBUS_P2P_NOT_SUPPORT);
421 ret = P2pLinkState(NODE_NETWORK_ID);
422 EXPECT_EQ(ret, SOFTBUS_WIFI_OFF);
423 ret = P2pLinkState(NODE_NETWORK_ID);
424 EXPECT_EQ(ret, SOFTBUS_WIFI_OFF);
425 ret = P2pLinkState(NODE_NETWORK_ID);
426 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
427 ret = P2pLinkState(NODE_NETWORK_ID);
428 EXPECT_EQ(ret, SOFTBUS_P2P_NOT_SUPPORT);
429 ret = P2pLinkState(NODE_NETWORK_ID);
430 EXPECT_EQ(ret, SOFTBUS_P2P_NOT_SUPPORT);
431 EXPECT_CALL(linkQueryMock, GetWifiDirectManager)
432 .WillOnce(Return(&g_managerp2p))
433 .WillRepeatedly(Return(&g_manager));
434 ret = P2pLinkState(NODE_NETWORK_ID);
435 EXPECT_EQ(ret, SOFTBUS_P2P_ROLE_CONFLICT);
436 }
437
438 /*
439 * @tc.name: LNN_QUERY_LANE_013
440 * @tc.desc: QueryLane
441 * @tc.type: FUNC
442 * @tc.require:
443 */
444 HWTEST_F(LNNLaneQueryTest, LNN_QUERY_LANE_013, TestSize.Level1)
445 {
446 NiceMock<LaneQueryDepsInterfaceMock> linkQueryMock;
447 EXPECT_CALL(linkQueryMock, GetWifiDirectManager)
448 .WillOnce(Return(nullptr))
449 .WillRepeatedly(Return(&g_manager));
450 EXPECT_CALL(linkQueryMock, SoftBusGetWifiState)
451 .WillOnce(Return(SOFTBUS_WIFI_STATE_INACTIVE))
452 .WillOnce(Return(SOFTBUS_WIFI_STATE_DEACTIVATING))
453 .WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVE));
454 EXPECT_CALL(linkQueryMock, IsFeatureSupport)
455 .WillOnce(Return(false))
456 .WillRepeatedly(Return(true));
457 EXPECT_CALL(linkQueryMock, LnnGetRemoteBoolInfo)
458 .WillOnce(Return(SOFTBUS_NOT_FIND))
459 .WillRepeatedly(Return(SOFTBUS_OK));
460 EXPECT_CALL(linkQueryMock, LnnGetFeatureCapabilty)
461 .WillRepeatedly(Return(1));
462 int32_t ret = HmlLinkState(NODE_NETWORK_ID);
463 EXPECT_EQ(ret, SOFTBUS_HML_NOT_SUPPORT);
464 ret = HmlLinkState(NODE_NETWORK_ID);
465 EXPECT_EQ(ret, SOFTBUS_WIFI_OFF);
466 ret = HmlLinkState(NODE_NETWORK_ID);
467 EXPECT_EQ(ret, SOFTBUS_WIFI_OFF);
468 ret = HmlLinkState(NODE_NETWORK_ID);
469 EXPECT_EQ(ret, SOFTBUS_HML_NOT_SUPPORT);
470 ret = HmlLinkState(NODE_NETWORK_ID);
471 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
472 EXPECT_CALL(linkQueryMock, LnnGetRemoteBoolInfo)
473 .WillOnce(DoAll(SetArgPointee<2>(false), Return(SOFTBUS_OK)))
474 .WillRepeatedly(DoAll(SetArgPointee<2>(true), Return(SOFTBUS_OK)));
475 ret = HmlLinkState(NODE_NETWORK_ID);
476 EXPECT_EQ(ret, SOFTBUS_HML_NOT_SUPPORT);
477 EXPECT_CALL(linkQueryMock, GetWifiDirectManager)
478 .WillOnce(Return(&g_managerhml))
479 .WillRepeatedly(Return(&g_manager));
480 ret = HmlLinkState(NODE_NETWORK_ID);
481 EXPECT_EQ(ret, SOFTBUS_HML_THREE_VAP_CONFLIC);
482 }
483
484 /*
485 * @tc.name: LNN_QUERY_LANE_014
486 * @tc.desc: QueryLane
487 * @tc.type: FUNC
488 * @tc.require:
489 */
490 HWTEST_F(LNNLaneQueryTest, LNN_QUERY_LANE_014, TestSize.Level1)
491 {
492 QosInfo qosInfo = {0};
493 LaneQueryInfo query;
494 (void)memset_s(&query, sizeof(LaneQueryInfo), 0, sizeof(LaneQueryInfo));
495 query.transType = LANE_T_MIX;
496 EXPECT_EQ(strncpy_s(query.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
497 int32_t ret = QueryByRequireLink(&query, &qosInfo);
498 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
499 ret = QueryByDefaultLink(&query);
500 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
501 }
502
503 /*
504 * @tc.name: LNN_QUERY_LANE_015
505 * @tc.desc: QueryLane
506 * @tc.type: FUNC
507 * @tc.require:
508 */
509 HWTEST_F(LNNLaneQueryTest, LNN_QUERY_LANE_015, TestSize.Level1)
510 {
511 QosInfo qosInfo = {0};
512 int32_t ret = IsValidLaneLink(NODE_NETWORK_ID, LANE_LINK_TYPE_BUTT);
513 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
514 qosInfo.minBW = HIGH_BW;
515 bool isHighBand = false;
516 EXPECT_TRUE(isHighRequire(&qosInfo, &isHighBand));
517 }
518 }