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 #include <securec.h>
18
19 #include "auth_pre_link.c"
20 #include "auth_pre_link.h"
21 #include "auth_pre_link_mock.h"
22 #include "softbus_adapter_mem.h"
23 #include "softbus_error_code.h"
24
25 namespace OHOS {
26 using namespace testing::ext;
27 using namespace testing;
28 const int32_t TEST_FD = 1;
29 const char TEST_UUID[] = "1234567890";
30
31 class AuthPreLinkTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase()39 void AuthPreLinkTest::SetUpTestCase()
40 {
41 int32_t ret = InitAuthPreLinkList();
42 EXPECT_EQ(ret, SOFTBUS_OK);
43 ret = InitAuthGenCertParallelList();
44 EXPECT_EQ(ret, SOFTBUS_OK);
45 }
46
TearDownTestCase()47 void AuthPreLinkTest::TearDownTestCase()
48 {
49 DeinitAuthGenCertParallelList();
50 DeinitAuthPreLinkList();
51 }
52
SetUp()53 void AuthPreLinkTest::SetUp() { }
54
TearDown()55 void AuthPreLinkTest::TearDown() { }
56
AuthFsmTestTrueLinkHasPtk(const char * remoteDeviceId)57 static bool AuthFsmTestTrueLinkHasPtk(const char *remoteDeviceId)
58 {
59 (void)remoteDeviceId;
60 return true;
61 }
62
AuthFsmTestFalseLinkHasPtk(const char * remoteDeviceId)63 static bool AuthFsmTestFalseLinkHasPtk(const char *remoteDeviceId)
64 {
65 (void)remoteDeviceId;
66 return false;
67 }
68
69 static struct WifiDirectManager g_manager1 = {
70 .linkHasPtk = AuthFsmTestTrueLinkHasPtk,
71 };
72
73 static struct WifiDirectManager g_manager2 = {
74 .linkHasPtk = AuthFsmTestFalseLinkHasPtk,
75 };
76
77 static struct WifiDirectManager g_manager3 = {
78 .linkHasPtk = NULL,
79 };
80
81 HWTEST_F(AuthPreLinkTest, ADD_AUTH_GEN_CER_PARA_NODE_TEST_001, TestSize.Level1)
82 {
83 int32_t requestId = 1;
84 int32_t ret = AddAuthGenCertParaNode(requestId);
85 EXPECT_EQ(ret, SOFTBUS_OK);
86 ret = AddAuthGenCertParaNode(requestId);
87 EXPECT_EQ(ret, SOFTBUS_ALREADY_EXISTED);
88 DelAuthGenCertParaNodeById(requestId);
89 }
90
91 HWTEST_F(AuthPreLinkTest, UPDATE_AUTH_GEN_CER_PARA_NODE_TEST_001, TestSize.Level1)
92 {
93 int32_t requestId = 1;
94 bool isValid = true;
95 SoftbusCertChain *softbusCertChain = nullptr;
96 int32_t ret = UpdateAuthGenCertParaNode(requestId, isValid, softbusCertChain);
97 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
98 }
99
100 HWTEST_F(AuthPreLinkTest, UPDATE_AUTH_GEN_CER_PARA_NODE_TEST_002, TestSize.Level1)
101 {
102 int32_t requestId = 1;
103 bool isValid = true;
104 SoftbusCertChain softbusCertChain;
105 (void)memset_s(&softbusCertChain, sizeof(SoftbusCertChain), 0, sizeof(SoftbusCertChain));
106 int32_t ret = UpdateAuthGenCertParaNode(requestId, isValid, &softbusCertChain);
107 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
108 }
109
110 HWTEST_F(AuthPreLinkTest, UPDATE_AUTH_GEN_CER_PARA_NODE_TEST_003, TestSize.Level1)
111 {
112 int32_t requestId = 1;
113 bool isValid = true;
114 SoftbusCertChain *softbusCertChain = (SoftbusCertChain *)SoftBusCalloc(sizeof(SoftbusCertChain));
115 ASSERT_NE(softbusCertChain, nullptr);
116 int32_t ret = AddAuthGenCertParaNode(requestId);
117 EXPECT_EQ(ret, SOFTBUS_OK);
118 ret = UpdateAuthGenCertParaNode(requestId, isValid, softbusCertChain);
119 EXPECT_EQ(ret, SOFTBUS_OK);
120 DelAuthGenCertParaNodeById(requestId);
121 }
122
123 HWTEST_F(AuthPreLinkTest, FIND_AND_WAIT_AUTH_GEN_CERT_PARA_NODE_BY_ID_TEST_001, TestSize.Level1)
124 {
125 int32_t requestId = 1;
126 int32_t ret = FindAndWaitAuthGenCertParaNodeById(requestId, nullptr);
127 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
128 }
129
130 HWTEST_F(AuthPreLinkTest, FIND_AND_WAIT_AUTH_GEN_CERT_PARA_NODE_BY_ID_TEST_002, TestSize.Level1)
131 {
132 int32_t requestId = 1;
133 AuthGenCertNode *genCertParaNode = nullptr;
134 int32_t ret = FindAndWaitAuthGenCertParaNodeById(requestId, &genCertParaNode);
135 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
136 }
137
138 HWTEST_F(AuthPreLinkTest, FIND_AND_WAIT_AUTH_GEN_CERT_PARA_NODE_BY_ID_TEST_003, TestSize.Level1)
139 {
140 int32_t requestId = 1;
141 AuthGenCertNode *genCertParaNode = nullptr;
142 int32_t ret = AddAuthGenCertParaNode(requestId);
143 EXPECT_EQ(ret, SOFTBUS_OK);
144 ret = FindAndWaitAuthGenCertParaNodeById(requestId, &genCertParaNode);
145 EXPECT_EQ(ret, SOFTBUS_AUTH_TIMEOUT);
146 ret = AddAuthGenCertParaNode(requestId);
147 EXPECT_EQ(ret, SOFTBUS_OK);
148 SoftbusCertChain *softbusCertChain = (SoftbusCertChain *)SoftBusCalloc(sizeof(SoftbusCertChain));
149 ASSERT_NE(softbusCertChain, nullptr);
150 ret = UpdateAuthGenCertParaNode(requestId, true, softbusCertChain);
151 EXPECT_EQ(ret, SOFTBUS_OK);
152 ret = FindAndWaitAuthGenCertParaNodeById(requestId, &genCertParaNode);
153 EXPECT_EQ(ret, SOFTBUS_OK);
154 DelAuthGenCertParaNodeById(requestId);
155 }
156
157 HWTEST_F(AuthPreLinkTest, IS_AUTH_PRE_LINK_NODE_EXIST_TEST_001, TestSize.Level1)
158 {
159 uint32_t requestId = 1;
160 bool isExist = IsAuthPreLinkNodeExist(requestId);
161 EXPECT_EQ(isExist, false);
162 ConnectionAddr connAddr;
163 (void)memset_s(&connAddr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
164 int32_t ret = AddToAuthPreLinkList(requestId, TEST_FD, &connAddr);
165 EXPECT_EQ(ret, SOFTBUS_OK);
166 isExist = IsAuthPreLinkNodeExist(requestId);
167 EXPECT_EQ(isExist, true);
168 DelAuthPreLinkById(requestId);
169 }
170
171 HWTEST_F(AuthPreLinkTest, FIND_AUTH_PRE_LINK_NODE_BY_ID_TEST_001, TestSize.Level1)
172 {
173 uint32_t requestId = 1;
174 AuthPreLinkNode node;
175 (void)memset_s(&node, sizeof(AuthPreLinkNode), 0, sizeof(ConnectionAddr));
176 int32_t ret = FindAuthPreLinkNodeById(requestId, &node);
177 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
178 ConnectionAddr connAddr;
179 (void)memset_s(&connAddr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
180 ret = AddToAuthPreLinkList(requestId, TEST_FD, &connAddr);
181 EXPECT_EQ(ret, SOFTBUS_OK);
182 ret = FindAuthPreLinkNodeById(requestId, &node);
183 EXPECT_EQ(ret, SOFTBUS_OK);
184 DelAuthPreLinkById(requestId);
185 }
186
187 HWTEST_F(AuthPreLinkTest, FIND_AUTH_PRE_LINK_NODE_BY_UUID_TEST_001, TestSize.Level1)
188 {
189 uint32_t requestId = 1;
190 AuthPreLinkNode node;
191 (void)memset_s(&node, sizeof(AuthPreLinkNode), 0, sizeof(ConnectionAddr));
192 int32_t ret = FindAuthPreLinkNodeByUuid(nullptr, &node);
193 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
194 ret = FindAuthPreLinkNodeByUuid(TEST_UUID, nullptr);
195 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
196 ret = FindAuthPreLinkNodeByUuid(TEST_UUID, &node);
197 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
198 ConnectionAddr connAddr;
199 (void)memset_s(&connAddr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
200 ret = AddToAuthPreLinkList(requestId, TEST_FD, &connAddr);
201 EXPECT_EQ(ret, SOFTBUS_OK);
202 ret = UpdateAuthPreLinkUuidById(requestId, (char *)TEST_UUID);
203 EXPECT_EQ(ret, SOFTBUS_OK);
204 ret = FindAuthPreLinkNodeByUuid(TEST_UUID, &node);
205 EXPECT_EQ(ret, SOFTBUS_OK);
206 DelAuthPreLinkById(requestId);
207 }
208
209 HWTEST_F(AuthPreLinkTest, UPDATE_AUTH_PRE_LINK_UUID_BY_ID_TEST_001, TestSize.Level1)
210 {
211 uint32_t requestId = 1;
212 int32_t ret = UpdateAuthPreLinkUuidById(requestId, nullptr);
213 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
214 ret = UpdateAuthPreLinkUuidById(requestId, (char *)TEST_UUID);
215 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
216 ConnectionAddr connAddr;
217 (void)memset_s(&connAddr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
218 ret = AddToAuthPreLinkList(requestId, TEST_FD, &connAddr);
219 EXPECT_EQ(ret, SOFTBUS_OK);
220 ret = UpdateAuthPreLinkUuidById(requestId, (char *)TEST_UUID);
221 EXPECT_EQ(ret, SOFTBUS_OK);
222 DelAuthPreLinkById(requestId);
223 }
224
225 /*
226 * @tc.name: PRE_LINK_CHECK_HAS_PTK_TEST_001
227 * @tc.desc: PreLinkCheckHasPtk test
228 * @tc.type: FUNC
229 * @tc.require:
230 */
231 HWTEST_F(AuthPreLinkTest, PRE_LINK_CHECK_HAS_PTK_TEST_001, TestSize.Level1)
232 {
233 NiceMock<AuthPreLinkInterfaceMock> mock;
234 EXPECT_CALL(mock, GetWifiDirectManager).WillOnce(Return(NULL)).WillOnce(Return(&g_manager3))
235 .WillOnce(Return(&g_manager2)).WillRepeatedly(Return(&g_manager1));
236 EXPECT_FALSE(PreLinkCheckHasPtk(NULL));
237 EXPECT_FALSE(PreLinkCheckHasPtk(TEST_UUID));
238 EXPECT_FALSE(PreLinkCheckHasPtk(TEST_UUID));
239 EXPECT_FALSE(PreLinkCheckHasPtk(TEST_UUID));
240 EXPECT_TRUE(PreLinkCheckHasPtk(TEST_UUID));
241 }
242 }
243