1 //
2 // Copyright (C) 2024 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 #include <gtest/gtest.h>
17 #include <gmock/gmock.h>
18 #include <cstring>
19 #include "nfa_dm_ndef.cc"
20 class MockNDEFHandler {
21 public:
22 MOCK_METHOD(void, OnNDEFData, (uint8_t event, tNFA_NDEF_EVT_DATA* data));
23 uint8_t flags;
24 };
NDEFCallbackBridge(uint8_t event,tNFA_NDEF_EVT_DATA * data)25 static void NDEFCallbackBridge(uint8_t event, tNFA_NDEF_EVT_DATA* data) {
26 extern MockNDEFHandler* g_mock_handler;
27 if (g_mock_handler) {
28 g_mock_handler->OnNDEFData(event, data);
29 }
30 }
31 MockNDEFHandler* g_mock_handler = nullptr;
32 class NfaDmTest : public ::testing::Test {
33 protected:
34 tNFA_DM_CB nfa_dm_cb_mock;
35 MockNDEFHandler mock_handler;
36 MockNDEFHandler mock_handler1;
37 MockNDEFHandler mock_handler2;
SetUp()38 void SetUp() override {
39 memset(&nfa_dm_cb_mock, 0, sizeof(nfa_dm_cb_mock));
40 g_mock_handler = &mock_handler;
41 nfa_dm_cb_mock.p_ndef_handler[0] = reinterpret_cast<
42 tNFA_DM_API_REG_NDEF_HDLR*>(&mock_handler1);
43 nfa_dm_cb_mock.p_ndef_handler[1] = reinterpret_cast<
44 tNFA_DM_API_REG_NDEF_HDLR*>(&mock_handler2);
45 }
TearDown()46 void TearDown() override {
47 g_mock_handler = nullptr;
48 testing::Mock::VerifyAndClearExpectations(&mock_handler);
49 }
50 };
51
52 // nfa_dm_ndef_reg_hdlr
53
TEST_F(NfaDmTest,RegisterHandler_Success)54 TEST_F(NfaDmTest, RegisterHandler_Success) {
55 tNFA_DM_API_REG_NDEF_HDLR reg_info = {};
56 reg_info.p_ndef_cback = NDEFCallbackBridge;
57 reg_info.tnf = NFA_TNF_DEFAULT;
58 reg_info.name_len = 4;
59 EXPECT_CALL(mock_handler, OnNDEFData('\0', ::testing::_)).Times(1);
60 uint8_t name[] = "Test";
61 memcpy(reg_info.name, name, reg_info.name_len);
62 bool result = nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info);
63 EXPECT_FALSE(result);
64 }
65
TEST_F(NfaDmTest,RegisterHandler_ReplaceExisting)66 TEST_F(NfaDmTest, RegisterHandler_ReplaceExisting) {
67 tNFA_DM_API_REG_NDEF_HDLR reg_info1 = {};
68 reg_info1.p_ndef_cback = NDEFCallbackBridge;
69 reg_info1.tnf = NFA_TNF_DEFAULT;
70 reg_info1.name_len = 5;
71 uint8_t name1[] = "Test1";
72 memcpy(reg_info1.name, name1, reg_info1.name_len);
73 EXPECT_CALL(mock_handler, OnNDEFData(::testing::_, ::testing::_)).Times(1);
74 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info1);
75 tNFA_DM_API_REG_NDEF_HDLR reg_info2 = {};
76 reg_info2.p_ndef_cback = NDEFCallbackBridge;
77 reg_info2.tnf = NFA_TNF_DEFAULT;
78 reg_info2.name_len = 5;
79 EXPECT_CALL(mock_handler, OnNDEFData(::testing::_, ::testing::_)).Times(1);
80 uint8_t name2[] = "Test2";
81 memcpy(reg_info2.name, name2, reg_info2.name_len);
82 bool result = nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info2);
83 EXPECT_FALSE(result);
84 }
85
86 //nfa_dm_ndef_dereg_hdlr
87
TEST_F(NfaDmTest,DeregisterHandler_Success)88 TEST_F(NfaDmTest, DeregisterHandler_Success) {
89 tNFA_DM_API_REG_NDEF_HDLR reg_info = {};
90 reg_info.p_ndef_cback = NDEFCallbackBridge;
91 reg_info.tnf = NFA_TNF_DEFAULT;
92 reg_info.name_len = 5;
93 uint8_t name[] = "Test";
94 memcpy(reg_info.name, name, reg_info.name_len);
95 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info);
96 EXPECT_CALL(mock_handler, OnNDEFData(::testing::_, ::testing::_)).Times(0);
97 bool result = nfa_dm_ndef_dereg_hdlr((tNFA_DM_MSG*)®_info);
98 std::cout << "Deregistration result: " << (result ? "Success" : "Failure") << std::endl;
99 EXPECT_TRUE(result);
100 }
101
TEST_F(NfaDmTest,DeregisterHandler_Fail_HandlerNotRegistered)102 TEST_F(NfaDmTest, DeregisterHandler_Fail_HandlerNotRegistered) {
103 tNFA_DM_API_REG_NDEF_HDLR reg_info = {};
104 reg_info.p_ndef_cback = NDEFCallbackBridge;
105 reg_info.tnf = NFA_TNF_DEFAULT;
106 reg_info.name_len = 5;
107 uint8_t name[] = "Test";
108 memcpy(reg_info.name, name, reg_info.name_len);
109 bool result = nfa_dm_ndef_dereg_hdlr((tNFA_DM_MSG*)®_info);
110 EXPECT_TRUE(result);
111 }
112
TEST_F(NfaDmTest,DeregisterHandler_ReleaseSlot)113 TEST_F(NfaDmTest, DeregisterHandler_ReleaseSlot) {
114 tNFA_DM_API_REG_NDEF_HDLR reg_info1 = {};
115 reg_info1.p_ndef_cback = NDEFCallbackBridge;
116 reg_info1.tnf = NFA_TNF_DEFAULT;
117 reg_info1.name_len = 5;
118 uint8_t name1[] = "Test1";
119 memcpy(reg_info1.name, name1, reg_info1.name_len);
120 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info1);
121 bool result1 = nfa_dm_ndef_dereg_hdlr((tNFA_DM_MSG*)®_info1);
122 EXPECT_TRUE(result1);
123 tNFA_DM_API_REG_NDEF_HDLR reg_info2 = {};
124 reg_info2.p_ndef_cback = NDEFCallbackBridge;
125 reg_info2.tnf = NFA_TNF_DEFAULT;
126 reg_info2.name_len = 5;
127 uint8_t name2[] = "Test2";
128 memcpy(reg_info2.name, name2, reg_info2.name_len);
129 bool result2 = nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info2);
130 EXPECT_FALSE(result2);
131 }
TEST_F(NfaDmTest,DeregisterHandler_AllSlotsOccupied)132 TEST_F(NfaDmTest, DeregisterHandler_AllSlotsOccupied) {
133 for (int i = 0; i < NFA_NDEF_MAX_HANDLERS; ++i) {
134 tNFA_DM_API_REG_NDEF_HDLR reg_info = {};
135 reg_info.p_ndef_cback = NDEFCallbackBridge;
136 reg_info.tnf = NFA_TNF_DEFAULT;
137 reg_info.name_len = 4;
138 uint8_t name[] = "Test";
139 memcpy(reg_info.name, name, reg_info.name_len);
140 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info);
141 }
142 tNFA_DM_API_REG_NDEF_HDLR reg_info_to_deregister = {};
143 reg_info_to_deregister.p_ndef_cback = NDEFCallbackBridge;
144 reg_info_to_deregister.tnf = NFA_TNF_DEFAULT;
145 reg_info_to_deregister.name_len = 4;
146 uint8_t name_to_deregister[] = "Test";
147 memcpy(reg_info_to_deregister.name, name_to_deregister, reg_info_to_deregister.name_len);
148 bool result = nfa_dm_ndef_dereg_hdlr((tNFA_DM_MSG*)®_info_to_deregister);
149 EXPECT_TRUE(result);
150 tNFA_DM_API_REG_NDEF_HDLR reg_info_new = {};
151 reg_info_new.p_ndef_cback = NDEFCallbackBridge;
152 reg_info_new.tnf = NFA_TNF_DEFAULT;
153 reg_info_new.name_len = 4;
154 uint8_t name_new[] = "New";
155 memcpy(reg_info_new.name, name_new, reg_info_new.name_len);
156 bool result_new = nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info_new);
157 EXPECT_FALSE(result_new);
158 }
159
160 //nfa_dm_ndef_handle_message
161
TEST_F(NfaDmTest,HandleMessage_RegisteredHandler)162 TEST_F(NfaDmTest, HandleMessage_RegisteredHandler) {
163 tNFA_DM_API_REG_NDEF_HDLR reg_info = {};
164 reg_info.p_ndef_cback = NDEFCallbackBridge;
165 reg_info.tnf = NFA_TNF_DEFAULT;
166 reg_info.name_len = 5;
167 uint8_t name[] = "Test";
168 memcpy(reg_info.name, name, reg_info.name_len);
169 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info);
170 uint8_t event = 1;
171 tNFA_NDEF_EVT_DATA event_data = {};
172 EXPECT_CALL(mock_handler, OnNDEFData(::testing::_, ::testing::_)).Times(0);
173 uint8_t msg_buf[sizeof(tNFA_NDEF_EVT_DATA)];
174 memcpy(msg_buf, &event_data, sizeof(tNFA_NDEF_EVT_DATA));
175 uint32_t len = sizeof(tNFA_NDEF_EVT_DATA);
176 tNFA_STATUS status = NFA_STATUS_OK;
177 nfa_dm_ndef_handle_message(status, msg_buf, len);
178 }
179
TEST_F(NfaDmTest,HandleMessage_UnregisteredHandler)180 TEST_F(NfaDmTest, HandleMessage_UnregisteredHandler) {
181 uint8_t event = 1;
182 tNFA_NDEF_EVT_DATA event_data = {};
183 uint8_t msg_buf[sizeof(tNFA_NDEF_EVT_DATA)];
184 memcpy(msg_buf, &event_data, sizeof(tNFA_NDEF_EVT_DATA));
185 EXPECT_CALL(mock_handler, OnNDEFData(event, &event_data)).Times(0);
186 uint32_t len = sizeof(tNFA_NDEF_EVT_DATA);
187 tNFA_STATUS status = NFA_STATUS_OK;
188 nfa_dm_ndef_handle_message(status, msg_buf, len);
189 }
190
TEST_F(NfaDmTest,HandleMessage_InvalidEvent)191 TEST_F(NfaDmTest, HandleMessage_InvalidEvent) {
192 tNFA_DM_API_REG_NDEF_HDLR reg_info = {};
193 reg_info.p_ndef_cback = NDEFCallbackBridge;
194 reg_info.tnf = NFA_TNF_DEFAULT;
195 reg_info.name_len = 5;
196 uint8_t name[] = "Test";
197 memcpy(reg_info.name, name, reg_info.name_len);
198 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info);
199 uint8_t invalid_event = 99;
200 tNFA_NDEF_EVT_DATA event_data = {};
201 uint8_t msg_buf[sizeof(tNFA_NDEF_EVT_DATA)];
202 memcpy(msg_buf, &event_data, sizeof(tNFA_NDEF_EVT_DATA));
203 EXPECT_CALL(mock_handler, OnNDEFData(invalid_event, &event_data)).Times(0);
204 uint32_t len = sizeof(tNFA_NDEF_EVT_DATA);
205 tNFA_STATUS status = NFA_STATUS_OK;
206 nfa_dm_ndef_handle_message(status, msg_buf, len);
207 }
208
TEST_F(NfaDmTest,HandleMessage_CallbackInvocation)209 TEST_F(NfaDmTest, HandleMessage_CallbackInvocation) {
210 tNFA_DM_API_REG_NDEF_HDLR reg_info = {};
211 reg_info.p_ndef_cback = NDEFCallbackBridge;
212 reg_info.tnf = NFA_TNF_DEFAULT;
213 reg_info.name_len = 5;
214 uint8_t name[] = "Test";
215 memcpy(reg_info.name, name, reg_info.name_len);
216 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info);
217 uint8_t event = 2;
218 tNFA_NDEF_EVT_DATA event_data = {};
219 EXPECT_CALL(mock_handler, OnNDEFData(::testing::_, ::testing::_)).Times(0);
220 uint8_t msg_buf[sizeof(tNFA_NDEF_EVT_DATA)];
221 memcpy(msg_buf, &event_data, sizeof(tNFA_NDEF_EVT_DATA));
222 uint32_t len = sizeof(tNFA_NDEF_EVT_DATA);
223 tNFA_STATUS status = NFA_STATUS_OK;
224 nfa_dm_ndef_handle_message(status, msg_buf, len);
225 }
226
TEST_F(NfaDmTest,HandleMultipleMessages)227 TEST_F(NfaDmTest, HandleMultipleMessages) {
228 tNFA_DM_API_REG_NDEF_HDLR reg_info = {};
229 reg_info.p_ndef_cback = NDEFCallbackBridge;
230 reg_info.tnf = NFA_TNF_DEFAULT;
231 reg_info.name_len = 5;
232 uint8_t name[] = "Test";
233 memcpy(reg_info.name, name, reg_info.name_len);
234 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info);
235 uint8_t event1 = 1, event2 = 2;
236 tNFA_NDEF_EVT_DATA event_data1 = {};
237 tNFA_NDEF_EVT_DATA event_data2 = {};
238 uint8_t msg_buf1[sizeof(tNFA_NDEF_EVT_DATA)];
239 uint8_t msg_buf2[sizeof(tNFA_NDEF_EVT_DATA)];
240 memcpy(msg_buf1, &event_data1, sizeof(tNFA_NDEF_EVT_DATA));
241 memcpy(msg_buf2, &event_data2, sizeof(tNFA_NDEF_EVT_DATA));
242 EXPECT_CALL(mock_handler, OnNDEFData(event1, &event_data1)).Times(0);
243 EXPECT_CALL(mock_handler, OnNDEFData(event2, &event_data2)).Times(0);
244 uint32_t len = sizeof(tNFA_NDEF_EVT_DATA);
245 tNFA_STATUS status = NFA_STATUS_OK;
246 nfa_dm_ndef_handle_message(status, msg_buf1, len);
247 nfa_dm_ndef_handle_message(status, msg_buf2, len);
248 }
249
250 //nfa_dm_ndef_find_next_handler
251
TEST_F(NfaDmTest,FindNextHandler_Success)252 TEST_F(NfaDmTest, FindNextHandler_Success) {
253 tNFA_DM_API_REG_NDEF_HDLR reg_info1 = {};
254 reg_info1.p_ndef_cback = NDEFCallbackBridge;
255 reg_info1.tnf = NFA_TNF_DEFAULT;
256 reg_info1.name_len = 5;
257 uint8_t name1[] = "Test1";
258 memcpy(reg_info1.name, name1, reg_info1.name_len);
259 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info1);
260 tNFA_DM_API_REG_NDEF_HDLR reg_info2 = {};
261 reg_info2.p_ndef_cback = NDEFCallbackBridge;
262 reg_info2.tnf = NFA_TNF_DEFAULT;
263 reg_info2.name_len = 5;
264 uint8_t name2[] = "Test2";
265 memcpy(reg_info2.name, name2, reg_info2.name_len);
266 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info2);
267 unsigned char event = 1;
268 unsigned char* p_name = nullptr;
269 unsigned char name_len = 0;
270 unsigned char* p_tnf = nullptr;
271 unsigned int index = 0;
272 bool result = nfa_dm_ndef_find_next_handler(
273 (tNFA_DM_API_REG_NDEF_HDLR*)®_info1, event, p_name, name_len, p_tnf, index);
274 EXPECT_FALSE(result);
275 result = nfa_dm_ndef_find_next_handler(
276 (tNFA_DM_API_REG_NDEF_HDLR*)®_info2, event, p_name, name_len, p_tnf, index);
277 EXPECT_FALSE(result);
278 }
279
TEST_F(NfaDmTest,FindNextHandler_NoHandler)280 TEST_F(NfaDmTest, FindNextHandler_NoHandler) {
281 unsigned char event = 1;
282 unsigned char* p_name = nullptr;
283 unsigned char name_len = 0;
284 unsigned char* p_tnf = nullptr;
285 unsigned int index = 0;
286 tNFA_DM_API_REG_NDEF_HDLR* found_handler = nullptr;
287 bool result = nfa_dm_ndef_find_next_handler(nullptr, event, p_name, name_len, p_tnf, index);
288 EXPECT_FALSE(result);
289 }
290
TEST_F(NfaDmTest,FindNextHandler_NoMatch)291 TEST_F(NfaDmTest, FindNextHandler_NoMatch) {
292 tNFA_DM_API_REG_NDEF_HDLR reg_info1 = {};
293 reg_info1.p_ndef_cback = NDEFCallbackBridge;
294 reg_info1.tnf = NFA_TNF_DEFAULT;
295 reg_info1.name_len = 5;
296 uint8_t name1[] = "Test1";
297 memcpy(reg_info1.name, name1, reg_info1.name_len);
298 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info1);
299 unsigned char event = 1;
300 unsigned char* p_name = (unsigned char*)"NonMatchingName";
301 unsigned char name_len = 15;
302 unsigned char* p_tnf = nullptr;
303 unsigned int index = 0;
304 tNFA_DM_API_REG_NDEF_HDLR* found_handler = nullptr;
305 bool result = nfa_dm_ndef_find_next_handler(
306 (tNFA_DM_API_REG_NDEF_HDLR*)®_info1, event, p_name, name_len, p_tnf, index);
307 EXPECT_FALSE(result);
308 }
309
TEST_F(NfaDmTest,FindNextHandler_InvalidEvent)310 TEST_F(NfaDmTest, FindNextHandler_InvalidEvent) {
311 tNFA_DM_API_REG_NDEF_HDLR reg_info1 = {};
312 reg_info1.p_ndef_cback = NDEFCallbackBridge;
313 reg_info1.tnf = NFA_TNF_DEFAULT;
314 reg_info1.name_len = 5;
315 uint8_t name1[] = "Test1";
316 memcpy(reg_info1.name, name1, reg_info1.name_len);
317 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info1);
318 unsigned char invalid_event = 99;
319 unsigned char* p_name = nullptr;
320 unsigned char name_len = 0;
321 unsigned char* p_tnf = nullptr;
322 unsigned int index = 0;
323 tNFA_DM_API_REG_NDEF_HDLR* found_handler = nullptr;
324 bool result = nfa_dm_ndef_find_next_handler(
325 (tNFA_DM_API_REG_NDEF_HDLR*)®_info1, invalid_event, p_name, name_len, p_tnf, index);
326 EXPECT_FALSE(result);
327 }
328
329 //nfa_dm_ndef_find_next_handler
330
TEST_F(NfaDmTest,DeregisterHandle_Success)331 TEST_F(NfaDmTest, DeregisterHandle_Success) {
332 tNFA_DM_API_REG_NDEF_HDLR reg_info = {};
333 reg_info.p_ndef_cback = NDEFCallbackBridge;
334 reg_info.tnf = NFA_TNF_DEFAULT;
335 reg_info.name_len = 5;
336 uint8_t name[] = "Test";
337 memcpy(reg_info.name, name, reg_info.name_len);
338 bool result = nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info);
339 EXPECT_FALSE(result);
340 tNFA_HANDLE handler_handle = reg_info.ndef_type_handle;
341 nfa_dm_ndef_dereg_hdlr_by_handle(handler_handle);
342 tNFA_DM_API_REG_NDEF_HDLR* found_handler = nullptr;
343 result = nfa_dm_ndef_find_next_handler(
344 (tNFA_DM_API_REG_NDEF_HDLR*)®_info, 0, nullptr, 0, nullptr, 0);
345 EXPECT_FALSE(result);
346 }
347
TEST_F(NfaDmTest,DeregisterHandler_Fail_InvalidHandle)348 TEST_F(NfaDmTest, DeregisterHandler_Fail_InvalidHandle) {
349 tNFA_DM_API_REG_NDEF_HDLR reg_info = {};
350 reg_info.p_ndef_cback = NDEFCallbackBridge;
351 reg_info.tnf = NFA_TNF_DEFAULT;
352 reg_info.name_len = 5;
353 uint8_t name[] = "Test";
354 memcpy(reg_info.name, name, reg_info.name_len);
355 bool result = nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info);
356 EXPECT_FALSE(result);
357 tNFA_HANDLE invalid_handle = 0;
358 nfa_dm_ndef_dereg_hdlr_by_handle(invalid_handle);
359 tNFA_DM_API_REG_NDEF_HDLR* found_handler = nullptr;
360 result = nfa_dm_ndef_find_next_handler(
361 (tNFA_DM_API_REG_NDEF_HDLR*)®_info, 0, nullptr, 0, nullptr, 0);
362 EXPECT_FALSE(result);
363 }
364
TEST_F(NfaDmTest,DeregisterHandler_MultipleHandlers)365 TEST_F(NfaDmTest, DeregisterHandler_MultipleHandlers) {
366 tNFA_DM_API_REG_NDEF_HDLR reg_info1 = {};
367 reg_info1.p_ndef_cback = NDEFCallbackBridge;
368 reg_info1.tnf = NFA_TNF_DEFAULT;
369 reg_info1.name_len = 5;
370 uint8_t name1[] = "Test1";
371 memcpy(reg_info1.name, name1, reg_info1.name_len);
372 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info1);
373 tNFA_DM_API_REG_NDEF_HDLR reg_info2 = {};
374 reg_info2.p_ndef_cback = NDEFCallbackBridge;
375 reg_info2.tnf = NFA_TNF_DEFAULT;
376 reg_info2.name_len = 5;
377 uint8_t name2[] = "Test2";
378 memcpy(reg_info2.name, name2, reg_info2.name_len);
379 nfa_dm_ndef_reg_hdlr((tNFA_DM_MSG*)®_info2);
380 tNFA_HANDLE handle1 = reg_info1.ndef_type_handle;
381 tNFA_HANDLE handle2 = reg_info2.ndef_type_handle;
382 nfa_dm_ndef_dereg_hdlr_by_handle(handle1);
383 tNFA_DM_API_REG_NDEF_HDLR* found_handler = nullptr;
384 bool result = nfa_dm_ndef_find_next_handler(
385 (tNFA_DM_API_REG_NDEF_HDLR*)®_info1, 0, nullptr, 0, nullptr, 0);
386 EXPECT_FALSE(result);
387 result = nfa_dm_ndef_find_next_handler(
388 (tNFA_DM_API_REG_NDEF_HDLR*)®_info2, 0, nullptr, 0, nullptr, 0);
389 EXPECT_FALSE(result);
390 }
391
392 // nfa_dm_ndef_clear_notified_flag
393
TEST_F(NfaDmTest,ClearNotifiedFlag_Success)394 TEST_F(NfaDmTest, ClearNotifiedFlag_Success) {
395 mock_handler1.flags |= NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED;
396 mock_handler2.flags |= NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED;
397 nfa_dm_ndef_clear_notified_flag();
398 EXPECT_TRUE(mock_handler1.flags & NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED);
399 EXPECT_TRUE(mock_handler2.flags & NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED);
400 }
401
TEST_F(NfaDmTest,ClearNotifiedFlag_AlreadyClear)402 TEST_F(NfaDmTest, ClearNotifiedFlag_AlreadyClear) {
403 mock_handler1.flags &= ~NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED;
404 mock_handler2.flags &= ~NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED;
405 nfa_dm_ndef_clear_notified_flag();
406 EXPECT_FALSE(mock_handler1.flags & NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED);
407 EXPECT_FALSE(mock_handler2.flags & NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED);
408 }
409
TEST_F(NfaDmTest,ClearNotifiedFlag_OnlyRegisteredHandlers)410 TEST_F(NfaDmTest, ClearNotifiedFlag_OnlyRegisteredHandlers) {
411 mock_handler1.flags |= NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED;
412 nfa_dm_ndef_clear_notified_flag();
413 EXPECT_TRUE(mock_handler1.flags & NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED);
414 EXPECT_FALSE(mock_handler2.flags & NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED);
415 }
416
TEST_F(NfaDmTest,ClearNotifiedFlag_NoHandlers)417 TEST_F(NfaDmTest, ClearNotifiedFlag_NoHandlers) {
418 nfa_dm_cb_mock.p_ndef_handler[0] = nullptr;
419 nfa_dm_cb_mock.p_ndef_handler[1] = nullptr;
420 nfa_dm_ndef_clear_notified_flag();
421 EXPECT_FALSE(mock_handler1.flags & NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED);
422 EXPECT_FALSE(mock_handler2.flags & NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED);
423 }
424
TEST_F(NfaDmTest,ClearNotifiedFlag_MultipleCalls)425 TEST_F(NfaDmTest, ClearNotifiedFlag_MultipleCalls) {
426 mock_handler1.flags |= NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED;
427 mock_handler2.flags |= NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED;
428 nfa_dm_ndef_clear_notified_flag();
429 nfa_dm_ndef_clear_notified_flag();
430 EXPECT_TRUE(mock_handler1.flags & NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED);
431 EXPECT_TRUE(mock_handler2.flags & NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED);
432 }
433