Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2010-2014 Intel Corporation
3 : : */
4 : :
5 : : #include "test.h"
6 : :
7 : : #include <stdio.h>
8 : : #include <unistd.h>
9 : : #include <string.h>
10 : :
11 : : #include <rte_cycles.h>
12 : : #include <rte_errno.h>
13 : : #include <rte_mbuf.h>
14 : : #include <rte_reorder.h>
15 : : #include <rte_lcore.h>
16 : : #include <rte_malloc.h>
17 : :
18 : : #define BURST 32
19 : : #define REORDER_BUFFER_SIZE 16384
20 : : #define NUM_MBUFS (2*REORDER_BUFFER_SIZE)
21 : : #define REORDER_BUFFER_SIZE_INVALID 2049
22 : :
23 : : struct reorder_unittest_params {
24 : : struct rte_mempool *p;
25 : : struct rte_reorder_buffer *b;
26 : : };
27 : :
28 : : static struct reorder_unittest_params default_params = {
29 : : .p = NULL,
30 : : .b = NULL
31 : : };
32 : :
33 : : static struct reorder_unittest_params *test_params = &default_params;
34 : :
35 : : static int
36 : 1 : test_reorder_create(void)
37 : : {
38 : : struct rte_reorder_buffer *b = NULL;
39 : :
40 : 1 : b = rte_reorder_create(NULL, rte_socket_id(), REORDER_BUFFER_SIZE);
41 [ + - - + ]: 1 : TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
42 : : "No error on create() with NULL name");
43 : :
44 : 1 : b = rte_reorder_create("PKT", rte_socket_id(), REORDER_BUFFER_SIZE_INVALID);
45 [ + - - + ]: 1 : TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
46 : : "No error on create() with invalid buffer size param.");
47 : :
48 : 1 : b = rte_reorder_create("PKT_RO1", rte_socket_id(), REORDER_BUFFER_SIZE);
49 [ - + ]: 1 : TEST_ASSERT_EQUAL(b, test_params->b,
50 : : "New reorder instance created with already existing name");
51 : :
52 : : return 0;
53 : : }
54 : :
55 : : static int
56 : 1 : test_reorder_init(void)
57 : : {
58 : : struct rte_reorder_buffer *b = NULL;
59 : : unsigned int size;
60 : : /*
61 : : * The minimum memory area size that should be passed to library determined
62 : : * by rte_reorder_memory_footprint_get().
63 : : * Otherwise error will be thrown
64 : : */
65 : :
66 : 1 : size = rte_reorder_memory_footprint_get(REORDER_BUFFER_SIZE) - 1;
67 : 1 : b = rte_reorder_init(b, size, "PKT1", REORDER_BUFFER_SIZE);
68 [ + - - + ]: 1 : TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
69 : : "No error on init with NULL buffer.");
70 : :
71 : 1 : b = rte_malloc(NULL, size, 0);
72 : 1 : b = rte_reorder_init(b, size, "PKT1", REORDER_BUFFER_SIZE);
73 [ + - - + ]: 1 : TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
74 : : "No error on init with invalid mem zone size.");
75 : 1 : rte_free(b);
76 : :
77 : 1 : size = rte_reorder_memory_footprint_get(REORDER_BUFFER_SIZE);
78 : 1 : b = rte_malloc(NULL, size, 0);
79 : 1 : b = rte_reorder_init(b, size, "PKT1", REORDER_BUFFER_SIZE_INVALID);
80 [ + - - + ]: 1 : TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
81 : : "No error on init with invalid buffer size param.");
82 : :
83 : 1 : b = rte_reorder_init(b, size, NULL, REORDER_BUFFER_SIZE);
84 [ + - - + ]: 1 : TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
85 : : "No error on init with invalid name.");
86 : 1 : rte_free(b);
87 : :
88 : 1 : return 0;
89 : : }
90 : :
91 : : static int
92 : 1 : test_reorder_find_existing(void)
93 : : {
94 : : struct rte_reorder_buffer *b = NULL;
95 : :
96 : : /* Try to find existing reorder buffer instance */
97 : 1 : b = rte_reorder_find_existing("PKT_RO1");
98 [ - + ]: 1 : TEST_ASSERT_EQUAL(b, test_params->b,
99 : : "existing reorder buffer instance not found");
100 : :
101 : : /* Try to find non existing reorder buffer instance */
102 : 1 : b = rte_reorder_find_existing("ro_find_non_existing");
103 [ + - - + ]: 1 : TEST_ASSERT((b == NULL) && (rte_errno == ENOENT),
104 : : "non existing reorder buffer instance found");
105 : :
106 : : return 0;
107 : : }
108 : :
109 : : static int
110 : 1 : test_reorder_free(void)
111 : : {
112 : : struct rte_reorder_buffer *b1 = NULL, *b2 = NULL;
113 : : const char *name = "test_free";
114 : :
115 : 1 : b1 = rte_reorder_create(name, rte_socket_id(), 8);
116 [ - + ]: 1 : TEST_ASSERT_NOT_NULL(b1, "Failed to create reorder buffer.");
117 : :
118 : 1 : b2 = rte_reorder_find_existing(name);
119 [ - + ]: 1 : TEST_ASSERT_EQUAL(b1, b2, "Failed to find existing reorder buffer");
120 : :
121 : 1 : rte_reorder_free(b1);
122 : :
123 : 1 : b2 = rte_reorder_find_existing(name);
124 [ + - - + ]: 1 : TEST_ASSERT((b2 == NULL) && (rte_errno == ENOENT),
125 : : "Found previously freed reorder buffer");
126 : :
127 : : return 0;
128 : : }
129 : :
130 : : static int
131 : 1 : test_reorder_insert(void)
132 : : {
133 : : #define INSERT_NUM_BUFS 7u
134 : :
135 : : struct rte_reorder_buffer *b = NULL;
136 : 1 : struct rte_mempool *p = test_params->p;
137 : : const unsigned int size = 4;
138 : : struct rte_mbuf *bufs[INSERT_NUM_BUFS];
139 : : int ret = 0;
140 : : unsigned i;
141 : :
142 : : /* This would create a reorder buffer instance consisting of:
143 : : * reorder_seq = 0
144 : : * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
145 : : * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
146 : : */
147 : 1 : b = rte_reorder_create("test_insert", rte_socket_id(), size);
148 [ - + ]: 1 : TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
149 : :
150 [ + + ]: 8 : for (i = 0; i < INSERT_NUM_BUFS; i++) {
151 : 7 : bufs[i] = rte_pktmbuf_alloc(p);
152 [ - + ]: 7 : TEST_ASSERT_NOT_NULL(bufs[i], "Packet allocation failed\n");
153 : 7 : *rte_reorder_seqn(bufs[i]) = i;
154 : : }
155 : :
156 : : /* This should fill up order buffer:
157 : : * reorder_seq = 0
158 : : * RB[] = {NULL, NULL, NULL, NULL}
159 : : * OB[] = {0, 1, 2, 3}
160 : : */
161 [ + + ]: 5 : for (i = 0; i < size; i++) {
162 : 4 : ret = rte_reorder_insert(b, bufs[i]);
163 [ - + ]: 4 : if (ret != 0) {
164 : : printf("%s:%d: Error inserting packet with seqn less than size\n",
165 : : __func__, __LINE__);
166 : : ret = -1;
167 : 0 : goto exit;
168 : : }
169 : 4 : bufs[i] = NULL;
170 : : }
171 : :
172 : : /* early packet - should move mbufs to ready buf and move sequence window
173 : : * reorder_seq = 4
174 : : * RB[] = {0, 1, 2, 3}
175 : : * OB[] = {4, NULL, NULL, NULL}
176 : : */
177 : 1 : ret = rte_reorder_insert(b, bufs[4]);
178 [ - + ]: 1 : if (ret != 0) {
179 : : printf("%s:%d: Error inserting early packet with seqn: size\n",
180 : : __func__, __LINE__);
181 : : ret = -1;
182 : 0 : goto exit;
183 : : }
184 : 1 : bufs[4] = NULL;
185 : :
186 : : /* early packet from current sequence window - full ready buffer */
187 : 1 : *rte_reorder_seqn(bufs[5]) = 2 * size;
188 : 1 : ret = rte_reorder_insert(b, bufs[5]);
189 [ + - - + ]: 1 : if (!((ret == -1) && (rte_errno == ENOSPC))) {
190 : : printf("%s:%d: No error inserting early packet with full ready buffer\n",
191 : : __func__, __LINE__);
192 : : ret = -1;
193 : 0 : goto exit;
194 : : }
195 : 1 : bufs[5] = NULL;
196 : :
197 : : /* late packet */
198 : 1 : *rte_reorder_seqn(bufs[6]) = 3 * size;
199 : 1 : ret = rte_reorder_insert(b, bufs[6]);
200 [ + - - + ]: 1 : if (!((ret == -1) && (rte_errno == ERANGE))) {
201 : : printf("%s:%d: No error inserting late packet with seqn:"
202 : : " 3 * size\n", __func__, __LINE__);
203 : : ret = -1;
204 : 0 : goto exit;
205 : : }
206 : 1 : bufs[6] = NULL;
207 : :
208 : : ret = 0;
209 : 1 : exit:
210 : 1 : rte_reorder_free(b);
211 [ + + ]: 8 : for (i = 0; i < INSERT_NUM_BUFS; i++)
212 : 7 : rte_pktmbuf_free(bufs[i]);
213 : :
214 : : return ret;
215 : : }
216 : :
217 : : static int
218 : 1 : test_reorder_drain(void)
219 : : {
220 : : #define DRAIN_NUM_BUFS 8u
221 : :
222 : : struct rte_reorder_buffer *b = NULL;
223 : 1 : struct rte_mempool *p = test_params->p;
224 : : const unsigned int size = 4;
225 : : struct rte_mbuf *bufs[DRAIN_NUM_BUFS];
226 : : struct rte_mbuf *robufs[DRAIN_NUM_BUFS];
227 : : int ret = 0;
228 : : unsigned i, cnt;
229 : :
230 : : /* initialize all robufs to NULL */
231 [ + + ]: 9 : for (i = 0; i < DRAIN_NUM_BUFS; i++)
232 : 8 : robufs[i] = NULL;
233 : :
234 : : /* This would create a reorder buffer instance consisting of:
235 : : * reorder_seq = 0
236 : : * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
237 : : * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
238 : : */
239 : 1 : b = rte_reorder_create("test_drain", rte_socket_id(), size);
240 [ - + ]: 1 : TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
241 : :
242 : : /* Check no drained packets if reorder is empty */
243 : 1 : cnt = rte_reorder_drain(b, robufs, 1);
244 [ - + ]: 1 : if (cnt != 0) {
245 : : printf("%s:%d: drained packets from empty reorder buffer\n",
246 : : __func__, __LINE__);
247 : : ret = -1;
248 : 0 : goto exit;
249 : : }
250 : :
251 [ + + ]: 9 : for (i = 0; i < DRAIN_NUM_BUFS; i++) {
252 : 8 : bufs[i] = rte_pktmbuf_alloc(p);
253 [ - + ]: 8 : TEST_ASSERT_NOT_NULL(bufs[i], "Packet allocation failed\n");
254 : 8 : *rte_reorder_seqn(bufs[i]) = i;
255 : : }
256 : :
257 : : /* Insert packet with seqn 1:
258 : : * reorder_seq = 0
259 : : * RB[] = {NULL, NULL, NULL, NULL}
260 : : * OB[] = {1, NULL, NULL, NULL}
261 : : */
262 : 1 : rte_reorder_insert(b, bufs[1]);
263 : 1 : bufs[1] = NULL;
264 : :
265 : 1 : cnt = rte_reorder_drain(b, robufs, 1);
266 [ - + ]: 1 : if (cnt != 1) {
267 : : printf("%s:%d:%d: number of expected packets not drained\n",
268 : : __func__, __LINE__, cnt);
269 : : ret = -1;
270 : 0 : goto exit;
271 : : }
272 : 1 : rte_pktmbuf_free(robufs[0]);
273 : : memset(robufs, 0, sizeof(robufs));
274 : :
275 : : /* Insert more packets
276 : : * RB[] = {NULL, NULL, NULL, NULL}
277 : : * OB[] = {NULL, 2, 3, NULL}
278 : : */
279 : 1 : rte_reorder_insert(b, bufs[2]);
280 : 1 : rte_reorder_insert(b, bufs[3]);
281 : 1 : bufs[2] = NULL;
282 : 1 : bufs[3] = NULL;
283 : :
284 : : /* Insert more packets
285 : : * RB[] = {NULL, NULL, NULL, NULL}
286 : : * OB[] = {NULL, 2, 3, 4}
287 : : */
288 : 1 : rte_reorder_insert(b, bufs[4]);
289 : 1 : bufs[4] = NULL;
290 : :
291 : : /* Insert more packets
292 : : * RB[] = {2, 3, 4, NULL}
293 : : * OB[] = {NULL, NULL, 7, NULL}
294 : : */
295 : 1 : rte_reorder_insert(b, bufs[7]);
296 : 1 : bufs[7] = NULL;
297 : :
298 : : /* drained expected packets */
299 : 1 : cnt = rte_reorder_drain(b, robufs, 4);
300 [ - + ]: 1 : if (cnt != 3) {
301 : : printf("%s:%d:%d: number of expected packets not drained\n",
302 : : __func__, __LINE__, cnt);
303 : : ret = -1;
304 : 0 : goto exit;
305 : : }
306 [ + + ]: 4 : for (i = 0; i < 3; i++) {
307 : 3 : rte_pktmbuf_free(robufs[i]);
308 : : }
309 : : memset(robufs, 0, sizeof(robufs));
310 : :
311 : : /*
312 : : * RB[] = {NULL, NULL, NULL, NULL}
313 : : * OB[] = {NULL, NULL, 7, NULL}
314 : : */
315 : 1 : cnt = rte_reorder_drain(b, robufs, 1);
316 [ - + ]: 1 : if (cnt != 0) {
317 : : printf("%s:%d:%d: number of expected packets not drained\n",
318 : : __func__, __LINE__, cnt);
319 : : ret = -1;
320 : 0 : goto exit;
321 : : }
322 : : ret = 0;
323 : 1 : exit:
324 : 1 : rte_reorder_free(b);
325 [ + + ]: 9 : for (i = 0; i < DRAIN_NUM_BUFS; i++) {
326 : 8 : rte_pktmbuf_free(bufs[i]);
327 : 8 : rte_pktmbuf_free(robufs[i]);
328 : : }
329 : : return ret;
330 : : }
331 : :
332 : : static void
333 : : buffer_to_reorder_move(struct rte_mbuf **mbuf, struct rte_reorder_buffer *b)
334 : : {
335 : 2 : rte_reorder_insert(b, *mbuf);
336 : 2 : *mbuf = NULL;
337 : : }
338 : :
339 : : static int
340 : 1 : test_reorder_drain_up_to_seqn(void)
341 : : {
342 : : #define DRAIN_TO_NUM_BUFS 10u
343 : :
344 : 1 : struct rte_mempool *p = test_params->p;
345 : : struct rte_reorder_buffer *b = NULL;
346 : : const unsigned int size = 4;
347 : : unsigned int i, cnt;
348 : : int ret = 0;
349 : :
350 : : struct rte_mbuf *bufs[DRAIN_TO_NUM_BUFS];
351 : : struct rte_mbuf *robufs[DRAIN_TO_NUM_BUFS];
352 : :
353 : : /* initialize all robufs to NULL */
354 : : memset(robufs, 0, sizeof(robufs));
355 : :
356 : : /* This would create a reorder buffer instance consisting of:
357 : : * reorder_seq = 0
358 : : * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
359 : : * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
360 : : */
361 : 1 : b = rte_reorder_create("test_drain_up_to_seqn", rte_socket_id(), size);
362 [ - + ]: 1 : TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
363 : :
364 [ + + ]: 11 : for (i = 0; i < DRAIN_TO_NUM_BUFS; i++) {
365 : 10 : bufs[i] = rte_pktmbuf_alloc(p);
366 [ - + ]: 10 : TEST_ASSERT_NOT_NULL(bufs[i], "Packet allocation failed\n");
367 : 10 : *rte_reorder_seqn(bufs[i]) = i;
368 : : }
369 : :
370 : : /* Insert packet with seqn 1 and 3:
371 : : * RB[] = {NULL, NULL, NULL, NULL}
372 : : * OB[] = {1, 2, 3, NULL}
373 : : */
374 : : buffer_to_reorder_move(&bufs[1], b);
375 : : buffer_to_reorder_move(&bufs[2], b);
376 : : buffer_to_reorder_move(&bufs[3], b);
377 : : /* Draining 1, 2 */
378 : 1 : cnt = rte_reorder_drain_up_to_seqn(b, robufs, DRAIN_TO_NUM_BUFS, 3);
379 [ - + ]: 1 : if (cnt != 2) {
380 : : printf("%s:%d:%d: number of expected packets not drained\n",
381 : : __func__, __LINE__, cnt);
382 : : ret = -1;
383 : 0 : goto exit;
384 : : }
385 [ + + ]: 3 : for (i = 0; i < 2; i++)
386 : 2 : rte_pktmbuf_free(robufs[i]);
387 : : memset(robufs, 0, sizeof(robufs));
388 : :
389 : : /* Insert more packets
390 : : * RB[] = {NULL, NULL, NULL, NULL}
391 : : * OB[] = {3, 4, NULL, 6}
392 : : */
393 : : buffer_to_reorder_move(&bufs[4], b);
394 : : buffer_to_reorder_move(&bufs[6], b);
395 : : /* Insert more packets to utilize Ready buffer
396 : : * RB[] = {3, NULL, 5, 6}
397 : : * OB[] = {NULL, NULL, 8, NULL}
398 : : */
399 : : buffer_to_reorder_move(&bufs[8], b);
400 : :
401 : : /* Drain 3 and 5 */
402 : 1 : cnt = rte_reorder_drain_up_to_seqn(b, robufs, DRAIN_TO_NUM_BUFS, 6);
403 [ - + ]: 1 : if (cnt != 2) {
404 : : printf("%s:%d:%d: number of expected packets not drained\n",
405 : : __func__, __LINE__, cnt);
406 : : ret = -1;
407 : 0 : goto exit;
408 : : }
409 [ + + ]: 3 : for (i = 0; i < 2; i++)
410 : 2 : rte_pktmbuf_free(robufs[i]);
411 : : memset(robufs, 0, sizeof(robufs));
412 : :
413 : : ret = 0;
414 : 1 : exit:
415 : 1 : rte_reorder_free(b);
416 [ + + ]: 11 : for (i = 0; i < DRAIN_TO_NUM_BUFS; i++) {
417 : 10 : rte_pktmbuf_free(bufs[i]);
418 : 10 : rte_pktmbuf_free(robufs[i]);
419 : : }
420 : : return ret;
421 : : }
422 : :
423 : : static int
424 : 1 : test_reorder_set_seqn(void)
425 : : {
426 : : #define SET_SEQN_NUM_BUFS 7u
427 : :
428 : 1 : struct rte_mempool *p = test_params->p;
429 : : struct rte_reorder_buffer *b = NULL;
430 : : const unsigned int size = 4;
431 : : unsigned int i;
432 : : int ret = 0;
433 : :
434 : : struct rte_mbuf *bufs[SET_SEQN_NUM_BUFS];
435 : :
436 : : /* This would create a reorder buffer instance consisting of:
437 : : * reorder_seq = 0
438 : : * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
439 : : * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
440 : : */
441 : 1 : b = rte_reorder_create("test_min_seqn_set", rte_socket_id(), size);
442 [ - + ]: 1 : TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
443 : :
444 [ + + ]: 8 : for (i = 0; i < SET_SEQN_NUM_BUFS; i++) {
445 : 7 : bufs[i] = rte_pktmbuf_alloc(p);
446 [ - + ]: 7 : if (bufs[i] == NULL) {
447 : : printf("Packet allocation failed\n");
448 : 0 : goto exit;
449 : : }
450 : 7 : *rte_reorder_seqn(bufs[i]) = i;
451 : : }
452 : :
453 : 1 : ret = rte_reorder_min_seqn_set(b, 5);
454 [ - + ]: 1 : if (ret != 0) {
455 : : printf("%s:%d: Error in setting min sequence number\n", __func__, __LINE__);
456 : : ret = -1;
457 : 0 : goto exit;
458 : : }
459 : :
460 : 1 : ret = rte_reorder_insert(b, bufs[0]);
461 [ - + ]: 1 : if (ret >= 0) {
462 : : printf("%s:%d: Insertion with value less the min seq number\n", __func__, __LINE__);
463 : : ret = -1;
464 : 0 : goto exit;
465 : : }
466 : :
467 : 1 : ret = rte_reorder_insert(b, bufs[5]);
468 [ - + ]: 1 : if (ret != 0) {
469 : : printf("%s:%d: Error inserting packet with valid seqn\n", __func__, __LINE__);
470 : : ret = -1;
471 : 0 : goto exit;
472 : : }
473 : 1 : bufs[5] = NULL;
474 : :
475 : 1 : ret = rte_reorder_min_seqn_set(b, 0);
476 [ - + ]: 1 : if (ret >= 0) {
477 : : printf("%s:%d: Error in setting min sequence number with non-empty buffer\n",
478 : : __func__, __LINE__);
479 : : ret = -1;
480 : 0 : goto exit;
481 : : }
482 : :
483 : : ret = 0;
484 : 1 : exit:
485 : 1 : rte_reorder_free(b);
486 [ + + ]: 8 : for (i = 0; i < SET_SEQN_NUM_BUFS; i++)
487 : 7 : rte_pktmbuf_free(bufs[i]);
488 : :
489 : : return ret;
490 : : }
491 : :
492 : : static int
493 : 1 : test_setup(void)
494 : : {
495 : : /* reorder buffer instance creation */
496 [ + - ]: 1 : if (test_params->b == NULL) {
497 : 1 : test_params->b = rte_reorder_create("PKT_RO1", rte_socket_id(),
498 : : REORDER_BUFFER_SIZE);
499 [ - + ]: 1 : if (test_params->b == NULL) {
500 : : printf("%s: Error creating reorder buffer instance b\n",
501 : : __func__);
502 : 0 : return -1;
503 : : }
504 : : } else
505 : 0 : rte_reorder_reset(test_params->b);
506 : :
507 : : /* mempool creation */
508 [ + - ]: 1 : if (test_params->p == NULL) {
509 : 1 : test_params->p = rte_pktmbuf_pool_create("RO_MBUF_POOL",
510 : : NUM_MBUFS, BURST, 0, RTE_MBUF_DEFAULT_BUF_SIZE,
511 : 1 : rte_socket_id());
512 [ - + ]: 1 : if (test_params->p == NULL) {
513 : : printf("%s: Error creating mempool\n", __func__);
514 : 0 : return -1;
515 : : }
516 : : }
517 : : return 0;
518 : : }
519 : :
520 : : static void
521 : 1 : test_teardown(void)
522 : : {
523 : 1 : rte_reorder_free(test_params->b);
524 : 1 : test_params->b = NULL;
525 : 1 : rte_mempool_free(test_params->p);
526 : 1 : test_params->p = NULL;
527 : 1 : }
528 : :
529 : :
530 : : static struct unit_test_suite reorder_test_suite = {
531 : :
532 : : .setup = test_setup,
533 : : .teardown = test_teardown,
534 : : .suite_name = "Reorder Unit Test Suite",
535 : : .unit_test_cases = {
536 : : TEST_CASE(test_reorder_create),
537 : : TEST_CASE(test_reorder_init),
538 : : TEST_CASE(test_reorder_find_existing),
539 : : TEST_CASE(test_reorder_free),
540 : : TEST_CASE(test_reorder_insert),
541 : : TEST_CASE(test_reorder_drain),
542 : : TEST_CASE(test_reorder_drain_up_to_seqn),
543 : : TEST_CASE(test_reorder_set_seqn),
544 : : TEST_CASES_END()
545 : : }
546 : : };
547 : :
548 : : static int
549 : 1 : test_reorder(void)
550 : : {
551 : 1 : return unit_test_suite_runner(&reorder_test_suite);
552 : : }
553 : :
554 : :
555 : 252 : REGISTER_FAST_TEST(reorder_autotest, true, true, test_reorder);
|
