1 /*
2 * Copyright (c) 2025 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
18 #include "lnn_sle_capability.h"
19 #include "lnn_sle_capability_mock.h"
20 #include "lnn_sle_capability.c"
21 #include "cJSON.h"
22 #include "softbus_json_utils.h"
23 #include "lnn_sync_info_manager_struct.h"
24
25 namespace OHOS {
26 using namespace testing::ext;
27 constexpr char NETWORK_ID[] = "235689BNHFCF";
28 constexpr char MSG[] = "testmsg";
29 constexpr char EMPTYMSG[] = "";
30
31 using namespace testing;
32 class LNNSleCapabilityTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase()40 void LNNSleCapabilityTest::SetUpTestCase() { }
41
TearDownTestCase()42 void LNNSleCapabilityTest::TearDownTestCase() { }
43
SetUp()44 void LNNSleCapabilityTest::SetUp()
45 {
46 LNN_LOGI(LNN_TEST, "LNNSleCapabilityTest start");
47 }
48
TearDown()49 void LNNSleCapabilityTest::TearDown()
50 {
51 LNN_LOGI(LNN_TEST, "LNNSleCapabilityTest end");
52 }
53
54 /*
55 * @tc.name: SetSleRangeCapToLocalLedgerTest001
56 * @tc.desc: test func SetSleRangeCapToLocalLedger branch
57 * @tc.type: FUNC
58 * @tc.require:
59 */
60 HWTEST_F(LNNSleCapabilityTest, SetSleRangeCapToLocalLedgerTest001, TestSize.Level1)
61 {
62 int32_t sleRangeCap = 0;
63 int32_t ret = 0;
64 NiceMock<LnnSleCapabilityInterfaceMock> sleCapabilityMock;
65 EXPECT_CALL(sleCapabilityMock, GetSleRangeCapacityPacked).WillRepeatedly(Return(sleRangeCap));
66 EXPECT_CALL(sleCapabilityMock, LnnGetLocalNumInfo)
67 .WillOnce(DoAll(SetArgPointee<1>(sleRangeCap), Return(SOFTBUS_OK)));
68 ret = SetSleRangeCapToLocalLedger();
69 EXPECT_EQ(ret, SOFTBUS_OK);
70
71 EXPECT_CALL(sleCapabilityMock, LnnGetLocalNumInfo)
72 .WillOnce(DoAll(SetArgPointee<1>(sleRangeCap), Return(SOFTBUS_ERR)));
73 ret = SetSleRangeCapToLocalLedger();
74 EXPECT_EQ(ret, SOFTBUS_OK);
75 }
76
77 /*
78 * @tc.name: SetSleRangeCapToLocalLedgerTest002
79 * @tc.desc: test func SetSleRangeCapToLocalLedger branch
80 * @tc.type: FUNC
81 * @tc.require:
82 */
83 HWTEST_F(LNNSleCapabilityTest, SetSleRangeCapToLocalLedgerTest002, TestSize.Level1)
84 {
85 int32_t sleRangeCap1 = 0;
86 int32_t ret = 0;
87 NiceMock<LnnSleCapabilityInterfaceMock> sleCapabilityMock;
88 EXPECT_CALL(sleCapabilityMock, GetSleRangeCapacityPacked)
89 .WillRepeatedly(Return(sleRangeCap1));
90 int32_t sleRangeCap2 = 1;
91 EXPECT_CALL(sleCapabilityMock, LnnGetLocalNumInfo)
92 .WillRepeatedly(DoAll(SetArgPointee<1>(sleRangeCap2), Return(SOFTBUS_OK)));
93 EXPECT_CALL(sleCapabilityMock, LnnUpdateSleCapacityAndVersion)
94 .WillOnce(Return(SOFTBUS_OK)).WillRepeatedly(Return(SOFTBUS_ERR));
95
96 ret = SetSleRangeCapToLocalLedger();
97 EXPECT_EQ(ret, SOFTBUS_OK);
98
99 ret = SetSleRangeCapToLocalLedger();
100 EXPECT_EQ(ret, SOFTBUS_ERR);
101 }
102
103 /*
104 * @tc.name: SetSleAddrToLocalLedgerTest001
105 * @tc.desc: test func SetSleAddrToLocalLedger branch
106 * @tc.type: FUNC
107 * @tc.require:
108 */
109 HWTEST_F(LNNSleCapabilityTest, SetSleAddrToLocalLedgerTest001, TestSize.Level1)
110 {
111 int32_t ret = 0;
112 NiceMock<LnnSleCapabilityInterfaceMock> sleCapabilityMock;
113 EXPECT_CALL(sleCapabilityMock, IsSleEnabledPacked)
114 .WillOnce(Return(false)).WillRepeatedly(Return(true));
115
116 ret = SetSleAddrToLocalLedger();
117 EXPECT_EQ(ret, SOFTBUS_SLE_RANGING_NOT_ENABLE);
118
119 EXPECT_CALL(sleCapabilityMock, GetLocalSleAddrPacked)
120 .WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
121
122 ret = SetSleAddrToLocalLedger();
123 EXPECT_EQ(ret, SOFTBUS_ERR);
124
125 EXPECT_CALL(sleCapabilityMock, LnnSetLocalStrInfo)
126 .WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
127
128 ret = SetSleAddrToLocalLedger();
129 EXPECT_EQ(ret, SOFTBUS_ERR);
130 ret = SetSleAddrToLocalLedger();
131 EXPECT_EQ(ret, SOFTBUS_OK);
132 }
133
134 /*
135 * @tc.name: SleStateChangeEventHandlerTest001
136 * @tc.desc: abnormal test func SleStateChangeEventHandler branch
137 * @tc.type: FUNC
138 * @tc.require:
139 */
140 HWTEST_F(LNNSleCapabilityTest, SleStateChangeEventHandlerTest001, TestSize.Level1)
141 {
142 int32_t sleRangeCap = 0;
143 NiceMock<LnnSleCapabilityInterfaceMock> sleCapabilityMock;
144 EXPECT_CALL(sleCapabilityMock, GetSleRangeCapacityPacked)
145 .WillRepeatedly(Return(sleRangeCap));
146 EXPECT_CALL(sleCapabilityMock, LnnGetLocalNumInfo)
147 .WillRepeatedly(DoAll(SetArgPointee<1>(sleRangeCap), Return(SOFTBUS_OK)));
148
149 int state = SOFTBUS_SLE_STATE_TURN_ON;
150 SleStateChangeEventHandler(state);
151 state = SOFTBUS_SLE_STATE_TURNING_ON;
152 SleStateChangeEventHandler(state);
153 EXPECT_EQ(g_sleRangeCap, sleRangeCap);
154
155 LnnSyncInfoType type = LNN_INFO_TYPE_SLE_MAC;
156 uint32_t size = strlen(MSG) + 1;
157 EXPECT_NO_FATAL_FAILURE(OnReceiveSleMacChangedMsg(LNN_INFO_TYPE_COUNT, NETWORK_ID, (const uint8_t *)MSG, size));
158 EXPECT_NO_FATAL_FAILURE(OnReceiveSleMacChangedMsg(type, NULL, (const uint8_t *)MSG, size));
159 EXPECT_NO_FATAL_FAILURE(OnReceiveSleMacChangedMsg(type, NETWORK_ID, NULL, size));
160 EXPECT_NO_FATAL_FAILURE(OnReceiveSleMacChangedMsg(type, NETWORK_ID, NULL, 0));
161 EXPECT_NO_FATAL_FAILURE(OnReceiveSleMacChangedMsg(type, NETWORK_ID, (const uint8_t *)EMPTYMSG, 1));
162 EXPECT_NO_FATAL_FAILURE(OnReceiveSleMacChangedMsg(type, NETWORK_ID, (const uint8_t *)MSG, size + 1));
163 EXPECT_NO_FATAL_FAILURE(OnReceiveSleMacChangedMsg(type, NETWORK_ID, (const uint8_t *)MSG, size));
164 }
165
166 /*
167 * @tc.name: LocalLedgerInitSleCapacityTest001
168 * @tc.desc: test func LocalLedgerInitSleCapacity branch
169 * @tc.type: FUNC
170 * @tc.require:
171 */
172 HWTEST_F(LNNSleCapabilityTest, LocalLedgerInitSleCapacityTest001, TestSize.Level1)
173 {
174 NiceMock<LnnSleCapabilityInterfaceMock> sleCapabilityMock;
175 int32_t ret = 0;
176 NodeInfo nodeInfo;
177 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
178 ret = LocalLedgerInitSleCapacity(NULL);
179 EXPECT_EQ(ret, SOFTBUS_ERR);
180
181 EXPECT_CALL(sleCapabilityMock, GetSleRangeCapacityPacked)
182 .WillOnce(Return(SOFTBUS_OK)).WillRepeatedly(Return(SOFTBUS_ERR));
183 EXPECT_CALL(sleCapabilityMock, SoftBusAddSleStateListenerPacked)
184 .WillOnce(Return(SOFTBUS_OK)).WillRepeatedly(Return(SOFTBUS_ERR));
185 ret = LocalLedgerInitSleCapacity(&nodeInfo);
186 EXPECT_EQ(ret, SOFTBUS_OK);
187 ret = LocalLedgerInitSleCapacity(&nodeInfo);
188 EXPECT_EQ(ret, SOFTBUS_ERR);
189 }
190
191 /*
192 * @tc.name: LnnInitSleInfoTest001
193 * @tc.desc: test func LnnInitSleInfo
194 * @tc.type: FUNC
195 * @tc.require:
196 */
197 HWTEST_F(LNNSleCapabilityTest, LnnInitSleInfoTest001, TestSize.Level1)
198 {
199 NiceMock<LnnSleCapabilityInterfaceMock> sleCapabilityMock;
200 int32_t ret = 0;
201 EXPECT_CALL(sleCapabilityMock, LnnRegSyncInfoHandler)
202 .WillOnce(Return(SOFTBUS_OK)).WillRepeatedly(Return(SOFTBUS_ERR));
203 ret = LnnInitSleInfo();
204 EXPECT_EQ(ret, SOFTBUS_OK);
205 ret = LnnInitSleInfo();
206 EXPECT_EQ(ret, SOFTBUS_ERR);
207 }
208 } // namespace OHOS