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_bt_network_impl.c"
21 #include "lnn_bt_network_impl_mock.h"
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_error_code.h"
30
31 #define BLE_DISABLE 0
32 #define LNN_DEFAULT_IF_NAME_BR "br0"
33 namespace OHOS {
34 using namespace testing::ext;
35 using namespace testing;
36
37 class LNNBtNetworkImplMockTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp();
42 void TearDown();
43 };
44
SetUpTestCase()45 void LNNBtNetworkImplMockTest::SetUpTestCase()
46 {
47 LooperInit();
48 }
49
TearDownTestCase()50 void LNNBtNetworkImplMockTest::TearDownTestCase()
51 {
52 LooperDeinit();
53 }
54
SetUp()55 void LNNBtNetworkImplMockTest::SetUp() { }
56
TearDown()57 void LNNBtNetworkImplMockTest::TearDown() { }
58
59 /*
60 * @tc.name: LNN_BT_NETWORK_IMPL_TEST_001
61 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
62 * @tc.type: FUNC
63 * @tc.require: I5OMIK
64 */
65 HWTEST_F(LNNBtNetworkImplMockTest, LNN_BT_NETWORK_IMPL_TEST_001, TestSize.Level1)
66 {
67 NiceMock<LnnBtNetworkImplInterfaceMock> btMock;
68 EXPECT_CALL(btMock, LnnRegisterEventHandler(_, _))
69 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
70 .WillRepeatedly(Return(SOFTBUS_OK));
71 int32_t ret = LnnInitBtProtocol(nullptr);
72 EXPECT_NE(ret, SOFTBUS_OK);
73 ret = LnnInitBtProtocol(nullptr);
74 EXPECT_TRUE(ret == SOFTBUS_OK);
75 }
76
77 /*
78 * @tc.name: LNN_BT_NETWORK_IMPL_TEST_002
79 * @tc.desc: relationNum is nullptr return SOFTBUS_INVALID_PARAM
80 * @tc.type: FUNC
81 * @tc.require: I5OMIK
82 */
83 HWTEST_F(LNNBtNetworkImplMockTest, LNN_BT_NETWORK_IMPL_TEST_002, TestSize.Level1)
84 {
85 NiceMock<LnnBtNetworkImplInterfaceMock> btMock;
86 EXPECT_CALL(btMock, LnnGetNetworkIdByBtMac)
87 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
88 .WillRepeatedly(Return(SOFTBUS_OK));
89 EXPECT_CALL(btMock, LnnRequestLeaveSpecific)
90 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
91 .WillRepeatedly(Return(SOFTBUS_OK));
92 LnnMonitorBtAclStateChangedEvent btEvent1 = {
93 .basic.event = LNN_EVENT_BT_ACL_STATE_CHANGED,
94 .status = (uint8_t)SOFTBUS_BR_ACL_CONNECTED,
95 };
96 LnnMonitorBtAclStateChangedEvent btEvent2 = {
97 .basic.event = LNN_EVENT_BT_ACL_STATE_CHANGED,
98 .status = (uint8_t)SOFTBUS_BR_ACL_DISCONNECTED,
99 .btMac = "btmac",
100 };
101 BtAclStateChangedEvtHandler(nullptr);
102 BtAclStateChangedEvtHandler((LnnEventBasicInfo *)&btEvent1);
103 BtAclStateChangedEvtHandler((LnnEventBasicInfo *)&btEvent2);
104 BtAclStateChangedEvtHandler((LnnEventBasicInfo *)&btEvent2);
105 BtAclStateChangedEvtHandler((LnnEventBasicInfo *)&btEvent2);
106 }
107
108 /*
109 * @tc.name: LNN_BT_NETWORK_IMPL_TEST_003
110 * @tc.desc: *invalid parameter
111 * @tc.type: FUNC
112 * @tc.require: I5OMIK
113 */
114 HWTEST_F(LNNBtNetworkImplMockTest, LNN_BT_NETWORK_IMPL_TEST_003, TestSize.Level1)
115 {
116 NiceMock<LnnBtNetworkImplInterfaceMock> btMock;
117 EXPECT_CALL(btMock, LnnNotifyPhysicalSubnetStatusChanged).WillRepeatedly(Return());
118 LnnNetIfMgr netifManager1 = {
119 .type = LNN_NETIF_TYPE_BR,
120 };
121 const LnnNetIfMgr netifManager2 = {
122 .type = LNN_NETIF_TYPE_BLE,
123 };
124 const LnnNetIfMgr netifManager3 = {
125 .type = LNN_NETIF_TYPE_WLAN,
126 };
127 SoftBusBtState btState = SOFTBUS_BR_TURN_ON;
128 void *data = (void *)(&btState);
129 EXPECT_TRUE(NotifyBtStatusChanged(&netifManager1, data) == CHOICE_VISIT_NEXT);
130 btState = SOFTBUS_BLE_TURN_ON;
131 data = (void *)(&btState);
132 EXPECT_TRUE(NotifyBtStatusChanged(&netifManager2, data) == CHOICE_VISIT_NEXT);
133 EXPECT_TRUE(NotifyBtStatusChanged(&netifManager3, data) == CHOICE_VISIT_NEXT);
134 }
135
136 /*
137 * @tc.name: LNN_BT_NETWORK_IMPL_TEST_004
138 * @tc.desc: *invalid parameter
139 * @tc.type: FUNC
140 * @tc.require: I5OMIK
141 */
142 HWTEST_F(LNNBtNetworkImplMockTest, LNN_BT_NETWORK_IMPL_TEST_004, TestSize.Level1)
143 {
144 NiceMock<LnnBtNetworkImplInterfaceMock> btMock;
145 EXPECT_CALL(btMock, LnnGetNetIfTypeByName)
146 .WillRepeatedly(LnnBtNetworkImplInterfaceMock::ActionOfLnnGetNetIfTypeByNameBr);
147 EXPECT_CALL(btMock, LnnRegistPhysicalSubnet)
148 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
149 .WillRepeatedly(Return(SOFTBUS_OK));
150 LnnProtocolManager self = { 0 };
151 LnnNetIfMgr netifMgr = {
152 .ifName = "name",
153 };
154 int32_t ret = LnnEnableBtProtocol(&self, nullptr);
155 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
156 ret = LnnEnableBtProtocol(&self, &netifMgr);
157 EXPECT_NE(ret, SOFTBUS_OK);
158 ret = LnnEnableBtProtocol(&self, &netifMgr);
159 EXPECT_TRUE(ret == SOFTBUS_OK);
160 }
161
162 /*
163 * @tc.name: LNN_BT_NETWORK_IMPL_TEST_005
164 * @tc.desc: *invalid parameter
165 * @tc.type: FUNC
166 * @tc.require: I5OMIK
167 */
168 HWTEST_F(LNNBtNetworkImplMockTest, LNN_BT_NETWORK_IMPL_TEST_005, TestSize.Level1)
169 {
170 NiceMock<LnnBtNetworkImplInterfaceMock> btMock;
171 EXPECT_CALL(btMock, LnnRequestLeaveByAddrType)
172 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
173 .WillRepeatedly(Return(SOFTBUS_OK));
174 LnnPhysicalSubnet *subnet = reinterpret_cast<LnnPhysicalSubnet *>(SoftBusMalloc(sizeof(LnnPhysicalSubnet)));
175 memset_s(subnet, sizeof(LnnPhysicalSubnet), 0, sizeof(LnnPhysicalSubnet));
176 subnet->status = LNN_SUBNET_IDLE;
177 DestroyBtSubnetManager(subnet);
178
179 LnnPhysicalSubnet *subnet1 = reinterpret_cast<LnnPhysicalSubnet *>(SoftBusMalloc(sizeof(LnnPhysicalSubnet)));
180 memset_s(subnet1, sizeof(LnnPhysicalSubnet), 0, sizeof(LnnPhysicalSubnet));
181 subnet1->status = LNN_SUBNET_RUNNING;
182 DestroyBtSubnetManager(subnet1);
183 }
184
185 /*
186 * @tc.name: LNN_BT_NETWORK_IMPL_TEST_006
187 * @tc.desc: *invalid parameter
188 * @tc.type: FUNC
189 * @tc.require: I5OMIK
190 */
191 HWTEST_F(LNNBtNetworkImplMockTest, LNN_BT_NETWORK_IMPL_TEST_006, TestSize.Level1)
192 {
193 NiceMock<LnnBtNetworkImplInterfaceMock> btMock;
194 LnnPhysicalSubnet subnet = {
195 .ifName = LNN_DEFAULT_IF_NAME_BR,
196 .status = LNN_SUBNET_RUNNING,
197 };
198 EXPECT_CALL(btMock, SoftBusGetBtState).WillRepeatedly(Return(BLE_DISABLE));
199 EXPECT_CALL(btMock, LnnRequestLeaveByAddrType)
200 .WillOnce(Return(SOFTBUS_OK))
201 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
202 OnBtNetifStatusChanged(nullptr, nullptr);
203
204 EXPECT_CALL(btMock, LnnGetNetIfTypeByName)
205 .WillOnce(LnnBtNetworkImplInterfaceMock::ActionOfLnnGetNetIfTypeByNameBr);
206 SoftBusBtState btState1 = SOFTBUS_BR_TURN_ON;
207 OnBtNetifStatusChanged(&subnet, (void *)(&btState1));
208
209 EXPECT_CALL(btMock, LnnGetNetIfTypeByName)
210 .WillOnce(LnnBtNetworkImplInterfaceMock::ActionOfLnnGetNetIfTypeByNameBle);
211 OnBtNetifStatusChanged(&subnet, (void *)(&btState1));
212
213 EXPECT_CALL(btMock, LnnGetNetIfTypeByName)
214 .WillOnce(LnnBtNetworkImplInterfaceMock::ActionOfLnnGetNetIfTypeByNameBr);
215 SoftBusBtState btState2 = SOFTBUS_BR_TURN_OFF;
216 OnBtNetifStatusChanged(&subnet, (void *)(&btState2));
217
218 EXPECT_CALL(btMock, LnnGetNetIfTypeByName)
219 .WillOnce(LnnBtNetworkImplInterfaceMock::ActionOfLnnGetNetIfTypeByNameBle);
220 OnBtNetifStatusChanged(&subnet, (void *)(&btState2));
221 }
222
223 /*
224 * @tc.name: LNN_BT_NETWORK_IMPL_TEST_007
225 * @tc.desc: *invalid parameter
226 * @tc.type: FUNC
227 * @tc.require: I5OMIK
228 */
229 HWTEST_F(LNNBtNetworkImplMockTest, LNN_BT_NETWORK_IMPL_TEST_007, TestSize.Level1)
230 {
231 char macStr[] = "123456789";
232 NiceMock<LnnBtNetworkImplInterfaceMock> btMock;
233 EXPECT_CALL(btMock, SoftBusGetBtMacAddr)
234 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
235 .WillRepeatedly(Return(SOFTBUS_OK));
236 EXPECT_CALL(btMock, ConvertBtMacToStr).WillOnce(Return(SOFTBUS_INVALID_PARAM)).WillRepeatedly(Return(SOFTBUS_OK));
237
238 int32_t ret = GetAvailableBtMac(macStr, NETWORK_ID_BUF_LEN);
239 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
240
241 ret = GetAvailableBtMac(macStr, BT_MAC_LEN);
242 EXPECT_NE(ret, SOFTBUS_OK);
243
244 ret = GetAvailableBtMac(macStr, BT_MAC_LEN);
245 EXPECT_NE(ret, SOFTBUS_OK);
246
247 ret = GetAvailableBtMac(macStr, BT_MAC_LEN);
248 EXPECT_TRUE(ret == SOFTBUS_OK);
249 }
250 } // namespace OHOS
251