1 //
2 // Copyright (C) 2025 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 #include "nfa_ee_api.cc"
18
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21
22 #include "mock_gki_utils.h"
23 #include "nfa_ee_int.h"
24 #include "nfa_hci_int.h"
25
26 class NfaEeApiTest : public ::testing::Test {
SetUp()27 void SetUp() override { gki_utils = new MockGkiUtils(); }
TearDown()28 void TearDown() override {
29 delete gki_utils;
30 gki_utils = nullptr;
31 }
32 };
33
34 // Tests for NFA_EeDiscover
TEST_F(NfaEeApiTest,NFA_EeDiscoverInvalidState)35 TEST_F(NfaEeApiTest, NFA_EeDiscoverInvalidState) {
36 tNFA_EE_CBACK* p_ee_cback = nullptr;
37 nfa_ee_cb.em_state = NFA_EE_EM_STATE_INIT;
38 tNFA_STATUS status = NFA_EeDiscover(p_ee_cback);
39 EXPECT_EQ(status, NFA_STATUS_FAILED);
40 }
41
TEST_F(NfaEeApiTest,NFA_EeDiscoverInvalidParam)42 TEST_F(NfaEeApiTest, NFA_EeDiscoverInvalidParam) {
43 tNFA_EE_CBACK* p_ee_cback = nullptr;
44 nfa_ee_cb.em_state = NFA_EE_EM_STATE_INIT_DONE;
45 tNFA_STATUS status = NFA_EeDiscover(p_ee_cback);
46 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
47 }
48
TEST_F(NfaEeApiTest,NFA_EeDiscoverNormal)49 TEST_F(NfaEeApiTest, NFA_EeDiscoverNormal) {
50 tNFA_EE_CBACK* mock_callback = [](tNFA_EE_EVT /*event*/,
51 tNFA_EE_CBACK_DATA* /*p_data*/) {};
52 nfa_ee_cb.p_ee_disc_cback = nullptr;
53 nfa_ee_cb.em_state = NFA_EE_EM_STATE_INIT_DONE;
54 tNFA_EE_API_DISCOVER* p_msg =
55 (tNFA_EE_API_DISCOVER*)malloc(sizeof(tNFA_EE_API_DISCOVER));
56
57 EXPECT_CALL(*((MockGkiUtils*)gki_utils), getbuf(sizeof(tNFA_EE_API_DISCOVER)))
58 .WillOnce(testing::Return(p_msg));
59 tNFA_STATUS status = NFA_EeDiscover(mock_callback);
60
61 free(p_msg);
62 EXPECT_EQ(status, NFA_STATUS_OK);
63 }
64
65 // Tests for NFA_EeGetInfo
TEST_F(NfaEeApiTest,NFA_EeGetInfoInvalidParam)66 TEST_F(NfaEeApiTest, NFA_EeGetInfoInvalidParam) {
67 tNFA_STATUS status = NFA_EeGetInfo(nullptr, nullptr);
68 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
69 }
70
TEST_F(NfaEeApiTest,NFA_EeGetInfoInvalidState)71 TEST_F(NfaEeApiTest, NFA_EeGetInfoInvalidState) {
72 memset(&nfa_hci_cb, 0, sizeof(nfa_hci_cb));
73 nfa_hci_cb.num_nfcee = 1;
74 nfa_hci_cb.ee_info[0].ee_interface[0] = 0;
75 nfa_ee_cb.em_state = NFA_EE_EM_STATE_INIT;
76 tNFA_STATUS status = NFA_EeGetInfo(&nfa_hci_cb.num_nfcee, nfa_hci_cb.ee_info);
77 EXPECT_EQ(status, NFA_STATUS_FAILED);
78 }
79
TEST_F(NfaEeApiTest,NFA_EeGetInfoOneNfcEe)80 TEST_F(NfaEeApiTest, NFA_EeGetInfoOneNfcEe) {
81 memset(&nfa_hci_cb, 0, sizeof(nfa_hci_cb));
82 memset(&nfa_ee_cb, 0, sizeof(nfa_ee_cb));
83 nfa_ee_cb.cur_ee = 1;
84 nfa_hci_cb.num_nfcee = 2;
85 nfa_hci_cb.ee_info[0].ee_interface[0] = 0;
86 nfa_ee_cb.em_state = NFA_EE_EM_STATE_INIT_DONE;
87 nfa_ee_cb.ecb[0].nfcee_id = 0x10;
88 tNFA_STATUS status = NFA_EeGetInfo(&nfa_hci_cb.num_nfcee, nfa_hci_cb.ee_info);
89 EXPECT_EQ(status, NFA_STATUS_OK);
90 EXPECT_EQ(nfa_hci_cb.num_nfcee, 1);
91 EXPECT_EQ(nfa_hci_cb.ee_info[0].ee_handle,
92 NFA_HANDLE_GROUP_EE | (tNFA_HANDLE)nfa_ee_cb.ecb[0].nfcee_id);
93 }
94
95 // Tests for NFA_EeRegister
TEST_F(NfaEeApiTest,NFA_EeRegisterInvalidParam)96 TEST_F(NfaEeApiTest, NFA_EeRegisterInvalidParam) {
97 tNFA_STATUS status = NFA_EeRegister(nullptr);
98 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
99 }
100
TEST_F(NfaEeApiTest,NFA_EeRegisterNormal)101 TEST_F(NfaEeApiTest, NFA_EeRegisterNormal) {
102 tNFA_EE_CBACK* mock_callback = [](tNFA_EE_EVT /*event*/,
103 tNFA_EE_CBACK_DATA* /*p_data*/) {};
104 tNFA_EE_API_REGISTER* p_msg =
105 (tNFA_EE_API_REGISTER*)malloc(sizeof(tNFA_EE_API_REGISTER));
106
107 EXPECT_CALL(*((MockGkiUtils*)gki_utils), getbuf(sizeof(tNFA_EE_API_REGISTER)))
108 .WillOnce(testing::Return(p_msg));
109 tNFA_STATUS status = NFA_EeRegister(mock_callback);
110
111 free(p_msg);
112 EXPECT_EQ(status, NFA_STATUS_OK);
113 }
114
115 // Tests for NFA_EeDeregister
TEST_F(NfaEeApiTest,NFA_EeDeregister)116 TEST_F(NfaEeApiTest, NFA_EeDeregister) {
117 memset(&nfa_ee_cb, 0, sizeof(nfa_ee_cb));
118 tNFA_EE_CBACK* mock_callback = [](tNFA_EE_EVT /*event*/,
119 tNFA_EE_CBACK_DATA* /*p_data*/) {};
120 nfa_ee_cb.p_ee_cback[0] = mock_callback;
121 tNFA_EE_API_DEREGISTER* p_msg =
122 (tNFA_EE_API_DEREGISTER*)malloc(sizeof(tNFA_EE_API_DEREGISTER));
123
124 EXPECT_CALL(*((MockGkiUtils*)gki_utils),
125 getbuf(sizeof(tNFA_EE_API_DEREGISTER)))
126 .WillOnce(testing::Return(p_msg));
127 tNFA_STATUS status = NFA_EeDeregister(mock_callback);
128
129 free(p_msg);
130 EXPECT_EQ(status, NFA_STATUS_OK);
131 }
132
133 // Tests for NFA_EeModeSet
TEST_F(NfaEeApiTest,NFA_EeModeSetInvalidNfceeId)134 TEST_F(NfaEeApiTest, NFA_EeModeSetInvalidNfceeId) {
135 memset(&nfa_ee_cb, 0, sizeof(nfa_ee_cb));
136 nfa_ee_cb.cur_ee = 2;
137 nfa_ee_cb.ecb[0].nfcee_id = 0;
138 nfa_ee_cb.ecb[1].nfcee_id = 0x10;
139
140 tNFA_STATUS status = NFA_EeModeSet(0xff, NFA_EE_MD_ACTIVATE);
141 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
142 }
143
TEST_F(NfaEeApiTest,NFA_EeModeSetActivate)144 TEST_F(NfaEeApiTest, NFA_EeModeSetActivate) {
145 memset(&nfa_ee_cb, 0, sizeof(nfa_ee_cb));
146 nfa_ee_cb.cur_ee = 2;
147 nfa_ee_cb.ecb[0].nfcee_id = 0;
148 nfa_ee_cb.ecb[1].nfcee_id = 0x10;
149
150 tNFA_EE_API_MODE_SET* p_msg =
151 (tNFA_EE_API_MODE_SET*)malloc(sizeof(tNFA_EE_API_MODE_SET));
152
153 EXPECT_CALL(*((MockGkiUtils*)gki_utils), getbuf(sizeof(tNFA_EE_API_MODE_SET)))
154 .WillOnce(testing::Return(p_msg));
155 tNFA_STATUS status = NFA_EeModeSet(0x10, NFA_EE_MD_ACTIVATE);
156
157 free(p_msg);
158 EXPECT_EQ(status, NFA_STATUS_OK);
159 }
160
161 // Tests for NFA_EeSetDefaultTechRouting
TEST_F(NfaEeApiTest,NFA_EeSetDefaultTechRoutingInvalidNfceeId)162 TEST_F(NfaEeApiTest, NFA_EeSetDefaultTechRoutingInvalidNfceeId) {
163 tNFA_STATUS status =
164 NFA_EeSetDefaultTechRouting(0xff, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1);
165 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
166 }
167
TEST_F(NfaEeApiTest,NFA_EeSetDefaultTechRoutingHost)168 TEST_F(NfaEeApiTest, NFA_EeSetDefaultTechRoutingHost) {
169 tNFA_EE_API_SET_TECH_CFG* p_msg =
170 (tNFA_EE_API_SET_TECH_CFG*)malloc(sizeof(tNFA_EE_API_SET_TECH_CFG));
171
172 EXPECT_CALL(*((MockGkiUtils*)gki_utils),
173 getbuf(sizeof(tNFA_EE_API_SET_TECH_CFG)))
174 .WillOnce(testing::Return(p_msg));
175 tNFA_STATUS status =
176 NFA_EeSetDefaultTechRouting(NFC_DH_ID, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1);
177
178 free(p_msg);
179 EXPECT_EQ(status, NFA_STATUS_OK);
180 }
181
182 // Tests for NFA_EeClearDefaultTechRouting
TEST_F(NfaEeApiTest,NFA_EeClearDefaultTechRoutingInvalidNfceeId)183 TEST_F(NfaEeApiTest, NFA_EeClearDefaultTechRoutingInvalidNfceeId) {
184 tNFA_STATUS status = NFA_EeClearDefaultTechRouting(0xff, 0x1);
185 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
186 }
187
TEST_F(NfaEeApiTest,NFA_EeClearDefaultTechRoutingHost)188 TEST_F(NfaEeApiTest, NFA_EeClearDefaultTechRoutingHost) {
189 tNFA_EE_API_CLEAR_TECH_CFG* p_msg =
190 (tNFA_EE_API_CLEAR_TECH_CFG*)malloc(sizeof(tNFA_EE_API_CLEAR_TECH_CFG));
191
192 EXPECT_CALL(*((MockGkiUtils*)gki_utils),
193 getbuf(sizeof(tNFA_EE_API_CLEAR_TECH_CFG)))
194 .WillOnce(testing::Return(p_msg));
195 tNFA_STATUS status = NFA_EeClearDefaultTechRouting(NFC_DH_ID, 0x1);
196
197 free(p_msg);
198 EXPECT_EQ(status, NFA_STATUS_OK);
199 }
200
201 // Tests for NFA_EeSetDefaultProtoRouting
TEST_F(NfaEeApiTest,NFA_EeSetDefaultProtoRoutingInvalidNfceeId)202 TEST_F(NfaEeApiTest, NFA_EeSetDefaultProtoRoutingInvalidNfceeId) {
203 tNFA_STATUS status =
204 NFA_EeSetDefaultProtoRouting(0xff, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1);
205 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
206 }
207
TEST_F(NfaEeApiTest,NFA_EeSetDefaultProtoRoutingHost)208 TEST_F(NfaEeApiTest, NFA_EeSetDefaultProtoRoutingHost) {
209 tNFA_EE_API_SET_PROTO_CFG* p_msg =
210 (tNFA_EE_API_SET_PROTO_CFG*)malloc(sizeof(tNFA_EE_API_SET_PROTO_CFG));
211
212 EXPECT_CALL(*((MockGkiUtils*)gki_utils),
213 getbuf(sizeof(tNFA_EE_API_SET_PROTO_CFG)))
214 .WillOnce(testing::Return(p_msg));
215 tNFA_STATUS status =
216 NFA_EeSetDefaultProtoRouting(NFC_DH_ID, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1);
217
218 free(p_msg);
219 EXPECT_EQ(status, NFA_STATUS_OK);
220 }
221
222 // Tests for NFA_EeClearDefaultProtoRouting
TEST_F(NfaEeApiTest,NFA_EeClearDefaultProtoRoutingInvalidNfceeId)223 TEST_F(NfaEeApiTest, NFA_EeClearDefaultProtoRoutingInvalidNfceeId) {
224 tNFA_STATUS status = NFA_EeClearDefaultProtoRouting(0xff, 0x1);
225 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
226 }
227
TEST_F(NfaEeApiTest,NFA_EeClearDefaultProtoRoutingClearNone)228 TEST_F(NfaEeApiTest, NFA_EeClearDefaultProtoRoutingClearNone) {
229 tNFA_STATUS status = NFA_EeClearDefaultProtoRouting(0xff, 0x0);
230 EXPECT_EQ(status, NFA_STATUS_OK);
231 }
232
TEST_F(NfaEeApiTest,NFA_EeClearDefaultProtoRoutingHost)233 TEST_F(NfaEeApiTest, NFA_EeClearDefaultProtoRoutingHost) {
234 tNFA_EE_API_SET_PROTO_CFG* p_msg =
235 (tNFA_EE_API_SET_PROTO_CFG*)malloc(sizeof(tNFA_EE_API_SET_PROTO_CFG));
236
237 EXPECT_CALL(*((MockGkiUtils*)gki_utils),
238 getbuf(sizeof(tNFA_EE_API_SET_PROTO_CFG)))
239 .WillOnce(testing::Return(p_msg));
240 tNFA_STATUS status = NFA_EeClearDefaultProtoRouting(NFC_DH_ID, 0x1);
241
242 free(p_msg);
243 EXPECT_EQ(status, NFA_STATUS_OK);
244 }
245
246 // Tests for NFA_EeAddAidRouting
TEST_F(NfaEeApiTest,NFA_EeAddAidRoutingInvalidNfceeId)247 TEST_F(NfaEeApiTest, NFA_EeAddAidRoutingInvalidNfceeId) {
248 uint8_t aid[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
249 tNFA_STATUS status = NFA_EeAddAidRouting(0xff, sizeof(aid), aid, 0x1, 0x1);
250 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
251 }
252
TEST_F(NfaEeApiTest,NFA_EeAddAidRoutingInvalidAid)253 TEST_F(NfaEeApiTest, NFA_EeAddAidRoutingInvalidAid) {
254 uint8_t aid[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
255 tNFA_STATUS status = NFA_EeAddAidRouting(NFC_DH_ID, 0, nullptr, 0x1, 0x1);
256 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
257 }
258
TEST_F(NfaEeApiTest,NFA_EeAddAidRoutingRegisterOneAidToHost)259 TEST_F(NfaEeApiTest, NFA_EeAddAidRoutingRegisterOneAidToHost) {
260 uint8_t aid[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
261 uint8_t size = sizeof(tNFA_EE_API_ADD_AID) + sizeof(aid);
262 tNFA_EE_API_ADD_AID* p_msg = (tNFA_EE_API_ADD_AID*)malloc(size);
263
264 EXPECT_CALL(*((MockGkiUtils*)gki_utils), getbuf(size))
265 .WillOnce(testing::Return(p_msg));
266 tNFA_STATUS status =
267 NFA_EeAddAidRouting(NFC_DH_ID, sizeof(aid), aid, 0x1, 0x1);
268
269 free(p_msg);
270 EXPECT_EQ(status, NFA_STATUS_OK);
271 }
272
273 // Tests for NFA_EeRemoveAidRouting
TEST_F(NfaEeApiTest,NFA_EeRemoveAidRoutingInvalidAid1)274 TEST_F(NfaEeApiTest, NFA_EeRemoveAidRoutingInvalidAid1) {
275 uint8_t aid[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
276 tNFA_STATUS status = NFA_EeRemoveAidRouting(sizeof(aid), nullptr);
277 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
278 }
279
TEST_F(NfaEeApiTest,NFA_EeRemoveAidRoutingInvalidAid2)280 TEST_F(NfaEeApiTest, NFA_EeRemoveAidRoutingInvalidAid2) {
281 uint8_t aid[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
282 tNFA_STATUS status = NFA_EeRemoveAidRouting(NFA_MAX_AID_LEN + 1, aid);
283 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
284 }
285
TEST_F(NfaEeApiTest,NFA_EeRemoveAidRoutingValidAid)286 TEST_F(NfaEeApiTest, NFA_EeRemoveAidRoutingValidAid) {
287 uint8_t aid[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
288 uint8_t size = sizeof(tNFA_EE_API_REMOVE_AID) + sizeof(aid);
289 tNFA_EE_API_REMOVE_AID* p_msg = (tNFA_EE_API_REMOVE_AID*)malloc(size);
290
291 EXPECT_CALL(*((MockGkiUtils*)gki_utils), getbuf(size))
292 .WillOnce(testing::Return(p_msg));
293 tNFA_STATUS status = NFA_EeRemoveAidRouting(sizeof(aid), aid);
294
295 free(p_msg);
296 EXPECT_EQ(status, NFA_STATUS_OK);
297 }
298
299 // Tests for NFA_EeAddSystemCodeRouting
TEST_F(NfaEeApiTest,NFA_EeAddSystemCodeRoutingInvalidNfceeId)300 TEST_F(NfaEeApiTest, NFA_EeAddSystemCodeRoutingInvalidNfceeId) {
301 tNFA_STATUS status = NFA_EeAddSystemCodeRouting(0xFEFE, 0xff, 0x1);
302 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
303 }
304
TEST_F(NfaEeApiTest,NFA_EeAddSystemCodeRoutingInvalidSystemCode)305 TEST_F(NfaEeApiTest, NFA_EeAddSystemCodeRoutingInvalidSystemCode) {
306 tNFA_STATUS status = NFA_EeAddSystemCodeRouting(0x0, NFC_DH_ID, 0x1);
307 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
308 }
309
TEST_F(NfaEeApiTest,NFA_EeAddSystemCodeRoutingNotSupport)310 TEST_F(NfaEeApiTest, NFA_EeAddSystemCodeRoutingNotSupport) {
311 nfc_cb.nci_version = NCI_VERSION_1_0;
312 nfc_cb.isScbrSupported = false;
313 tNFA_STATUS status = NFA_EeAddSystemCodeRouting(0xFEFE, NFC_DH_ID, 0x1);
314 EXPECT_EQ(status, NFA_STATUS_NOT_SUPPORTED);
315 }
316
TEST_F(NfaEeApiTest,NFA_EeAddSystemCodeRoutingRegisterDefaultSystemCodeToHost)317 TEST_F(NfaEeApiTest,
318 NFA_EeAddSystemCodeRoutingRegisterDefaultSystemCodeToHost) {
319 nfc_cb.nci_version = NCI_VERSION_2_0;
320 tNFA_EE_API_ADD_SYSCODE* p_msg =
321 (tNFA_EE_API_ADD_SYSCODE*)malloc(sizeof(tNFA_EE_API_ADD_SYSCODE));
322
323 EXPECT_CALL(*((MockGkiUtils*)gki_utils),
324 getbuf(sizeof(tNFA_EE_API_ADD_SYSCODE)))
325 .WillOnce(testing::Return(p_msg));
326 tNFA_STATUS status = NFA_EeAddSystemCodeRouting(0xFEFE, NFC_DH_ID, 0x1);
327
328 free(p_msg);
329 EXPECT_EQ(status, NFA_STATUS_OK);
330 }
331
332 // Tests for NFA_EeRemoveSystemCodeRouting
TEST_F(NfaEeApiTest,NFA_EeRemoveSystemCodeRoutingInvalidSystemCode)333 TEST_F(NfaEeApiTest, NFA_EeRemoveSystemCodeRoutingInvalidSystemCode) {
334 tNFA_STATUS status = NFA_EeRemoveSystemCodeRouting(0x0);
335 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
336 }
337
TEST_F(NfaEeApiTest,NFA_EeRemoveSystemCodeRoutingNotSupport)338 TEST_F(NfaEeApiTest, NFA_EeRemoveSystemCodeRoutingNotSupport) {
339 nfc_cb.nci_version = NCI_VERSION_1_0;
340 nfc_cb.isScbrSupported = false;
341 tNFA_STATUS status = NFA_EeRemoveSystemCodeRouting(0xFEFE);
342 EXPECT_EQ(status, NFA_STATUS_NOT_SUPPORTED);
343 }
344
TEST_F(NfaEeApiTest,NFA_EeRemoveSystemCodeRoutingRegisterDefaultSystemCodeToHost)345 TEST_F(NfaEeApiTest,
346 NFA_EeRemoveSystemCodeRoutingRegisterDefaultSystemCodeToHost) {
347 nfc_cb.nci_version = NCI_VERSION_2_0;
348 tNFA_EE_API_REMOVE_SYSCODE* p_msg =
349 (tNFA_EE_API_REMOVE_SYSCODE*)malloc(sizeof(tNFA_EE_API_REMOVE_SYSCODE));
350
351 EXPECT_CALL(*((MockGkiUtils*)gki_utils),
352 getbuf(sizeof(tNFA_EE_API_REMOVE_SYSCODE)))
353 .WillOnce(testing::Return(p_msg));
354 tNFA_STATUS status = NFA_EeRemoveSystemCodeRouting(0xFEFE);
355
356 free(p_msg);
357 EXPECT_EQ(status, NFA_STATUS_OK);
358 }
359
360 // Tests for NFA_GetAidTableSize
TEST_F(NfaEeApiTest,GetAidTableSize)361 TEST_F(NfaEeApiTest, GetAidTableSize) { ASSERT_GE(NFA_GetAidTableSize(), 0); }
362
363 // Tests for NFA_EeGetLmrtRemainingSize
TEST_F(NfaEeApiTest,NFA_EeGetLmrtRemainingSize)364 TEST_F(NfaEeApiTest, NFA_EeGetLmrtRemainingSize) {
365 tNFA_EE_API_LMRT_SIZE* p_msg =
366 (tNFA_EE_API_LMRT_SIZE*)malloc(sizeof(tNFA_EE_API_LMRT_SIZE));
367
368 EXPECT_CALL(*((MockGkiUtils*)gki_utils),
369 getbuf(sizeof(tNFA_EE_API_LMRT_SIZE)))
370 .WillOnce(testing::Return(p_msg));
371 tNFA_STATUS status = NFA_EeGetLmrtRemainingSize();
372
373 free(p_msg);
374 EXPECT_EQ(status, NFA_STATUS_OK);
375 }
376
377 // Tests for NFA_EeUpdateNow
TEST_F(NfaEeApiTest,NFA_EeUpdateNowInProgress)378 TEST_F(NfaEeApiTest, NFA_EeUpdateNowInProgress) {
379 nfa_ee_cb.ee_wait_evt |= NFA_EE_WAIT_UPDATE_ALL;
380
381 tNFA_STATUS status = NFA_EeUpdateNow();
382 EXPECT_EQ(status, NFA_STATUS_SEMANTIC_ERROR);
383
384 nfa_ee_cb.ee_wait_evt &= ~NFA_EE_WAIT_UPDATE_ALL;
385 }
386
TEST_F(NfaEeApiTest,NFA_EeUpdateNowNormal)387 TEST_F(NfaEeApiTest, NFA_EeUpdateNowNormal) {
388 NFC_HDR* p_msg = (NFC_HDR*)malloc(sizeof(NFC_HDR_SIZE));
389
390 EXPECT_CALL(*((MockGkiUtils*)gki_utils), getbuf(sizeof(NFC_HDR_SIZE)))
391 .WillOnce(testing::Return(p_msg));
392 tNFA_STATUS status = NFA_EeUpdateNow();
393
394 free(p_msg);
395 EXPECT_EQ(status, NFA_STATUS_OK);
396 }
397
398 // Tests for NFA_EeConnect
TEST_F(NfaEeApiTest,NFA_EeConnectInvalidEe)399 TEST_F(NfaEeApiTest, NFA_EeConnectInvalidEe) {
400 tNFA_EE_CBACK* mock_callback = [](tNFA_EE_EVT /*event*/,
401 tNFA_EE_CBACK_DATA* /*p_data*/) {};
402 tNFA_STATUS status = NFA_EeConnect(0xFF, 0x0, mock_callback);
403 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
404 }
405
TEST_F(NfaEeApiTest,NFA_EeConnectNullCback)406 TEST_F(NfaEeApiTest, NFA_EeConnectNullCback) {
407 tNFA_STATUS status = NFA_EeConnect(NFC_DH_ID, 0x0, nullptr);
408 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
409 }
410
TEST_F(NfaEeApiTest,NFA_EeConnectHost)411 TEST_F(NfaEeApiTest, NFA_EeConnectHost) {
412 tNFA_EE_CBACK* mock_callback = [](tNFA_EE_EVT /*event*/,
413 tNFA_EE_CBACK_DATA* /*p_data*/) {};
414 tNFA_EE_API_CONNECT* p_msg =
415 (tNFA_EE_API_CONNECT*)malloc(sizeof(tNFA_EE_API_CONNECT));
416
417 EXPECT_CALL(*((MockGkiUtils*)gki_utils), getbuf(sizeof(tNFA_EE_API_CONNECT)))
418 .WillOnce(testing::Return(p_msg));
419 tNFA_STATUS status = NFA_EeConnect(NFC_DH_ID, 0x0, mock_callback);
420
421 free(p_msg);
422 EXPECT_EQ(status, NFA_STATUS_OK);
423 }
424
425 // Tests for NFA_EeSendData
TEST_F(NfaEeApiTest,NFA_EeSendDataInvalidEe)426 TEST_F(NfaEeApiTest, NFA_EeSendDataInvalidEe) {
427 uint8_t data[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
428
429 tNFA_STATUS status = NFA_EeSendData(0xff, sizeof(data), data);
430 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
431 }
432
TEST_F(NfaEeApiTest,NFA_EeSendDataInvalidNullData)433 TEST_F(NfaEeApiTest, NFA_EeSendDataInvalidNullData) {
434 uint8_t data[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
435
436 tNFA_STATUS status = NFA_EeSendData(NFC_DH_ID, sizeof(data), nullptr);
437 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
438 }
439
TEST_F(NfaEeApiTest,NFA_EeSendDataToHost)440 TEST_F(NfaEeApiTest, NFA_EeSendDataToHost) {
441 memset(&nfa_ee_cb, 0, sizeof(nfa_ee_cb));
442 nfa_ee_cb.ecb[NFA_EE_CB_4_DH].conn_st = NFA_EE_CONN_ST_CONN;
443 uint8_t data[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
444 uint8_t data_len = sizeof(data);
445 tNFA_EE_API_SEND_DATA* p_msg = (tNFA_EE_API_SEND_DATA*)malloc(
446 (uint16_t)(sizeof(tNFA_EE_API_SEND_DATA) + data_len));
447
448 EXPECT_CALL(*((MockGkiUtils*)gki_utils),
449 getbuf((uint16_t)(sizeof(tNFA_EE_API_SEND_DATA) + data_len)))
450 .WillOnce(testing::Return(p_msg));
451 tNFA_STATUS status = NFA_EeSendData(NFC_DH_ID, sizeof(data), data);
452
453 free(p_msg);
454 EXPECT_EQ(status, NFA_STATUS_OK);
455 }
456
457 // Tests for NFA_EeDisconnect
TEST_F(NfaEeApiTest,NFA_EeDisconnectInvalidEe)458 TEST_F(NfaEeApiTest, NFA_EeDisconnectInvalidEe) {
459 tNFA_STATUS status = NFA_EeDisconnect(0xff);
460 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
461 }
462
TEST_F(NfaEeApiTest,NFA_EeDisconnectHost)463 TEST_F(NfaEeApiTest, NFA_EeDisconnectHost) {
464 memset(&nfa_ee_cb, 0, sizeof(nfa_ee_cb));
465 nfa_ee_cb.ecb[NFA_EE_CB_4_DH].conn_st = NFA_EE_CONN_ST_CONN;
466 tNFA_EE_API_DISCONNECT* p_msg =
467 (tNFA_EE_API_DISCONNECT*)malloc(sizeof(tNFA_EE_API_DISCONNECT));
468
469 EXPECT_CALL(*((MockGkiUtils*)gki_utils),
470 getbuf(sizeof(tNFA_EE_API_DISCONNECT)))
471 .WillOnce(testing::Return(p_msg));
472 tNFA_STATUS status = NFA_EeDisconnect(NFC_DH_ID);
473
474 free(p_msg);
475 EXPECT_EQ(status, NFA_STATUS_OK);
476 }
477
478 // Tests for NFA_EePowerAndLinkCtrl
TEST_F(NfaEeApiTest,NFA_EePowerAndLinkCtrlInvalidEe)479 TEST_F(NfaEeApiTest, NFA_EePowerAndLinkCtrlInvalidEe) {
480 tNFA_STATUS status = NFA_EePowerAndLinkCtrl(0xff, 0x01);
481 EXPECT_EQ(status, NFA_STATUS_INVALID_PARAM);
482 }
483
TEST_F(NfaEeApiTest,NFA_EePowerAndLinkCtrlHost)484 TEST_F(NfaEeApiTest, NFA_EePowerAndLinkCtrlHost) {
485 memset(&nfa_ee_cb, 0, sizeof(nfa_ee_cb));
486 nfa_ee_cb.ecb[NFA_EE_CB_4_DH].ee_status = NFA_EE_STATUS_ACTIVE;
487 tNFA_EE_API_PWR_AND_LINK_CTRL* p_msg = (tNFA_EE_API_PWR_AND_LINK_CTRL*)malloc(
488 sizeof(tNFA_EE_API_PWR_AND_LINK_CTRL));
489
490 EXPECT_CALL(*((MockGkiUtils*)gki_utils),
491 getbuf(sizeof(tNFA_EE_API_PWR_AND_LINK_CTRL)))
492 .WillOnce(testing::Return(p_msg));
493 tNFA_STATUS status = NFA_EePowerAndLinkCtrl(NFC_DH_ID, 0x01);
494
495 free(p_msg);
496 EXPECT_EQ(status, NFA_STATUS_OK);
497 }
498
499 // Tests for NFA_EeClearRoutingTable
TEST_F(NfaEeApiTest,NFA_EeClearRoutingTable)500 TEST_F(NfaEeApiTest, NFA_EeClearRoutingTable) {
501 tNFA_EE_API_CLEAR_ROUTING_TABLE* p_msg =
502 (tNFA_EE_API_CLEAR_ROUTING_TABLE*)malloc(
503 sizeof(tNFA_EE_API_CLEAR_ROUTING_TABLE));
504
505 EXPECT_CALL(*((MockGkiUtils*)gki_utils),
506 getbuf(sizeof(tNFA_EE_API_CLEAR_ROUTING_TABLE)))
507 .WillOnce(testing::Return(p_msg));
508 tNFA_STATUS status = NFA_EeClearRoutingTable(true, true, true);
509 EXPECT_EQ(status, NFA_STATUS_OK);
510 }
511