1 /*
2 * Copyright (c) 2024 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 "nfc_impl.h"
17 #include <hdf_base.h>
18 #include <hdf_log.h>
19 #include <vector>
20 #include "nfc_vendor_adaptions.h"
21 #include <gtest/gtest.h>
22 #include <hdf_device_desc.h>
23 #include <hdf_sbuf_ipc.h>
24 #include "v1_0/infc_interface.h"
25 #include "v1_0/nfc_types.h"
26 #include "nfc_chip_type_parser.h"
27
28 typedef uint8_t tHAL_NFC_STATUS;
29 typedef void(tHAL_NFC_STATUS_CBACK)(tHAL_NFC_STATUS status);
30 typedef void(tHAL_NFC_CBACK)(uint8_t event, tHAL_NFC_STATUS status);
31 typedef void(tHAL_NFC_DATA_CBACK)(uint16_t data_len, uint8_t* p_data);
32
33 using namespace OHOS::HDI::Nfc::V1_0;
34 using namespace testing::ext;
35 using namespace std;
36 using namespace OHOS::HDI::Nfc;
37 using INfcV1_0 = OHOS::HDI::Nfc::V1_0::INfcInterface;
38 using OHOS::HDI::Nfc::V1_0::NfcStatus;
39 using OHOS::HDI::Nfc::V1_0::NfcEvent;
40 using OHOS::HDI::Nfc::V1_0::INfcCallback;
41 using OHOS::NFC::NfcChipTypeParser;
42
43 namespace {
44 OHOS::sptr<INfcV1_0> mHal = nullptr;
45 OHOS::sptr<V1_0::INfcCallback> g_callbackV1_0 = nullptr;
46 OHOS::sptr<INfcCallback> mCallback = nullptr;
47 } // namespace
48
49 class NfcClientCallback : public INfcCallback {
50 public:
NfcClientCallback()51 NfcClientCallback() {}
~NfcClientCallback()52 virtual ~NfcClientCallback() {}
NfcClientCallback(tHAL_NFC_CBACK * eventCallback,tHAL_NFC_DATA_CBACK dataCallback)53 NfcClientCallback(tHAL_NFC_CBACK *eventCallback, tHAL_NFC_DATA_CBACK dataCallback)
54 {
55 mEventCallback = eventCallback;
56 mDataCallback = dataCallback;
57 };
58
OnData(const std::vector<uint8_t> & data)59 int32_t OnData(const std::vector<uint8_t> &data) override
60 {
61 if (mDataCallback != nullptr && !data.empty()) {
62 mDataCallback(data.size(), (uint8_t *)&data[0]);
63 }
64 return HDF_SUCCESS;
65 }
66
OnEvent(NfcEvent event,NfcStatus status)67 int32_t OnEvent(NfcEvent event, NfcStatus status) override
68 {
69 if (mEventCallback != nullptr) {
70 mEventCallback((uint8_t)event, (tHAL_NFC_STATUS)status);
71 }
72 return HDF_SUCCESS;
73 }
74
75 private:
76 tHAL_NFC_CBACK *mEventCallback;
77 tHAL_NFC_DATA_CBACK *mDataCallback;
78 };
79
80 class HdfNfcHdiTestAdditional : public testing::Test {
81 public:
82 static void SetUpTestCase();
83 static void TearDownTestCase();
84 void SetUp();
85 void TearDown();
86 };
SetUpTestCase()87 void HdfNfcHdiTestAdditional::SetUpTestCase() { mHal = INfcV1_0::Get(); }
TearDownTestCase()88 void HdfNfcHdiTestAdditional::TearDownTestCase() {}
SetUp()89 void HdfNfcHdiTestAdditional::SetUp() {}
TearDown()90 void HdfNfcHdiTestAdditional::TearDown() {}
91
EventCallback(uint8_t event,uint8_t status)92 static void EventCallback(uint8_t event, uint8_t status)
93 {
94 if (g_callbackV1_0 != nullptr) {
95 printf("EventCallback:%d,%d", event, status);
96 }
97 }
98
DataCallback(uint16_t len,uint8_t * data)99 static void DataCallback(uint16_t len, uint8_t *data)
100 {
101 if (g_callbackV1_0 != nullptr) {
102 printf("DataCallback:%d,%d", len, data[0]);
103 }
104 }
105
106 /**
107 * @tc.number : SUB_Communication_Nfc_Open_0200
108 * @tc.name : testOpen001
109 * @tc.desc : The first parameter is nullptr
110 */
111 HWTEST_F(HdfNfcHdiTestAdditional, testOpen001, Function | MediumTest | Level2)
112 {
113 if (!NfcChipTypeParser::IsSupportedChipType()) {
114 EXPECT_EQ(HDF_SUCCESS, 0);
115 } else {
116 if (mHal == nullptr) {
117 ASSERT_NE(nullptr, mHal);
118 return;
119 }
120 mCallback = new NfcClientCallback(EventCallback, DataCallback);
121 if (mCallback == nullptr) {
122 ASSERT_NE(nullptr, mCallback);
123 return;
124 }
125 NfcStatus nfcbtType = NfcStatus::OK;
126 int32_t ret = 0;
127 ret = mHal->Open(nullptr, nfcbtType);
128 EXPECT_NE(HDF_SUCCESS, ret);
129 }
130 }
131
132 /**
133 * @tc.number : SUB_Communication_Nfc_Close_0200
134 * @tc.name : testClose001
135 * @tc.desc : stability test
136 */
137 HWTEST_F(HdfNfcHdiTestAdditional, testClose001, Function | MediumTest | Level1)
138 {
139 if (!NfcChipTypeParser::IsSupportedChipType()) {
140 EXPECT_EQ(HDF_SUCCESS, 0);
141 } else {
142 if (mHal == nullptr) {
143 ASSERT_NE(nullptr, mHal);
144 return;
145 }
146 mCallback = new NfcClientCallback(EventCallback, DataCallback);
147 if (mCallback == nullptr) {
148 ASSERT_NE(nullptr, mCallback);
149 return;
150 }
151 NfcStatus nfcbtType = NfcStatus::OK;
152 int32_t ret = 0;
153 for (int i = 0; i < 1000; i++) {
154 ret = mHal->Open(mCallback, nfcbtType);
155 EXPECT_EQ(HDF_SUCCESS, ret);
156 ret = mHal->Close(nfcbtType);
157 EXPECT_EQ(HDF_SUCCESS, ret);
158 }
159 }
160 }
161
162 /**
163 * @tc.number : SUB_Communication_Nfc_CoreInitialized_0200
164 * @tc.name : testCoreInitialized001
165 * @tc.desc : The first parameter is an array (1,1)
166 */
167 HWTEST_F(HdfNfcHdiTestAdditional, testCoreInitialized001, Function | MediumTest | Level1)
168 {
169 if (!NfcChipTypeParser::IsSupportedChipType()) {
170 EXPECT_EQ(HDF_SUCCESS, 0);
171 } else {
172 if (mHal == nullptr) {
173 ASSERT_NE(nullptr, mHal);
174 return;
175 }
176 mCallback = new NfcClientCallback(EventCallback, DataCallback);
177 if (mCallback == nullptr) {
178 ASSERT_NE(nullptr, mCallback);
179 return;
180 }
181 NfcStatus nfcbtType = NfcStatus::OK;
182 int32_t ret = 0;
183 ret = mHal->Open(mCallback, nfcbtType);
184 EXPECT_EQ(HDF_SUCCESS, ret);
185
186 std::vector<uint8_t> data(1, 1);
187 ret = mHal->CoreInitialized(data, nfcbtType);
188 EXPECT_EQ(HDF_SUCCESS, ret);
189
190 ret = mHal->Close(nfcbtType);
191 EXPECT_EQ(HDF_SUCCESS, ret);
192 }
193 }
194
195 /**
196 * @tc.number : SUB_Communication_Nfc_CoreInitialized_0300
197 * @tc.name : testCoreInitialized002
198 * @tc.desc : The first parameter is an array (255,1)
199 */
200 HWTEST_F(HdfNfcHdiTestAdditional, testCoreInitialized002, Function | MediumTest | Level1)
201 {
202 if (!NfcChipTypeParser::IsSupportedChipType()) {
203 EXPECT_EQ(HDF_SUCCESS, 0);
204 } else {
205 if (mHal == nullptr) {
206 ASSERT_NE(nullptr, mHal);
207 return;
208 }
209 mCallback = new NfcClientCallback(EventCallback, DataCallback);
210 if (mCallback == nullptr) {
211 ASSERT_NE(nullptr, mCallback);
212 return;
213 }
214 NfcStatus nfcbtType = NfcStatus::OK;
215 int32_t ret = 0;
216 ret = mHal->Open(mCallback, nfcbtType);
217 EXPECT_EQ(HDF_SUCCESS, ret);
218
219 std::vector<uint8_t> data(255, 1);
220 ret = mHal->CoreInitialized(data, nfcbtType);
221 EXPECT_EQ(HDF_SUCCESS, ret);
222
223 ret = mHal->Close(nfcbtType);
224 EXPECT_EQ(HDF_SUCCESS, ret);
225 }
226 }
227
228 /**
229 * @tc.number : SUB_Communication_Nfc_CoreInitialized_0400
230 * @tc.name : testCoreInitialized003
231 * @tc.desc : stability test
232 */
233 HWTEST_F(HdfNfcHdiTestAdditional, testCoreInitialized003, Function | MediumTest | Level1)
234 {
235 if (!NfcChipTypeParser::IsSupportedChipType()) {
236 EXPECT_EQ(HDF_SUCCESS, 0);
237 } else {
238 if (mHal == nullptr) {
239 ASSERT_NE(nullptr, mHal);
240 return;
241 }
242 mCallback = new NfcClientCallback(EventCallback, DataCallback);
243 if (mCallback == nullptr) {
244 ASSERT_NE(nullptr, mCallback);
245 return;
246 }
247 NfcStatus nfcbtType = NfcStatus::OK;
248 int32_t ret = 0;
249 ret = mHal->Open(mCallback, nfcbtType);
250 EXPECT_EQ(HDF_SUCCESS, ret);
251
252 for (int i = 0; i < 1000; i++) {
253 std::vector<uint8_t> data(1, 1);
254 ret = mHal->CoreInitialized(data, nfcbtType);
255 EXPECT_EQ(HDF_SUCCESS, ret);
256 }
257 ret = mHal->Close(nfcbtType);
258 EXPECT_EQ(HDF_SUCCESS, ret);
259 }
260 }
261
262 /**
263 * @tc.number : SUB_Communication_Nfc_Prediscover_0200
264 * @tc.name : testPrediscover001
265 * @tc.desc : stability test
266 */
267 HWTEST_F(HdfNfcHdiTestAdditional, testPrediscover001, Function | MediumTest | Level1)
268 {
269 if (!NfcChipTypeParser::IsSupportedChipType()) {
270 EXPECT_EQ(HDF_SUCCESS, 0);
271 } else {
272 if (mHal == nullptr) {
273 ASSERT_NE(nullptr, mHal);
274 return;
275 }
276 mCallback = new NfcClientCallback(EventCallback, DataCallback);
277 if (mCallback == nullptr) {
278 ASSERT_NE(nullptr, mCallback);
279 return;
280 }
281 NfcStatus nfcbtType = NfcStatus::OK;
282 int32_t ret = 0;
283 ret = mHal->Open(mCallback, nfcbtType);
284 EXPECT_EQ(HDF_SUCCESS, ret);
285
286 for (int i = 0; i < 1000; i++) {
287 ret = mHal->Prediscover(nfcbtType);
288 EXPECT_EQ(HDF_SUCCESS, ret);
289 }
290 ret = mHal->Close(nfcbtType);
291 EXPECT_EQ(HDF_SUCCESS, ret);
292 }
293 }
294
295 /**
296 * @tc.number : SUB_Communication_Nfc_Write_0200
297 * @tc.name : testWrite001
298 * @tc.desc : The first parameter is an array (1,1)
299 */
300 HWTEST_F(HdfNfcHdiTestAdditional, testWrite001, Function | MediumTest | Level1)
301 {
302 if (!NfcChipTypeParser::IsSupportedChipType()) {
303 EXPECT_EQ(HDF_SUCCESS, 0);
304 } else {
305 if (mHal == nullptr) {
306 ASSERT_NE(nullptr, mHal);
307 return;
308 }
309 mCallback = new NfcClientCallback(EventCallback, DataCallback);
310 if (mCallback == nullptr) {
311 ASSERT_NE(nullptr, mCallback);
312 return;
313 }
314 NfcStatus nfcbtType = NfcStatus::OK;
315 int32_t ret = 0;
316 ret = mHal->Open(mCallback, nfcbtType);
317 EXPECT_EQ(HDF_SUCCESS, ret);
318
319 std::vector<uint8_t> data(1, 1);
320 ret = mHal->Write(data, nfcbtType);
321 EXPECT_EQ(HDF_SUCCESS, ret);
322
323 ret = mHal->Close(nfcbtType);
324 EXPECT_EQ(HDF_SUCCESS, ret);
325 }
326 }
327
328 /**
329 * @tc.number : SUB_Communication_Nfc_Write_0300
330 * @tc.name : testWrite002
331 * @tc.desc : The first parameter is an array (255,1)
332 */
333 HWTEST_F(HdfNfcHdiTestAdditional, testWrite002, Function | MediumTest | Level1)
334 {
335 if (!NfcChipTypeParser::IsSupportedChipType()) {
336 EXPECT_EQ(HDF_SUCCESS, 0);
337 } else {
338 if (mHal == nullptr) {
339 ASSERT_NE(nullptr, mHal);
340 return;
341 }
342 mCallback = new NfcClientCallback(EventCallback, DataCallback);
343 if (mCallback == nullptr) {
344 ASSERT_NE(nullptr, mCallback);
345 return;
346 }
347 NfcStatus nfcbtType = NfcStatus::OK;
348 int32_t ret = 0;
349 ret = mHal->Open(mCallback, nfcbtType);
350 EXPECT_EQ(HDF_SUCCESS, ret);
351
352 std::vector<uint8_t> data(255, 1);
353 ret = mHal->Write(data, nfcbtType);
354 EXPECT_EQ(HDF_SUCCESS, ret);
355
356 ret = mHal->Close(nfcbtType);
357 EXPECT_EQ(HDF_SUCCESS, ret);
358 }
359 }
360
361 /**
362 * @tc.number : SUB_Communication_Nfc_Write_0400
363 * @tc.name : testWrite003
364 * @tc.desc : stability test
365 */
366 HWTEST_F(HdfNfcHdiTestAdditional, testWrite003, Function | MediumTest | Level1)
367 {
368 if (!NfcChipTypeParser::IsSupportedChipType()) {
369 EXPECT_EQ(HDF_SUCCESS, 0);
370 } else {
371 if (mHal == nullptr) {
372 ASSERT_NE(nullptr, mHal);
373 return;
374 }
375 mCallback = new NfcClientCallback(EventCallback, DataCallback);
376 if (mCallback == nullptr) {
377 ASSERT_NE(nullptr, mCallback);
378 return;
379 }
380 NfcStatus nfcbtType = NfcStatus::OK;
381 int32_t ret = 0;
382 ret = mHal->Open(mCallback, nfcbtType);
383 EXPECT_EQ(HDF_SUCCESS, ret);
384
385 for (int i = 0; i < 1000; i++) {
386 std::vector<uint8_t> data(1, 1);
387 ret = mHal->Write(data, nfcbtType);
388 EXPECT_EQ(HDF_SUCCESS, ret);
389 }
390 ret = mHal->Close(nfcbtType);
391 EXPECT_EQ(HDF_SUCCESS, ret);
392 }
393 }
394
395 /**
396 * @tc.number : SUB_Communication_Nfc_ControlGranted_0200
397 * @tc.name : testControlGranted001
398 * @tc.desc : stability test
399 */
400 HWTEST_F(HdfNfcHdiTestAdditional, testControlGranted001, Function | MediumTest | Level1)
401 {
402 if (!NfcChipTypeParser::IsSupportedChipType()) {
403 EXPECT_EQ(HDF_SUCCESS, 0);
404 } else {
405 if (mHal == nullptr) {
406 ASSERT_NE(nullptr, mHal);
407 return;
408 }
409 mCallback = new NfcClientCallback(EventCallback, DataCallback);
410 if (mCallback == nullptr) {
411 ASSERT_NE(nullptr, mCallback);
412 return;
413 }
414 NfcStatus nfcbtType = NfcStatus::OK;
415 int32_t ret = 0;
416 ret = mHal->Open(mCallback, nfcbtType);
417 EXPECT_EQ(HDF_SUCCESS, ret);
418
419 for (int i = 0; i < 1000; i++) {
420 ret = mHal->ControlGranted(nfcbtType);
421 EXPECT_EQ(HDF_SUCCESS, ret);
422 }
423 ret = mHal->Close(nfcbtType);
424 EXPECT_EQ(HDF_SUCCESS, ret);
425 }
426 }
427
428 /**
429 * @tc.number : SUB_Communication_Nfc_PowerCycle_0200
430 * @tc.name : testPowerCycle001
431 * @tc.desc : stability test
432 */
433 HWTEST_F(HdfNfcHdiTestAdditional, testPowerCycle001, Function | MediumTest | Level1)
434 {
435 if (!NfcChipTypeParser::IsSupportedChipType()) {
436 EXPECT_EQ(HDF_SUCCESS, 0);
437 } else {
438 if (mHal == nullptr) {
439 ASSERT_NE(nullptr, mHal);
440 return;
441 }
442 mCallback = new NfcClientCallback(EventCallback, DataCallback);
443 if (mCallback == nullptr) {
444 ASSERT_NE(nullptr, mCallback);
445 return;
446 }
447 NfcStatus nfcbtType = NfcStatus::OK;
448 int32_t ret = 0;
449 ret = mHal->Open(mCallback, nfcbtType);
450 EXPECT_EQ(HDF_SUCCESS, ret);
451
452 for (int i = 0; i < 1000; i++) {
453 ret = mHal->PowerCycle(nfcbtType);
454 EXPECT_EQ(HDF_SUCCESS, ret);
455 }
456 ret = mHal->Close(nfcbtType);
457 EXPECT_EQ(HDF_SUCCESS, ret);
458 }
459 }
460
461 /**
462 * @tc.number : SUB_Communication_Nfc_Ioctl_0200
463 * @tc.name : testIoctl001
464 * @tc.desc : The first parameter is an array (1,1)
465 */
466 HWTEST_F(HdfNfcHdiTestAdditional, testIoctl001, Function | MediumTest | Level1)
467 {
468 if (!NfcChipTypeParser::IsSupportedChipType()) {
469 EXPECT_EQ(HDF_SUCCESS, 0);
470 } else {
471 if (mHal == nullptr) {
472 ASSERT_NE(nullptr, mHal);
473 return;
474 }
475 mCallback = new NfcClientCallback(EventCallback, DataCallback);
476 if (mCallback == nullptr) {
477 ASSERT_NE(nullptr, mCallback);
478 return;
479 }
480 NfcStatus nfcbtType = NfcStatus::OK;
481 int32_t ret = 0;
482 ret = mHal->Open(mCallback, nfcbtType);
483 EXPECT_EQ(HDF_SUCCESS, ret);
484
485 std::vector<uint8_t> v_data(1, 1);
486 NfcCommand nfcCommand = NfcCommand::CMD_INVALID;
487 ret = mHal->Ioctl(nfcCommand, v_data, nfcbtType);
488 EXPECT_EQ(HDF_SUCCESS, ret);
489
490 ret = mHal->Close(nfcbtType);
491 EXPECT_EQ(HDF_SUCCESS, ret);
492 }
493 }
494
495 /**
496 * @tc.number : SUB_Communication_Nfc_Ioctl_0300
497 * @tc.name : testIoctl002
498 * @tc.desc : The first parameter is an array (255,1)
499 */
500 HWTEST_F(HdfNfcHdiTestAdditional, testIoctl002, Function | MediumTest | Level1)
501 {
502 if (!NfcChipTypeParser::IsSupportedChipType()) {
503 EXPECT_EQ(HDF_SUCCESS, 0);
504 } else {
505 if (mHal == nullptr) {
506 ASSERT_NE(nullptr, mHal);
507 return;
508 }
509 mCallback = new NfcClientCallback(EventCallback, DataCallback);
510 if (mCallback == nullptr) {
511 ASSERT_NE(nullptr, mCallback);
512 return;
513 }
514 NfcStatus nfcbtType = NfcStatus::OK;
515 int32_t ret = 0;
516 ret = mHal->Open(mCallback, nfcbtType);
517 EXPECT_EQ(HDF_SUCCESS, ret);
518
519 std::vector<uint8_t> v_data(255, 1);
520 NfcCommand nfcCommand = NfcCommand::CMD_INVALID;
521 ret = mHal->Ioctl(nfcCommand, v_data, nfcbtType);
522 EXPECT_EQ(HDF_SUCCESS, ret);
523
524 ret = mHal->Close(nfcbtType);
525 EXPECT_EQ(HDF_SUCCESS, ret);
526 }
527 }
528
529 /**
530 * @tc.number : SUB_Communication_Nfc_Ioctl_0400
531 * @tc.name : testIoctl003
532 * @tc.desc : stability test
533 */
534 HWTEST_F(HdfNfcHdiTestAdditional, testIoctl003, Function | MediumTest | Level1)
535 {
536 if (!NfcChipTypeParser::IsSupportedChipType()) {
537 EXPECT_EQ(HDF_SUCCESS, 0);
538 } else {
539 if (mHal == nullptr) {
540 ASSERT_NE(nullptr, mHal);
541 return;
542 }
543 mCallback = new NfcClientCallback(EventCallback, DataCallback);
544 if (mCallback == nullptr) {
545 ASSERT_NE(nullptr, mCallback);
546 return;
547 }
548 NfcStatus nfcbtType = NfcStatus::OK;
549 NfcCommand nfcCommand = NfcCommand::CMD_INVALID;
550 int32_t ret = 0;
551 ret = mHal->Open(mCallback, nfcbtType);
552 EXPECT_EQ(HDF_SUCCESS, ret);
553
554 for (int i = 0; i < 1000; i++) {
555 std::vector<uint8_t> v_data(1, 1);
556 ret = mHal->Ioctl(nfcCommand, v_data, nfcbtType);
557 EXPECT_EQ(HDF_SUCCESS, ret);
558 }
559 ret = mHal->Close(nfcbtType);
560 EXPECT_EQ(HDF_SUCCESS, ret);
561 }
562 }