1 /*
2 * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #include "hdf_netbuf.h"
10 #include "hdf_log.h"
11 #include "hdf_wifi_test.h"
12
13 #define DEFAULT_NETBUF_SIZE 100
14 #define DEFAULT_OP_SIZE 10
15 #define DEFAULT_HEAD_SIZE 10
16 #define DEFAULT_TAIL_SIZE 20
17 #define DEFAULT_MAPPING_QUEUE 10
18 #define DEFAULT_TRIM_SIZE 3
19 #define DEFAULT_SECTION_SIZE 10
20
21 #define MAX_MEM_ALLOC_SIZE 0x7fffffff
22
23 typedef int32_t (*pTestCaseFunc)(void);
24
25 /*
26 * @tc.name: HdfNetBufTest001
27 * @tc.desc: Alloc net buffer
28 * @tc.type: FUNC
29 * @tc.require: AR000DT1UD
30 */
HdfNetBufTest001(void)31 int32_t HdfNetBufTest001(void)
32 {
33 NetBuf *nb = NetBufAlloc(DEFAULT_NETBUF_SIZE);
34 if (nb == NULL) {
35 HDF_LOGE("NetBufAlloc fail");
36 return HDF_FAILURE;
37 }
38 NetBufFree(nb);
39 return HDF_SUCCESS;
40 }
41
42 /*
43 * @tc.name: HdfNetBufTest002
44 * @tc.desc: Alloc net buffer for invalid size
45 * @tc.type: FUNC
46 * @tc.require: AR000DT1UD
47 */
HdfNetBufTest002(void)48 int32_t HdfNetBufTest002(void)
49 {
50 NetBuf *nb = NetBufAlloc(MAX_MEM_ALLOC_SIZE);
51 if (nb == NULL) {
52 return HDF_SUCCESS;
53 }
54 NetBufFree(nb);
55 return HDF_FAILURE;
56 }
57
58 /*
59 * @tc.name: HdfNetBufTest003
60 * @tc.desc: NetBufPush test
61 * @tc.type: FUNC
62 * @tc.require: AR000DT1UD
63 */
HdfNetBufTest003(void)64 int32_t HdfNetBufTest003(void)
65 {
66 void *tmp = NULL;
67 NetBuf *nb = NetBufAlloc(DEFAULT_NETBUF_SIZE);
68 if (nb == NULL) {
69 return HDF_FAILURE;
70 }
71
72 tmp = NetBufPush(nb, E_DATA_BUF, DEFAULT_OP_SIZE);
73 if (tmp == NULL) {
74 NetBufFree(nb);
75 HDF_LOGE("NetBuf Push fail");
76 return HDF_FAILURE;
77 }
78
79 if (NetBufGetRoom(nb, E_DATA_BUF) != DEFAULT_OP_SIZE) {
80 NetBufFree(nb);
81 HDF_LOGE("NetBuf datasize error.");
82 return HDF_FAILURE;
83 }
84
85 NetBufFree(nb);
86 return HDF_SUCCESS;
87 }
88
89 /*
90 * @tc.name: HdfNetBufTest004
91 * @tc.desc: NetBufPush test
92 * @tc.type: FUNC
93 * @tc.require: AR000DT1UD
94 */
HdfNetBufTest004(void)95 int32_t HdfNetBufTest004(void)
96 {
97 void *tmp = NULL;
98 NetBuf *nb = NetBufAlloc(DEFAULT_NETBUF_SIZE);
99 if (nb == NULL) {
100 return HDF_FAILURE;
101 }
102
103 tmp = NetBufPush(nb, E_DATA_BUF, DEFAULT_OP_SIZE);
104 if (tmp == NULL) {
105 NetBufFree(nb);
106 HDF_LOGE("NetBuf push data fail");
107 return HDF_FAILURE;
108 }
109
110 tmp = NetBufPush(nb, E_HEAD_BUF, DEFAULT_OP_SIZE);
111 if (tmp == NULL) {
112 NetBufFree(nb);
113 HDF_LOGE("NetBuf push head fail");
114 return HDF_FAILURE;
115 }
116
117 #ifdef __LITEOS__
118 if (NetBufGetRoom(nb, E_HEAD_BUF) != DEFAULT_OP_SIZE || NetBufGetRoom(nb, E_DATA_BUF) != 0) {
119 #else
120 if (NetBufGetRoom(nb, E_HEAD_BUF) < DEFAULT_OP_SIZE) {
121 #endif
122 NetBufFree(nb);
123 HDF_LOGE("NetBuf datasize error.");
124 return HDF_FAILURE;
125 }
126
127 NetBufFree(nb);
128 return HDF_SUCCESS;
129 }
130
131 /*
132 * @tc.name: HdfNetBufTest005
133 * @tc.desc: NetBufPop test
134 * @tc.type: FUNC
135 * @tc.require: AR000DT1UD
136 */
137 int32_t HdfNetBufTest005(void)
138 {
139 void *tmp = NULL;
140 NetBuf *nb = NetBufAlloc(DEFAULT_NETBUF_SIZE);
141 if (nb == NULL) {
142 return HDF_FAILURE;
143 }
144
145 NetBufPush(nb, E_DATA_BUF, DEFAULT_OP_SIZE);
146 NetBufPush(nb, E_HEAD_BUF, DEFAULT_OP_SIZE);
147 tmp = NetBufPop(nb, E_HEAD_BUF, DEFAULT_OP_SIZE);
148 if (tmp == NULL) {
149 NetBufFree(nb);
150 HDF_LOGE("NetBuf Pull fail");
151 return HDF_FAILURE;
152 }
153
154 #ifdef __LITEOS__
155 if (NetBufGetRoom(nb, E_DATA_BUF) != DEFAULT_OP_SIZE || NetBufGetRoom(nb, E_HEAD_BUF) != 0) {
156 #else
157 if (NetBufGetRoom(nb, E_DATA_BUF) < DEFAULT_OP_SIZE) {
158 #endif
159 NetBufFree(nb);
160 HDF_LOGE("NetBuf datasize error.");
161 return HDF_FAILURE;
162 }
163
164 NetBufFree(nb);
165 return HDF_SUCCESS;
166 }
167
168 /*
169 * @tc.name: HdfNetBufTest006
170 * @tc.desc: NetBufPop test
171 * @tc.type: FUNC
172 * @tc.require: AR000DT1UD
173 */
174 int32_t HdfNetBufTest006(void)
175 {
176 void *tmp = NULL;
177 NetBuf *nb = NetBufAlloc(DEFAULT_NETBUF_SIZE);
178 if (nb == NULL) {
179 return HDF_FAILURE;
180 }
181
182 NetBufPush(nb, E_DATA_BUF, DEFAULT_OP_SIZE);
183 tmp = NetBufPop(nb, E_DATA_BUF, DEFAULT_OP_SIZE);
184 if (tmp == NULL) {
185 NetBufFree(nb);
186 HDF_LOGE("NetBuf Pull fail");
187 return HDF_FAILURE;
188 }
189
190 #ifdef __LITEOS__
191 if (NetBufGetRoom(nb, E_HEAD_BUF) != DEFAULT_OP_SIZE || NetBufGetRoom(nb, E_DATA_BUF) != 0) {
192 #else
193 if (NetBufGetRoom(nb, E_HEAD_BUF) < DEFAULT_OP_SIZE) {
194 #endif
195 NetBufFree(nb);
196 HDF_LOGE("NetBuf datasize error.");
197 return HDF_FAILURE;
198 }
199
200 NetBufFree(nb);
201 return HDF_SUCCESS;
202 }
203
204 /*
205 * @tc.name: HdfNetBufTest007
206 * @tc.desc: NetBufGetRoom test
207 * @tc.type: FUNC
208 * @tc.require: AR000DT1UD
209 */
210 int32_t HdfNetBufTest007(void)
211 {
212 NetBuf *nb = NetBufAlloc(DEFAULT_NETBUF_SIZE);
213 if (nb == NULL) {
214 return HDF_FAILURE;
215 }
216
217 #ifdef __LITEOS__
218 if (NetBufGetRoom(nb, E_HEAD_BUF) != 0) {
219 NetBufFree(nb);
220 HDF_LOGE("NetBufGetRoom head fail");
221 return HDF_FAILURE;
222 }
223 #endif
224
225 if (NetBufGetRoom(nb, E_DATA_BUF) != 0) {
226 NetBufFree(nb);
227 HDF_LOGE("NetBufGetRoom data fail");
228 return HDF_FAILURE;
229 }
230
231 #ifdef __LITEOS__
232 if (NetBufGetRoom(nb, E_TAIL_BUF) != DEFAULT_NETBUF_SIZE) {
233 #else
234 if (NetBufGetRoom(nb, E_TAIL_BUF) < DEFAULT_NETBUF_SIZE) {
235 #endif
236 NetBufFree(nb);
237 HDF_LOGE("NetBufGetRoom tail fail");
238 return HDF_FAILURE;
239 }
240
241 NetBufFree(nb);
242 return HDF_SUCCESS;
243 }
244
245 /*
246 * @tc.name: HdfNetBufTest008
247 * @tc.desc: NetBufGetRoom test
248 * @tc.type: FUNC
249 * @tc.require: AR000DT1UD
250 */
251 int32_t HdfNetBufTest008(void)
252 {
253 NetBuf *nb = NetBufAlloc(DEFAULT_NETBUF_SIZE);
254 if (nb == NULL) {
255 return HDF_FAILURE;
256 }
257
258 NetBufPush(nb, E_DATA_BUF, DEFAULT_OP_SIZE);
259
260 #ifdef __LITEOS__
261 if (NetBufGetRoom(nb, E_TAIL_BUF) != (DEFAULT_NETBUF_SIZE - DEFAULT_OP_SIZE)) {
262 #else
263 if (NetBufGetRoom(nb, E_TAIL_BUF) < (DEFAULT_NETBUF_SIZE - DEFAULT_OP_SIZE)) {
264 #endif
265 NetBufFree(nb);
266 HDF_LOGE("NetBufTailRoom fail");
267 return HDF_FAILURE;
268 }
269
270 NetBufFree(nb);
271
272 return HDF_SUCCESS;
273 }
274
275 /*
276 * @tc.name: HdfNetBufTest009
277 * @tc.desc: NetBufExpandRoom test
278 * @tc.type: FUNC
279 * @tc.require: AR000DT1UD
280 */
281 int32_t HdfNetBufTest009(void)
282 {
283 int32_t ret;
284 NetBuf *nb = NetBufAlloc(DEFAULT_NETBUF_SIZE);
285 if (nb == NULL) {
286 return HDF_FAILURE;
287 }
288
289 ret = NetBufResizeRoom(nb, DEFAULT_HEAD_SIZE, DEFAULT_TAIL_SIZE);
290 if (ret != 0) {
291 NetBufFree(nb);
292 HDF_LOGE("NetBufExpandRoom fail");
293 return HDF_FAILURE;
294 }
295
296 #ifdef __LITEOS__
297 if (NetBufGetRoom(nb, E_HEAD_BUF) != DEFAULT_HEAD_SIZE) {
298 #else
299 if (NetBufGetRoom(nb, E_HEAD_BUF) < DEFAULT_HEAD_SIZE) {
300 #endif
301 NetBufFree(nb);
302 HDF_LOGE("NetBufHeadRoom fail");
303 return HDF_FAILURE;
304 }
305
306 if (NetBufGetRoom(nb, E_TAIL_BUF) < (DEFAULT_NETBUF_SIZE + DEFAULT_TAIL_SIZE)) {
307 NetBufFree(nb);
308 HDF_LOGE("NetBufTailRoom fail, tailroom:%d", NetBufGetRoom(nb, E_TAIL_BUF));
309 return HDF_FAILURE;
310 }
311
312 NetBufFree(nb);
313 return HDF_SUCCESS;
314 }
315
316 /*
317 * @tc.name: HdfNetBufTest010
318 * @tc.desc: NetBufConcat test
319 * @tc.type: FUNC
320 * @tc.require: AR000DT1UD
321 */
322 int32_t HdfNetBufTest010(void)
323 {
324 uint32_t ret;
325 NetBuf *dst = NetBufAlloc(DEFAULT_NETBUF_SIZE);
326 NetBuf *src = NetBufAlloc(DEFAULT_NETBUF_SIZE);
327 if (dst == NULL || src == NULL) {
328 NetBufFree(src);
329 NetBufFree(dst);
330 HDF_LOGE("NetBufAlloc fail");
331 return HDF_FAILURE;
332 }
333
334 NetBufPush(dst, E_DATA_BUF, DEFAULT_OP_SIZE);
335 NetBufPush(src, E_DATA_BUF, DEFAULT_OP_SIZE);
336
337 ret = NetBufConcat(dst, src);
338 if (ret != HDF_SUCCESS) {
339 NetBufFree(src);
340 NetBufFree(dst);
341 HDF_LOGE("NetBufConcat fail");
342 return HDF_FAILURE;
343 }
344
345 if (NetBufGetDataLen(dst) != (DEFAULT_OP_SIZE + DEFAULT_OP_SIZE)) {
346 NetBufFree(dst);
347 HDF_LOGE("NetBufGetLen fail");
348 return HDF_FAILURE;
349 }
350
351 NetBufFree(dst);
352 return HDF_SUCCESS;
353 }
354
355 /*
356 * @tc.name: HdfNetBufTest011
357 * @tc.desc: NetBufConcat test
358 * @tc.type: FUNC
359 * @tc.require: AR000DT1UD
360 */
361 int32_t HdfNetBufTest011(void)
362 {
363 uint32_t ret, dstDataLen;
364 NetBuf *dst = NetBufAlloc(DEFAULT_NETBUF_SIZE);
365 NetBuf *src = NetBufAlloc(DEFAULT_NETBUF_SIZE);
366 if (dst == NULL || src == NULL) {
367 NetBufFree(src);
368 NetBufFree(dst);
369 HDF_LOGE("NetBufAlloc fail");
370 return HDF_FAILURE;
371 }
372
373 /* push large enough because there is maybe padding bytes exists */
374 dstDataLen = DEFAULT_OP_SIZE * DEFAULT_SECTION_SIZE;
375 NetBufPush(dst, E_DATA_BUF, dstDataLen);
376 NetBufPush(src, E_DATA_BUF, DEFAULT_NETBUF_SIZE - 1);
377
378 ret = NetBufConcat(dst, src);
379 if (ret == HDF_SUCCESS) {
380 NetBufFree(dst);
381 HDF_LOGE("NetBufConcat success");
382 return HDF_FAILURE;
383 }
384
385 if (NetBufGetDataLen(dst) != dstDataLen) {
386 NetBufFree(src);
387 NetBufFree(dst);
388 HDF_LOGE("NetBufGetLen fail");
389 return HDF_FAILURE;
390 }
391
392 NetBufFree(src);
393 NetBufFree(dst);
394 return HDF_SUCCESS;
395 }
396
397 #ifdef __LITEOS__
398 /*
399 * @tc.name: HdfNetBufTest012
400 * @tc.desc: NetBuf2Pbuf test
401 * @tc.type: FUNC
402 * @tc.require: AR000DT1UD
403 */
404 int32_t HdfNetBufTest012(void)
405 {
406 struct pbuf *lwipBuf = NULL;
407 NetBuf *nb = NetBufAlloc(DEFAULT_NETBUF_SIZE);
408 if (nb == NULL) {
409 HDF_LOGE("NetBufAlloc fail");
410 return HDF_FAILURE;
411 }
412
413 NetBufPush(nb, E_DATA_BUF, DEFAULT_OP_SIZE);
414
415 lwipBuf = NetBuf2Pbuf(nb);
416 if (lwipBuf == NULL) {
417 NetBufFree(nb);
418 HDF_LOGE("NetBuf2Pbuf fail");
419 return HDF_FAILURE;
420 }
421
422 pbuf_free(lwipBuf);
423 NetBufFree(nb);
424 return HDF_SUCCESS;
425 }
426
427 /*
428 * @tc.name: HdfNetBufTest013
429 * @tc.desc: Pbuf2NetBuf test
430 * @tc.type: FUNC
431 * @tc.require: AR000DT1UD
432 */
433 int32_t HdfNetBufTest013(void)
434 {
435 struct pbuf *lwipBuf = NULL;
436 NetBuf *nb = NULL;
437
438 lwipBuf = pbuf_alloc(PBUF_RAW, DEFAULT_NETBUF_SIZE, PBUF_RAM);
439 if (lwipBuf == NULL) {
440 HDF_LOGE("pbuf_alloc fail");
441 return HDF_FAILURE;
442 }
443
444 nb = Pbuf2NetBuf(NULL, lwipBuf);
445 if (nb == NULL) {
446 pbuf_free(lwipBuf);
447 NetBufFree(nb);
448 HDF_LOGE("Pbuf2NetBuf fail");
449 return HDF_FAILURE;
450 }
451
452 pbuf_free(lwipBuf);
453 NetBufFree(nb);
454 return HDF_SUCCESS;
455 }
456 #endif
457
458 /*
459 * @tc.name: HdfNetBufQueueTest001
460 * @tc.desc: NetBufQueueInit test
461 * @tc.type: FUNC
462 * @tc.require: AR000DT1UD
463 */
464 int32_t HdfNetBufQueueTest001(void)
465 {
466 NetBufQueue q;
467
468 NetBufQueueInit(&q);
469
470 if (!NetBufQueueIsEmpty(&q)) {
471 HDF_LOGE("NetBufQueueIsEmpty fail");
472 return HDF_FAILURE;
473 }
474
475 return HDF_SUCCESS;
476 }
477
478 /*
479 * @tc.name: HdfNetBufQueueTest002
480 * @tc.desc: NetBufQueueSize test
481 * @tc.type: FUNC
482 * @tc.require: AR000DT1UD
483 */
484 int32_t HdfNetBufQueueTest002(void)
485 {
486 NetBufQueue q;
487
488 NetBufQueueInit(&q);
489
490 if (NetBufQueueSize(&q) != 0) {
491 HDF_LOGE("NetBufQueueIsEmpty fail");
492 return HDF_FAILURE;
493 }
494
495 return HDF_SUCCESS;
496 }
497
498 /*
499 * @tc.name: HdfNetBufQueueTest003
500 * @tc.desc: NetBufQueueEnqueue test
501 * @tc.type: FUNC
502 * @tc.require: AR000DT1UD
503 */
504 int32_t HdfNetBufQueueTest003(void)
505 {
506 NetBufQueue q;
507 NetBuf *nb1 = NULL;
508 NetBuf *nb2 = NULL;
509 uint32_t size = 0;
510
511 NetBufQueueInit(&q);
512
513 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
514 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
515 if (nb1 == NULL || nb2 == NULL) {
516 NetBufFree(nb1);
517 NetBufFree(nb2);
518 HDF_LOGE("NetBufAlloc fail");
519 return HDF_FAILURE;
520 }
521
522 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
523 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE);
524 NetBufQueueEnqueue(&q, nb1);
525 size++;
526 NetBufQueueEnqueue(&q, nb2);
527 size++;
528 if (NetBufQueueSize(&q) != size || NetBufQueueIsEmpty(&q)) {
529 HDF_LOGE("NetBufQueueIsEmpty fail");
530 NetBufQueueClear(&q);
531 return HDF_FAILURE;
532 }
533
534 NetBufQueueClear(&q);
535 return HDF_SUCCESS;
536 }
537
538 /*
539 * @tc.name: HdfNetBufQueueTest004
540 * @tc.desc: NetBufQueueAtHead test
541 * @tc.type: FUNC
542 * @tc.require: AR000DT1UD
543 */
544 int32_t HdfNetBufQueueTest004(void)
545 {
546 NetBufQueue q;
547 NetBuf *nb = NULL;
548 NetBuf *nb1 = NULL;
549 NetBuf *nb2 = NULL;
550
551 NetBufQueueInit(&q);
552
553 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
554 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
555 if (nb1 == NULL || nb2 == NULL) {
556 HDF_LOGE("NetBufAlloc fail");
557 NetBufFree(nb1);
558 NetBufFree(nb2);
559 return HDF_FAILURE;
560 }
561
562 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
563 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE + DEFAULT_OP_SIZE);
564 NetBufQueueEnqueue(&q, nb1);
565 NetBufQueueEnqueue(&q, nb2);
566
567 nb = NetBufQueueAtHead(&q);
568 if (NetBufGetDataLen(nb) != DEFAULT_OP_SIZE) {
569 HDF_LOGE("NetBufGetLen fail, len:%d", NetBufGetDataLen(nb));
570 NetBufQueueClear(&q);
571 return HDF_FAILURE;
572 }
573
574 NetBufQueueClear(&q);
575 return HDF_SUCCESS;
576 }
577
578 /*
579 * @tc.name: HdfNetBufQueueTest005
580 * @tc.desc: NetBufQueueAtTail test
581 * @tc.type: FUNC
582 * @tc.require: AR000DT1UD
583 */
584 int32_t HdfNetBufQueueTest005(void)
585 {
586 NetBufQueue q;
587 NetBuf *nb = NULL;
588 NetBuf *nb1 = NULL;
589 NetBuf *nb2 = NULL;
590
591 NetBufQueueInit(&q);
592
593 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
594 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
595 if (nb1 == NULL || nb2 == NULL) {
596 NetBufFree(nb1);
597 NetBufFree(nb2);
598 HDF_LOGE("NetBufAlloc fail");
599 return HDF_FAILURE;
600 }
601
602 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
603 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE + DEFAULT_OP_SIZE);
604 NetBufQueueEnqueue(&q, nb1);
605 NetBufQueueEnqueue(&q, nb2);
606
607 nb = NetBufQueueAtTail(&q);
608 if (NetBufGetDataLen(nb) != (DEFAULT_OP_SIZE + DEFAULT_OP_SIZE)) {
609 HDF_LOGE("NetBufGetLen fail, len:%d", NetBufGetDataLen(nb));
610 NetBufQueueClear(&q);
611 return HDF_FAILURE;
612 }
613
614 NetBufQueueClear(&q);
615 return HDF_SUCCESS;
616 }
617
618 /*
619 * @tc.name: HdfNetBufQueueTest006
620 * @tc.desc: NetBufQueueDequeue test
621 * @tc.type: FUNC
622 * @tc.require: AR000DT1UD
623 */
624 int32_t HdfNetBufQueueTest006(void)
625 {
626 NetBufQueue q;
627 NetBuf *nb1 = NULL;
628 NetBuf *nb2 = NULL;
629
630 NetBufQueueInit(&q);
631 if (NetBufQueueIsEmpty(&q) != 1) {
632 HDF_LOGE("NetBufQueueIsEmpty fail");
633 return HDF_FAILURE;
634 }
635
636 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
637 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
638 if (nb1 == NULL || nb2 == NULL) {
639 NetBufFree(nb1);
640 NetBufFree(nb2);
641 HDF_LOGE("NetBufAlloc fail");
642 return HDF_FAILURE;
643 }
644
645 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
646 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE + DEFAULT_OP_SIZE);
647 NetBufQueueEnqueue(&q, nb1);
648 NetBufQueueEnqueue(&q, nb2);
649
650 nb1 = NetBufQueueDequeue(&q);
651 nb2 = NetBufQueueDequeue(&q);
652 if (nb1 == NULL || nb2 == NULL) {
653 HDF_LOGE("NetBufQueueDequeue fail");
654 NetBufQueueClear(&q);
655 return HDF_FAILURE;
656 }
657
658 if (NetBufQueueSize(&q) != 0 || !NetBufQueueIsEmpty(&q)) {
659 HDF_LOGE("NetBufQueueSize fail, queue size:%d", NetBufQueueSize(&q));
660 NetBufFree(nb1);
661 NetBufFree(nb2);
662 NetBufQueueClear(&q);
663 return HDF_FAILURE;
664 }
665
666 if (NetBufGetDataLen(nb1) != DEFAULT_OP_SIZE ||
667 NetBufGetDataLen(nb2) != (DEFAULT_OP_SIZE + DEFAULT_OP_SIZE)) {
668 HDF_LOGE("NetBufGetLen fail, len:%d", NetBufGetDataLen(nb1));
669 NetBufFree(nb1);
670 NetBufFree(nb2);
671 return HDF_FAILURE;
672 }
673
674 NetBufFree(nb1);
675 NetBufFree(nb2);
676 return HDF_SUCCESS;
677 }
678
679 /*
680 * @tc.name: HdfNetBufQueueTest007
681 * @tc.desc: NetBufQueueEnqueueHead test
682 * @tc.type: FUNC
683 * @tc.require: AR000DT1UD
684 */
685 int32_t HdfNetBufQueueTest007(void)
686 {
687 NetBufQueue q;
688 NetBuf *nb1 = NULL;
689 NetBuf *nb2 = NULL;
690 uint32_t size = 0;
691
692 NetBufQueueInit(&q);
693
694 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
695 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
696 if (nb1 == NULL || nb2 == NULL) {
697 NetBufFree(nb1);
698 NetBufFree(nb2);
699 HDF_LOGE("NetBufAlloc fail");
700 return HDF_FAILURE;
701 }
702
703 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
704 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE + DEFAULT_OP_SIZE);
705 NetBufQueueEnqueueHead(&q, nb1);
706 size++;
707 NetBufQueueEnqueueHead(&q, nb2);
708 size++;
709 if (NetBufQueueSize(&q) != size || NetBufQueueIsEmpty(&q)) {
710 HDF_LOGE("NetBufQueueSize fail, queue size:%d", NetBufQueueSize(&q));
711 NetBufQueueClear(&q);
712 return HDF_FAILURE;
713 }
714
715 nb1 = NetBufQueueDequeueTail(&q);
716 nb2 = NetBufQueueDequeueTail(&q);
717
718 if (NetBufQueueSize(&q) != 0 || !NetBufQueueIsEmpty(&q)) {
719 HDF_LOGE("NetBufQueueSize fail, queue size:%d", NetBufQueueSize(&q));
720 NetBufQueueClear(&q);
721 return HDF_FAILURE;
722 }
723
724 if (NetBufGetDataLen(nb1) != DEFAULT_OP_SIZE) {
725 HDF_LOGE("NetBufGetLen fail, len:%d", NetBufGetDataLen(nb1));
726 NetBufFree(nb1);
727 NetBufFree(nb2);
728 return HDF_FAILURE;
729 }
730
731 if (NetBufGetDataLen(nb2) != (DEFAULT_OP_SIZE + DEFAULT_OP_SIZE)) {
732 HDF_LOGE("NetBufGetLen fail, len:%d", NetBufGetDataLen(nb2));
733 NetBufFree(nb1);
734 NetBufFree(nb2);
735 return HDF_FAILURE;
736 }
737
738 NetBufFree(nb1);
739 NetBufFree(nb2);
740 return HDF_SUCCESS;
741 }
742
743 /*
744 * @tc.name: HdfNetBufQueueTest008
745 * @tc.desc: NetBufQueuePurge test
746 * @tc.type: FUNC
747 * @tc.require: AR000DT1UD
748 */
749 int32_t HdfNetBufQueueTest008(void)
750 {
751 NetBufQueue q;
752 NetBuf *nb1 = NULL;
753 NetBuf *nb2 = NULL;
754
755 NetBufQueueInit(&q);
756
757 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
758 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
759 if (nb1 == NULL || nb2 == NULL) {
760 NetBufFree(nb1);
761 NetBufFree(nb2);
762 HDF_LOGE("NetBufAlloc fail");
763 return HDF_FAILURE;
764 }
765
766 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
767 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE);
768 NetBufQueueEnqueue(&q, nb1);
769 NetBufQueueEnqueue(&q, nb2);
770
771 NetBufQueueClear(&q);
772
773 if (NetBufQueueSize(&q) != 0 || !NetBufQueueIsEmpty(&q)) {
774 HDF_LOGE("NetBufQueueSize fail, queue size:%d", NetBufQueueSize(&q));
775 return HDF_FAILURE;
776 }
777
778 return HDF_SUCCESS;
779 }
780
781 /*
782 * @tc.name: HdfNetBufQueueTest009
783 * @tc.desc: NetBufQueueSpliceInit test
784 * @tc.type: FUNC
785 * @tc.require: AR000DT1UD
786 */
787 int32_t HdfNetBufQueueTest009(void)
788 {
789 NetBufQueue q;
790 NetBufQueue add;
791 NetBuf *nb1 = NULL;
792 NetBuf *nb2 = NULL;
793 NetBuf *nb = NULL;
794 uint32_t size = 0;
795
796 NetBufQueueInit(&q);
797 NetBufQueueInit(&add);
798
799 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
800 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
801 nb = NetBufAlloc(DEFAULT_NETBUF_SIZE);
802 if (nb1 == NULL || nb2 == NULL || nb == NULL) {
803 NetBufFree(nb1);
804 NetBufFree(nb2);
805 NetBufFree(nb);
806 HDF_LOGE("NetBufAlloc fail");
807 return HDF_FAILURE;
808 }
809
810 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
811 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE);
812 NetBufPush(nb, E_DATA_BUF, DEFAULT_OP_SIZE);
813 NetBufQueueEnqueue(&q, nb1);
814 size++;
815 NetBufQueueEnqueue(&q, nb2);
816 size++;
817 NetBufQueueEnqueue(&add, nb);
818
819 NetBufQueueConcat(&q, &add);
820 size++;
821 if (NetBufQueueSize(&q) != size) {
822 NetBufQueueClear(&q);
823 HDF_LOGE("NetBufQueueSize fail, queue size:%d", NetBufQueueSize(&q));
824 return HDF_FAILURE;
825 }
826
827 NetBufQueueClear(&q);
828 return HDF_SUCCESS;
829 }
830
831 // add test case
832 pTestCaseFunc g_hdfNetBufTestCaseLists[] = {
833 HdfNetBufTest001,
834 HdfNetBufTest002,
835 HdfNetBufTest003,
836 HdfNetBufTest004,
837 HdfNetBufTest005,
838 HdfNetBufTest006,
839 HdfNetBufTest007,
840 HdfNetBufTest008,
841 HdfNetBufTest009,
842 HdfNetBufTest010,
843 HdfNetBufTest011,
844 #ifdef __LITEOS__
845 HdfNetBufTest012,
846 HdfNetBufTest013,
847 #endif
848 };
849
850 // add test case
851 pTestCaseFunc g_hdfNetBufQueueTestCaseLists[] = {
852 HdfNetBufQueueTest001,
853 HdfNetBufQueueTest002,
854 HdfNetBufQueueTest003,
855 HdfNetBufQueueTest004,
856 HdfNetBufQueueTest005,
857 HdfNetBufQueueTest006,
858 HdfNetBufQueueTest007,
859 HdfNetBufQueueTest008,
860 HdfNetBufQueueTest009,
861 };
862
863 // HDFNetBuf test case Entry
864 int32_t HdfNetBufTest(void)
865 {
866 int32_t ret, i;
867
868 for (i = 0; i < sizeof(g_hdfNetBufTestCaseLists) / sizeof(g_hdfNetBufTestCaseLists[0]); ++i) {
869 if (g_hdfNetBufTestCaseLists[i] != NULL) {
870 ret = g_hdfNetBufTestCaseLists[i]();
871 HDF_LOGI("HdfTest:HdfNetBuf test_case[%d] result[%s-%d]",
872 i + 1, (ret != HDF_SUCCESS) ? "failed" : "pass", ret);
873 if (ret != HDF_SUCCESS) {
874 return HDF_FAILURE;
875 }
876 }
877 }
878
879 return HDF_SUCCESS;
880 }
881
882 // HdfNetBufQueue test case Entry
883 int32_t HdfNetBufQueueTest(void)
884 {
885 int32_t ret, i;
886
887 for (i = 0; i < sizeof(g_hdfNetBufQueueTestCaseLists) / sizeof(g_hdfNetBufQueueTestCaseLists[0]); ++i) {
888 if (g_hdfNetBufQueueTestCaseLists[i] != NULL) {
889 ret = g_hdfNetBufQueueTestCaseLists[i]();
890 HDF_LOGI("HdfTest:HdfNetBufQueue test_case[%d] result[%s-%d]",
891 i + 1, (ret != HDF_SUCCESS) ? "failed" : "pass", ret);
892 if (ret != HDF_SUCCESS) {
893 return HDF_FAILURE;
894 }
895 }
896 }
897
898 return HDF_SUCCESS;
899 }
900