1 /*
2 * Copyright (c) 2020-2023 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static int32_t HdfNetBufTest011(void)
362 {
363 uint32_t ret;
364 uint32_t dstDataLen;
365 NetBuf *dst = NetBufAlloc(DEFAULT_NETBUF_SIZE);
366 NetBuf *src = NetBufAlloc(DEFAULT_NETBUF_SIZE);
367 if (dst == NULL || src == NULL) {
368 NetBufFree(src);
369 NetBufFree(dst);
370 HDF_LOGE("NetBufAlloc fail");
371 return HDF_FAILURE;
372 }
373
374 /* push large enough because there is maybe padding bytes exists */
375 dstDataLen = DEFAULT_OP_SIZE * DEFAULT_SECTION_SIZE;
376 NetBufPush(dst, E_DATA_BUF, dstDataLen);
377 NetBufPush(src, E_DATA_BUF, DEFAULT_NETBUF_SIZE - 1);
378
379 ret = NetBufConcat(dst, src);
380 if (ret == HDF_SUCCESS) {
381 NetBufFree(dst);
382 HDF_LOGE("NetBufConcat success");
383 return HDF_FAILURE;
384 }
385
386 if (NetBufGetDataLen(dst) != dstDataLen) {
387 NetBufFree(src);
388 NetBufFree(dst);
389 HDF_LOGE("NetBufGetLen fail");
390 return HDF_FAILURE;
391 }
392
393 NetBufFree(src);
394 NetBufFree(dst);
395 return HDF_SUCCESS;
396 }
397
398 #ifdef __LITEOS__
399 /*
400 * @tc.name: HdfNetBufTest012
401 * @tc.desc: NetBuf2Pbuf test
402 * @tc.type: FUNC
403 * @tc.require: AR000DT1UD
404 */
405 static int32_t HdfNetBufTest012(void)
406 {
407 struct pbuf *lwipBuf = NULL;
408 NetBuf *nb = NetBufAlloc(DEFAULT_NETBUF_SIZE);
409 if (nb == NULL) {
410 HDF_LOGE("NetBufAlloc fail");
411 return HDF_FAILURE;
412 }
413
414 NetBufPush(nb, E_DATA_BUF, DEFAULT_OP_SIZE);
415
416 lwipBuf = NetBuf2Pbuf(nb);
417 if (lwipBuf == NULL) {
418 NetBufFree(nb);
419 HDF_LOGE("NetBuf2Pbuf fail");
420 return HDF_FAILURE;
421 }
422
423 pbuf_free(lwipBuf);
424 NetBufFree(nb);
425 return HDF_SUCCESS;
426 }
427
428 /*
429 * @tc.name: HdfNetBufTest013
430 * @tc.desc: Pbuf2NetBuf test
431 * @tc.type: FUNC
432 * @tc.require: AR000DT1UD
433 */
434 static int32_t HdfNetBufTest013(void)
435 {
436 struct pbuf *lwipBuf = NULL;
437 NetBuf *nb = NULL;
438
439 lwipBuf = pbuf_alloc(PBUF_RAW, DEFAULT_NETBUF_SIZE, PBUF_RAM);
440 if (lwipBuf == NULL) {
441 HDF_LOGE("pbuf_alloc fail");
442 return HDF_FAILURE;
443 }
444
445 nb = Pbuf2NetBuf(NULL, lwipBuf);
446 if (nb == NULL) {
447 pbuf_free(lwipBuf);
448 NetBufFree(nb);
449 HDF_LOGE("Pbuf2NetBuf fail");
450 return HDF_FAILURE;
451 }
452
453 pbuf_free(lwipBuf);
454 NetBufFree(nb);
455 return HDF_SUCCESS;
456 }
457 #endif
458
459 /*
460 * @tc.name: HdfNetBufQueueTest001
461 * @tc.desc: NetBufQueueInit test
462 * @tc.type: FUNC
463 * @tc.require: AR000DT1UD
464 */
465 static int32_t HdfNetBufQueueTest001(void)
466 {
467 NetBufQueue q;
468
469 NetBufQueueInit(&q);
470
471 if (!NetBufQueueIsEmpty(&q)) {
472 HDF_LOGE("NetBufQueueIsEmpty fail");
473 return HDF_FAILURE;
474 }
475
476 return HDF_SUCCESS;
477 }
478
479 /*
480 * @tc.name: HdfNetBufQueueTest002
481 * @tc.desc: NetBufQueueSize test
482 * @tc.type: FUNC
483 * @tc.require: AR000DT1UD
484 */
485 static int32_t HdfNetBufQueueTest002(void)
486 {
487 NetBufQueue q;
488
489 NetBufQueueInit(&q);
490
491 if (NetBufQueueSize(&q) != 0) {
492 HDF_LOGE("NetBufQueueIsEmpty fail");
493 return HDF_FAILURE;
494 }
495
496 return HDF_SUCCESS;
497 }
498
499 /*
500 * @tc.name: HdfNetBufQueueTest003
501 * @tc.desc: NetBufQueueEnqueue test
502 * @tc.type: FUNC
503 * @tc.require: AR000DT1UD
504 */
505 static int32_t HdfNetBufQueueTest003(void)
506 {
507 NetBufQueue q;
508 NetBuf *nb1 = NULL;
509 NetBuf *nb2 = NULL;
510 uint32_t size = 0;
511
512 NetBufQueueInit(&q);
513
514 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
515 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
516 if (nb1 == NULL || nb2 == NULL) {
517 NetBufFree(nb1);
518 NetBufFree(nb2);
519 HDF_LOGE("NetBufAlloc fail");
520 return HDF_FAILURE;
521 }
522
523 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
524 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE);
525 NetBufQueueEnqueue(&q, nb1);
526 size++;
527 NetBufQueueEnqueue(&q, nb2);
528 size++;
529 if (NetBufQueueSize(&q) != size || NetBufQueueIsEmpty(&q)) {
530 HDF_LOGE("NetBufQueueIsEmpty fail");
531 NetBufQueueClear(&q);
532 return HDF_FAILURE;
533 }
534
535 NetBufQueueClear(&q);
536 return HDF_SUCCESS;
537 }
538
539 /*
540 * @tc.name: HdfNetBufQueueTest004
541 * @tc.desc: NetBufQueueAtHead test
542 * @tc.type: FUNC
543 * @tc.require: AR000DT1UD
544 */
545 static int32_t HdfNetBufQueueTest004(void)
546 {
547 NetBufQueue q;
548 NetBuf *nb = NULL;
549 NetBuf *nb1 = NULL;
550 NetBuf *nb2 = NULL;
551
552 NetBufQueueInit(&q);
553
554 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
555 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
556 if (nb1 == NULL || nb2 == NULL) {
557 HDF_LOGE("NetBufAlloc fail");
558 NetBufFree(nb1);
559 NetBufFree(nb2);
560 return HDF_FAILURE;
561 }
562
563 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
564 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE + DEFAULT_OP_SIZE);
565 NetBufQueueEnqueue(&q, nb1);
566 NetBufQueueEnqueue(&q, nb2);
567
568 nb = NetBufQueueAtHead(&q);
569 if (NetBufGetDataLen(nb) != DEFAULT_OP_SIZE) {
570 HDF_LOGE("NetBufGetLen fail, len:%d", NetBufGetDataLen(nb));
571 NetBufQueueClear(&q);
572 return HDF_FAILURE;
573 }
574
575 NetBufQueueClear(&q);
576 return HDF_SUCCESS;
577 }
578
579 /*
580 * @tc.name: HdfNetBufQueueTest005
581 * @tc.desc: NetBufQueueAtTail test
582 * @tc.type: FUNC
583 * @tc.require: AR000DT1UD
584 */
585 static int32_t HdfNetBufQueueTest005(void)
586 {
587 NetBufQueue q;
588 NetBuf *nb = NULL;
589 NetBuf *nb1 = NULL;
590 NetBuf *nb2 = NULL;
591
592 NetBufQueueInit(&q);
593
594 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
595 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
596 if (nb1 == NULL || nb2 == NULL) {
597 NetBufFree(nb1);
598 NetBufFree(nb2);
599 HDF_LOGE("NetBufAlloc fail");
600 return HDF_FAILURE;
601 }
602
603 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
604 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE + DEFAULT_OP_SIZE);
605 NetBufQueueEnqueue(&q, nb1);
606 NetBufQueueEnqueue(&q, nb2);
607
608 nb = NetBufQueueAtTail(&q);
609 if (NetBufGetDataLen(nb) != (DEFAULT_OP_SIZE + DEFAULT_OP_SIZE)) {
610 HDF_LOGE("NetBufGetLen fail, len:%d", NetBufGetDataLen(nb));
611 NetBufQueueClear(&q);
612 return HDF_FAILURE;
613 }
614
615 NetBufQueueClear(&q);
616 return HDF_SUCCESS;
617 }
618
619 /*
620 * @tc.name: HdfNetBufQueueTest006
621 * @tc.desc: NetBufQueueDequeue test
622 * @tc.type: FUNC
623 * @tc.require: AR000DT1UD
624 */
625 static int32_t HdfNetBufQueueTest006(void)
626 {
627 NetBufQueue q;
628 NetBuf *nb1 = NULL;
629 NetBuf *nb2 = NULL;
630
631 NetBufQueueInit(&q);
632 if (NetBufQueueIsEmpty(&q) != 1) {
633 HDF_LOGE("NetBufQueueIsEmpty fail");
634 return HDF_FAILURE;
635 }
636
637 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
638 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
639 if (nb1 == NULL || nb2 == NULL) {
640 NetBufFree(nb1);
641 NetBufFree(nb2);
642 HDF_LOGE("NetBufAlloc fail");
643 return HDF_FAILURE;
644 }
645
646 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
647 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE + DEFAULT_OP_SIZE);
648 NetBufQueueEnqueue(&q, nb1);
649 NetBufQueueEnqueue(&q, nb2);
650
651 nb1 = NetBufQueueDequeue(&q);
652 nb2 = NetBufQueueDequeue(&q);
653 if (nb1 == NULL || nb2 == NULL) {
654 HDF_LOGE("NetBufQueueDequeue fail");
655 NetBufQueueClear(&q);
656 return HDF_FAILURE;
657 }
658
659 if (NetBufQueueSize(&q) != 0 || !NetBufQueueIsEmpty(&q)) {
660 HDF_LOGE("NetBufQueueSize fail, queue size:%d", NetBufQueueSize(&q));
661 NetBufFree(nb1);
662 NetBufFree(nb2);
663 NetBufQueueClear(&q);
664 return HDF_FAILURE;
665 }
666
667 if (NetBufGetDataLen(nb1) != DEFAULT_OP_SIZE ||
668 NetBufGetDataLen(nb2) != (DEFAULT_OP_SIZE + DEFAULT_OP_SIZE)) {
669 HDF_LOGE("NetBufGetLen fail, len:%d", NetBufGetDataLen(nb1));
670 NetBufFree(nb1);
671 NetBufFree(nb2);
672 return HDF_FAILURE;
673 }
674
675 NetBufFree(nb1);
676 NetBufFree(nb2);
677 return HDF_SUCCESS;
678 }
679
680 /*
681 * @tc.name: HdfNetBufQueueTest007
682 * @tc.desc: NetBufQueueEnqueueHead test
683 * @tc.type: FUNC
684 * @tc.require: AR000DT1UD
685 */
686 static int32_t HdfNetBufQueueTest007(void)
687 {
688 NetBufQueue q;
689 NetBuf *nb1 = NULL;
690 NetBuf *nb2 = NULL;
691 uint32_t size = 0;
692
693 NetBufQueueInit(&q);
694
695 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
696 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
697 if (nb1 == NULL || nb2 == NULL) {
698 NetBufFree(nb1);
699 NetBufFree(nb2);
700 HDF_LOGE("NetBufAlloc fail");
701 return HDF_FAILURE;
702 }
703
704 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
705 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE + DEFAULT_OP_SIZE);
706 NetBufQueueEnqueueHead(&q, nb1);
707 size++;
708 NetBufQueueEnqueueHead(&q, nb2);
709 size++;
710 if (NetBufQueueSize(&q) != size || NetBufQueueIsEmpty(&q)) {
711 HDF_LOGE("NetBufQueueSize fail, queue size:%d", NetBufQueueSize(&q));
712 NetBufQueueClear(&q);
713 return HDF_FAILURE;
714 }
715
716 nb1 = NetBufQueueDequeueTail(&q);
717 nb2 = NetBufQueueDequeueTail(&q);
718
719 if (NetBufQueueSize(&q) != 0 || !NetBufQueueIsEmpty(&q)) {
720 HDF_LOGE("NetBufQueueSize fail, queue size:%d", NetBufQueueSize(&q));
721 NetBufQueueClear(&q);
722 return HDF_FAILURE;
723 }
724
725 if (NetBufGetDataLen(nb1) != DEFAULT_OP_SIZE) {
726 HDF_LOGE("NetBufGetLen fail, len:%d", NetBufGetDataLen(nb1));
727 NetBufFree(nb1);
728 NetBufFree(nb2);
729 return HDF_FAILURE;
730 }
731
732 if (NetBufGetDataLen(nb2) != (DEFAULT_OP_SIZE + DEFAULT_OP_SIZE)) {
733 HDF_LOGE("NetBufGetLen fail, len:%d", NetBufGetDataLen(nb2));
734 NetBufFree(nb1);
735 NetBufFree(nb2);
736 return HDF_FAILURE;
737 }
738
739 NetBufFree(nb1);
740 NetBufFree(nb2);
741 return HDF_SUCCESS;
742 }
743
744 /*
745 * @tc.name: HdfNetBufQueueTest008
746 * @tc.desc: NetBufQueuePurge test
747 * @tc.type: FUNC
748 * @tc.require: AR000DT1UD
749 */
750 static int32_t HdfNetBufQueueTest008(void)
751 {
752 NetBufQueue q;
753 NetBuf *nb1 = NULL;
754 NetBuf *nb2 = NULL;
755
756 NetBufQueueInit(&q);
757
758 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
759 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
760 if (nb1 == NULL || nb2 == NULL) {
761 NetBufFree(nb1);
762 NetBufFree(nb2);
763 HDF_LOGE("NetBufAlloc fail");
764 return HDF_FAILURE;
765 }
766
767 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
768 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE);
769 NetBufQueueEnqueue(&q, nb1);
770 NetBufQueueEnqueue(&q, nb2);
771
772 NetBufQueueClear(&q);
773
774 if (NetBufQueueSize(&q) != 0 || !NetBufQueueIsEmpty(&q)) {
775 HDF_LOGE("NetBufQueueSize fail, queue size:%d", NetBufQueueSize(&q));
776 return HDF_FAILURE;
777 }
778
779 return HDF_SUCCESS;
780 }
781
782 /*
783 * @tc.name: HdfNetBufQueueTest009
784 * @tc.desc: NetBufQueueSpliceInit test
785 * @tc.type: FUNC
786 * @tc.require: AR000DT1UD
787 */
788 static int32_t HdfNetBufQueueTest009(void)
789 {
790 NetBufQueue q;
791 NetBufQueue add;
792 NetBuf *nb1 = NULL;
793 NetBuf *nb2 = NULL;
794 NetBuf *nb = NULL;
795 uint32_t size = 0;
796
797 NetBufQueueInit(&q);
798 NetBufQueueInit(&add);
799
800 nb1 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
801 nb2 = NetBufAlloc(DEFAULT_NETBUF_SIZE);
802 nb = NetBufAlloc(DEFAULT_NETBUF_SIZE);
803 if (nb1 == NULL || nb2 == NULL || nb == NULL) {
804 NetBufFree(nb1);
805 NetBufFree(nb2);
806 NetBufFree(nb);
807 HDF_LOGE("NetBufAlloc fail");
808 return HDF_FAILURE;
809 }
810
811 NetBufPush(nb1, E_DATA_BUF, DEFAULT_OP_SIZE);
812 NetBufPush(nb2, E_DATA_BUF, DEFAULT_OP_SIZE);
813 NetBufPush(nb, E_DATA_BUF, DEFAULT_OP_SIZE);
814 NetBufQueueEnqueue(&q, nb1);
815 size++;
816 NetBufQueueEnqueue(&q, nb2);
817 size++;
818 NetBufQueueEnqueue(&add, nb);
819
820 NetBufQueueConcat(&q, &add);
821 size++;
822 if (NetBufQueueSize(&q) != size) {
823 NetBufQueueClear(&q);
824 HDF_LOGE("NetBufQueueSize fail, queue size:%d", NetBufQueueSize(&q));
825 return HDF_FAILURE;
826 }
827
828 NetBufQueueClear(&q);
829 return HDF_SUCCESS;
830 }
831
832 // add test case
833 pTestCaseFunc g_hdfNetBufTestCaseLists[] = {
834 HdfNetBufTest001,
835 HdfNetBufTest002,
836 HdfNetBufTest003,
837 HdfNetBufTest004,
838 HdfNetBufTest005,
839 HdfNetBufTest006,
840 HdfNetBufTest007,
841 HdfNetBufTest008,
842 HdfNetBufTest009,
843 HdfNetBufTest010,
844 HdfNetBufTest011,
845 #ifdef __LITEOS__
846 HdfNetBufTest012,
847 HdfNetBufTest013,
848 #endif
849 };
850
851 // add test case
852 pTestCaseFunc g_hdfNetBufQueueTestCaseLists[] = {
853 HdfNetBufQueueTest001,
854 HdfNetBufQueueTest002,
855 HdfNetBufQueueTest003,
856 HdfNetBufQueueTest004,
857 HdfNetBufQueueTest005,
858 HdfNetBufQueueTest006,
859 HdfNetBufQueueTest007,
860 HdfNetBufQueueTest008,
861 HdfNetBufQueueTest009,
862 };
863
864 // HDFNetBuf test case Entry
865 int32_t HdfNetBufTest(void)
866 {
867 int32_t ret;
868 int32_t i;
869
870 for (i = 0; i < sizeof(g_hdfNetBufTestCaseLists) / sizeof(g_hdfNetBufTestCaseLists[0]); ++i) {
871 if (g_hdfNetBufTestCaseLists[i] != NULL) {
872 ret = g_hdfNetBufTestCaseLists[i]();
873 HDF_LOGI("HdfTest:HdfNetBuf test_case[%d] result[%s-%d]",
874 i + 1, (ret != HDF_SUCCESS) ? "failed" : "pass", ret);
875 if (ret != HDF_SUCCESS) {
876 return HDF_FAILURE;
877 }
878 }
879 }
880
881 return HDF_SUCCESS;
882 }
883
884 // HdfNetBufQueue test case Entry
885 int32_t HdfNetBufQueueTest(void)
886 {
887 int32_t ret;
888 int32_t i;
889
890 for (i = 0; i < sizeof(g_hdfNetBufQueueTestCaseLists) / sizeof(g_hdfNetBufQueueTestCaseLists[0]); ++i) {
891 if (g_hdfNetBufQueueTestCaseLists[i] != NULL) {
892 ret = g_hdfNetBufQueueTestCaseLists[i]();
893 HDF_LOGI("HdfTest:HdfNetBufQueue test_case[%d] result[%s-%d]",
894 i + 1, (ret != HDF_SUCCESS) ? "failed" : "pass", ret);
895 if (ret != HDF_SUCCESS) {
896 return HDF_FAILURE;
897 }
898 }
899 }
900
901 return HDF_SUCCESS;
902 }
903