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_mock.h"
21 #include "lnn_bt_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 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 {
57 }
58
TearDown()59 void LNNBtNetworkImplMockTest::TearDown()
60 {
61 }
62
63 /*
64 * @tc.name: LNN_BT_NETWORK_IMPL_TEST_001
65 * @tc.desc: len is not CONNECTION_ADDR_MAX return SOFTBUS_INVALID_PARAM
66 * @tc.type: FUNC
67 * @tc.require: I5OMIK
68 */
69 HWTEST_F(LNNBtNetworkImplMockTest, LNN_BT_NETWORK_IMPL_TEST_001, TestSize.Level1)
70 {
71 NiceMock<LnnBtNetworkImplInterfaceMock> btMock;
72 EXPECT_CALL(btMock, LnnRegisterEventHandler(_, _)).WillOnce(Return(SOFTBUS_ERR)).
73 WillRepeatedly(Return(SOFTBUS_OK));
74 int ret = LnnInitBtProtocol(nullptr);
75 EXPECT_TRUE(ret == SOFTBUS_ERR);
76 ret = LnnInitBtProtocol(nullptr);
77 EXPECT_TRUE(ret == SOFTBUS_OK);
78 }
79
80 /*
81 * @tc.name: LNN_BT_NETWORK_IMPL_TEST_002
82 * @tc.desc: relationNum is NULL return SOFTBUS_INVALID_PARAM
83 * @tc.type: FUNC
84 * @tc.require: I5OMIK
85 */
86 HWTEST_F(LNNBtNetworkImplMockTest, LNN_BT_NETWORK_IMPL_TEST_002, TestSize.Level1)
87 {
88 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
89 NiceMock<LnnBtNetworkImplInterfaceMock> btMock;
90 EXPECT_CALL(ledgerMock, LnnGetNetworkIdByBtMac).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
91 EXPECT_CALL(btMock, LnnRequestLeaveSpecific).WillOnce(Return(SOFTBUS_ERR)).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).WillRepeatedly(LnnBtNetworkImplInterfaceMock::
146 ActionOfLnnGetNetIfTypeByNameBr);
147 EXPECT_CALL(btMock, LnnRegistPhysicalSubnet).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
148 LnnProtocolManager self = {0};
149 LnnNetIfMgr netifMgr = {
150 .ifName = "name",
151 };
152 int ret = LnnEnableBtProtocol(&self, nullptr);
153 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
154 ret = LnnEnableBtProtocol(&self, &netifMgr);
155 EXPECT_TRUE(ret == SOFTBUS_ERR);
156 ret = LnnEnableBtProtocol(&self, &netifMgr);
157 EXPECT_TRUE(ret == SOFTBUS_OK);
158 }
159
160 /*
161 * @tc.name: LNN_BT_NETWORK_IMPL_TEST_005
162 * @tc.desc: *invalid parameter
163 * @tc.type: FUNC
164 * @tc.require: I5OMIK
165 */
166 HWTEST_F(LNNBtNetworkImplMockTest, LNN_BT_NETWORK_IMPL_TEST_005, TestSize.Level1)
167 {
168 NiceMock<LnnBtNetworkImplInterfaceMock> btMock;
169 EXPECT_CALL(btMock, LnnRequestLeaveByAddrType).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
170 LnnPhysicalSubnet *subnet = reinterpret_cast<LnnPhysicalSubnet *>(SoftBusMalloc(sizeof(LnnPhysicalSubnet)));
171 memset_s(subnet, sizeof(LnnPhysicalSubnet), 0, sizeof(LnnPhysicalSubnet));
172 subnet->status = LNN_SUBNET_IDLE;
173 DestroyBtSubnetManager(subnet);
174
175 LnnPhysicalSubnet *subnet1 = reinterpret_cast<LnnPhysicalSubnet *>(SoftBusMalloc(sizeof(LnnPhysicalSubnet)));
176 memset_s(subnet1, sizeof(LnnPhysicalSubnet), 0, sizeof(LnnPhysicalSubnet));
177 subnet1->status = LNN_SUBNET_RUNNING;
178 DestroyBtSubnetManager(subnet1);
179 }
180
181 /*
182 * @tc.name: LNN_BT_NETWORK_IMPL_TEST_006
183 * @tc.desc: *invalid parameter
184 * @tc.type: FUNC
185 * @tc.require: I5OMIK
186 */
187 HWTEST_F(LNNBtNetworkImplMockTest, LNN_BT_NETWORK_IMPL_TEST_006, TestSize.Level1)
188 {
189 NiceMock<LnnBtNetworkImplInterfaceMock> btMock;
190 LnnPhysicalSubnet subnet = {
191 .ifName = LNN_DEFAULT_IF_NAME_BR,
192 .status = LNN_SUBNET_RUNNING,
193 };
194 EXPECT_CALL(btMock, SoftBusGetBtState).WillRepeatedly(Return(BLE_DISABLE));
195 EXPECT_CALL(btMock, LnnRequestLeaveByAddrType).WillOnce(Return(SOFTBUS_OK)).WillRepeatedly(Return(SOFTBUS_ERR));
196 OnBtNetifStatusChanged(nullptr, nullptr);
197
198 EXPECT_CALL(btMock, LnnGetNetIfTypeByName).WillOnce(LnnBtNetworkImplInterfaceMock::
199 ActionOfLnnGetNetIfTypeByNameBr);
200 SoftBusBtState btState1 = SOFTBUS_BR_TURN_ON;
201 OnBtNetifStatusChanged(&subnet, (void *)(&btState1));
202
203 EXPECT_CALL(btMock, LnnGetNetIfTypeByName).WillOnce(LnnBtNetworkImplInterfaceMock::
204 ActionOfLnnGetNetIfTypeByNameBle);
205 OnBtNetifStatusChanged(&subnet, (void *)(&btState1));
206
207 EXPECT_CALL(btMock, LnnGetNetIfTypeByName).WillOnce(LnnBtNetworkImplInterfaceMock::
208 ActionOfLnnGetNetIfTypeByNameBr);
209 SoftBusBtState btState2 = SOFTBUS_BR_TURN_OFF;
210 OnBtNetifStatusChanged(&subnet, (void *)(&btState2));
211
212 EXPECT_CALL(btMock, LnnGetNetIfTypeByName).WillOnce(LnnBtNetworkImplInterfaceMock::
213 ActionOfLnnGetNetIfTypeByNameBle);
214 OnBtNetifStatusChanged(&subnet, (void *)(&btState2));
215 }
216
217 /*
218 * @tc.name: LNN_BT_NETWORK_IMPL_TEST_007
219 * @tc.desc: *invalid parameter
220 * @tc.type: FUNC
221 * @tc.require: I5OMIK
222 */
223 HWTEST_F(LNNBtNetworkImplMockTest, LNN_BT_NETWORK_IMPL_TEST_007, TestSize.Level1)
224 {
225 char macStr[] = "123456789";
226 NiceMock<LnnBtNetworkImplInterfaceMock> btMock;
227 EXPECT_CALL(btMock, SoftBusGetBtMacAddr).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
228 EXPECT_CALL(btMock, ConvertBtMacToStr).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
229
230 int ret = GetAvailableBtMac(macStr, NETWORK_ID_BUF_LEN);
231 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
232
233 ret = GetAvailableBtMac(macStr, BT_MAC_LEN);
234 EXPECT_TRUE(ret == SOFTBUS_ERR);
235
236 ret = GetAvailableBtMac(macStr, BT_MAC_LEN);
237 EXPECT_TRUE(ret == SOFTBUS_ERR);
238
239 ret = GetAvailableBtMac(macStr, BT_MAC_LEN);
240 EXPECT_TRUE(ret == SOFTBUS_OK);
241 }
242 } // namespace OHOS
243