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 "bus_center_manager.h"
21 #include "cJSON.h"
22 #include "common_list.h"
23 #include "lnn_net_builder.h"
24 #include "lnn_net_ledger_mock.h"
25 #include "lnn_node_info.h"
26 #include "lnn_p2p_info.h"
27 #include "lnn_service_mock.h"
28 #include "lnn_sync_info_manager.h"
29 #include "lnn_trans_mock.h"
30 #include "softbus_adapter_mem.h"
31 #include "softbus_adapter_thread.h"
32 #include "softbus_common.h"
33 #include "softbus_errcode.h"
34 #include "message_handler.h"
35 #include "softbus_json_utils.h"
36 #include "softbus_log.h"
37
38 #define JSON_KEY_P2P_ROLE "P2P_ROLE"
39 #define JSON_KEY_P2P_MAC "P2P_MAC"
40 #define JSON_KEY_GO_MAC "GO_MAC"
41
42 namespace OHOS {
43 using namespace testing::ext;
44 using namespace testing;
45
46 constexpr int32_t CHANNELID = 0;
47 constexpr int32_t CHANNELID1 = 1;
48 constexpr int32_t CHANNELID2 = 2;
49 constexpr uint32_t LEN = 65;
50 constexpr char UUID[65] = "abc";
51
GetP2pInfoMsgTest(const P2pInfo * info)52 static char *GetP2pInfoMsgTest(const P2pInfo *info)
53 {
54 cJSON *json = cJSON_CreateObject();
55 if (json == NULL) {
56 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "create p2p info json fail.");
57 return NULL;
58 }
59 if (!AddNumberToJsonObject(json, JSON_KEY_P2P_ROLE, info->p2pRole)) {
60 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "add p2p role fail.");
61 cJSON_Delete(json);
62 return NULL;
63 }
64 if (!AddStringToJsonObject(json, JSON_KEY_P2P_MAC, info->p2pMac)) {
65 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "add p2p mac fail.");
66 cJSON_Delete(json);
67 return NULL;
68 }
69 if (!AddStringToJsonObject(json, JSON_KEY_GO_MAC, info->goMac)) {
70 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "add go mac fail.");
71 cJSON_Delete(json);
72 return NULL;
73 }
74 char *msg = cJSON_PrintUnformatted(json);
75 if (msg == NULL) {
76 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "unformat p2p info fail");
77 }
78 cJSON_Delete(json);
79 return msg;
80 }
81
82 class LnnP2pInfoTest : public testing::Test {
83 public:
84 static void SetUpTestCase();
85 static void TearDownTestCase();
86 void SetUp();
87 void TearDown();
88 };
89
SetUpTestCase()90 void LnnP2pInfoTest::SetUpTestCase()
91 {
92 LooperInit();
93 NiceMock<LnnTransInterfaceMock> transMock;
94 EXPECT_CALL(transMock, TransRegisterNetworkingChannelListener).WillRepeatedly(
95 DoAll(LnnTransInterfaceMock::ActionOfTransRegister, Return(SOFTBUS_OK)));
96 LnnInitSyncInfoManager();
97 LnnInitP2p();
98 }
99
TearDownTestCase()100 void LnnP2pInfoTest::TearDownTestCase()
101 {
102 LooperDeinit();
103 LnnDeinitSyncInfoManager();
104 LnnDeinitP2p();
105 }
106
SetUp()107 void LnnP2pInfoTest::SetUp()
108 {
109 }
110
TearDown()111 void LnnP2pInfoTest::TearDown()
112 {
113 }
114
115 /*
116 * @tc.name: P2P_INFO_MOCK_TEST_001
117 * @tc.desc: test LnnInitLocalP2pInfo
118 * @tc.type: FUNC
119 * @tc.require:
120 */
121 HWTEST_F(LnnP2pInfoTest, P2P_INFO_MOCK_TEST_001, TestSize.Level1)
122 {
123 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
124 ON_CALL(netLedgerMock, LnnSetP2pRole).WillByDefault(Return(SOFTBUS_OK));
125 ON_CALL(netLedgerMock, LnnSetP2pMac).WillByDefault(Return(SOFTBUS_OK));
126 ON_CALL(netLedgerMock, LnnSetP2pGoMac).WillByDefault(Return(SOFTBUS_OK));
127 NodeInfo info;
128 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
129
130 int32_t ret = LnnInitLocalP2pInfo(&info);
131 EXPECT_TRUE(ret == SOFTBUS_OK);
132
133 EXPECT_CALL(netLedgerMock, LnnSetP2pRole(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
134 ret = LnnInitLocalP2pInfo(&info);
135 EXPECT_TRUE(ret != SOFTBUS_OK);
136
137 EXPECT_CALL(netLedgerMock, LnnSetP2pMac(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
138 ret = LnnInitLocalP2pInfo(&info);
139 EXPECT_TRUE(ret != SOFTBUS_OK);
140
141 EXPECT_CALL(netLedgerMock, LnnSetP2pGoMac(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
142 ret = LnnInitLocalP2pInfo(&info);
143 EXPECT_TRUE(ret != SOFTBUS_OK);
144 }
145
146 /*
147 * @tc.name: P2P_INFO_MOCK_TEST_002
148 * @tc.desc: test LnnSyncP2pInfo
149 * @tc.type: FUNC
150 * @tc.require:
151 */
152 HWTEST_F(LnnP2pInfoTest, P2P_INFO_MOCK_TEST_002, TestSize.Level1)
153 {
154 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
155 NiceMock<LnnTransInterfaceMock> transMock;
156 NodeInfo info = {
157 .p2pInfo.p2pRole = 1,
158 .p2pInfo.p2pMac = "abc",
159 .p2pInfo.goMac = "abc",
160 };
161 ON_CALL(netLedgerMock, LnnGetAllOnlineAndMetaNodeInfo).WillByDefault(
162 LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnline);
163 ON_CALL(netLedgerMock, LnnGetLocalNodeInfo).WillByDefault(Return(&info));
164 ON_CALL(transMock, TransOpenNetWorkingChannel).WillByDefault(Return(CHANNELID));
165 ON_CALL(transMock, TransSendNetworkingMessage).WillByDefault(Return(SOFTBUS_OK));
166 int32_t ret = LnnSyncP2pInfo();
167 SoftBusSleepMs(50);
168 EXPECT_TRUE(ret == SOFTBUS_OK);
169 ON_CALL(netLedgerMock, LnnConvertDlId).WillByDefault(LnnNetLedgertInterfaceMock::
170 ActionOfLnnConvertDlId);
171 int ret1 = LnnTransInterfaceMock::g_networkListener->onChannelOpened(CHANNELID, UUID, false);
172 EXPECT_TRUE(ret1 == SOFTBUS_OK);
173
174 P2pInfo p2pInfo = {
175 .p2pRole = 1,
176 .p2pMac = "abcd",
177 .goMac = "abcd",
178 };
179 char *p2pMsg = GetP2pInfoMsgTest(&p2pInfo);
180 EXPECT_TRUE(p2pMsg != NULL);
181 char msg[65] = {0};
182 *(int32_t *)msg = 6;
183 if (memcpy_s(msg + sizeof(int32_t), LEN - sizeof(int32_t), p2pMsg, strlen(p2pMsg) + 1) != EOK) {
184 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "copy sync info msg for type:");
185 }
186 cJSON_free(p2pMsg);
187 LnnTransInterfaceMock::g_networkListener->onChannelOpenFailed(CHANNELID, UUID);
188 LnnTransInterfaceMock::g_networkListener->onChannelClosed(CHANNELID);
189 LnnTransInterfaceMock::g_networkListener->onChannelOpened(CHANNELID2, UUID, true);
190 LnnTransInterfaceMock::g_networkListener->onMessageReceived(CHANNELID2, msg, LEN);
191 }
192
193 /*
194 * @tc.name: P2P_INFO_MOCK_TEST_003
195 * @tc.desc: test LnnSyncP2pInfo
196 * @tc.type: FUNC
197 * @tc.require:
198 */
199 HWTEST_F(LnnP2pInfoTest, P2P_INFO_MOCK_TEST_003, TestSize.Level1)
200 {
201 NiceMock<LnnNetLedgertInterfaceMock> netLedgerMock;
202 NiceMock<LnnTransInterfaceMock> transMock;
203 NodeInfo info = {
204 .p2pInfo.p2pRole = 1,
205 .p2pInfo.p2pMac = "abc",
206 .p2pInfo.goMac = "abc",
207 };
208 ON_CALL(netLedgerMock, LnnGetLocalNodeInfo).WillByDefault(Return(&info));
209 ON_CALL(transMock, TransOpenNetWorkingChannel).WillByDefault(Return(CHANNELID));
210 ON_CALL(transMock, TransSendNetworkingMessage).WillByDefault(Return(SOFTBUS_OK));
211
212 EXPECT_CALL(netLedgerMock, LnnGetAllOnlineAndMetaNodeInfo).WillOnce(
213 Return(SOFTBUS_OK)).WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnline);
214 int32_t ret = LnnSyncP2pInfo();
215 SoftBusSleepMs(2);
216 EXPECT_TRUE(ret == SOFTBUS_OK);
217
218 EXPECT_CALL(netLedgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr))
219 .WillRepeatedly(Return(&info));
220 ret = LnnSyncP2pInfo();
221 SoftBusSleepMs(50);
222 EXPECT_TRUE(ret == SOFTBUS_OK);
223
224 EXPECT_CALL(transMock, TransOpenNetWorkingChannel).WillOnce(Return(CHANNELID1))
225 .WillRepeatedly(Return(CHANNELID));
226 ret = LnnSyncP2pInfo();
227 SoftBusSleepMs(50);
228 EXPECT_TRUE(ret == SOFTBUS_OK);
229 }
230 } // namespace OHOS