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 : 1 : {
133 : : struct rte_reorder_buffer *b = NULL;
134 : 1 : struct rte_mempool *p = test_params->p;
135 : : const unsigned int size = 4;
136 : : const unsigned int num_bufs = 7;
137 : 1 : struct rte_mbuf *bufs[num_bufs];
138 : : int ret = 0;
139 : : unsigned i;
140 : :
141 : : /* This would create a reorder buffer instance consisting of:
142 : : * reorder_seq = 0
143 : : * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
144 : : * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
145 : : */
146 : 1 : b = rte_reorder_create("test_insert", rte_socket_id(), size);
147 [ - + ]: 1 : TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
148 : :
149 [ + + ]: 8 : for (i = 0; i < num_bufs; i++) {
150 : 7 : bufs[i] = rte_pktmbuf_alloc(p);
151 [ - + ]: 7 : TEST_ASSERT_NOT_NULL(bufs[i], "Packet allocation failed\n");
152 : 7 : *rte_reorder_seqn(bufs[i]) = i;
153 : : }
154 : :
155 : : /* This should fill up order buffer:
156 : : * reorder_seq = 0
157 : : * RB[] = {NULL, NULL, NULL, NULL}
158 : : * OB[] = {0, 1, 2, 3}
159 : : */
160 [ + + ]: 5 : for (i = 0; i < size; i++) {
161 : 4 : ret = rte_reorder_insert(b, bufs[i]);
162 [ - + ]: 4 : if (ret != 0) {
163 : : printf("%s:%d: Error inserting packet with seqn less than size\n",
164 : : __func__, __LINE__);
165 : : ret = -1;
166 : 0 : goto exit;
167 : : }
168 : 4 : bufs[i] = NULL;
169 : : }
170 : :
171 : : /* early packet - should move mbufs to ready buf and move sequence window
172 : : * reorder_seq = 4
173 : : * RB[] = {0, 1, 2, 3}
174 : : * OB[] = {4, NULL, NULL, NULL}
175 : : */
176 : 1 : ret = rte_reorder_insert(b, bufs[4]);
177 [ - + ]: 1 : if (ret != 0) {
178 : : printf("%s:%d: Error inserting early packet with seqn: size\n",
179 : : __func__, __LINE__);
180 : : ret = -1;
181 : 0 : goto exit;
182 : : }
183 : 1 : bufs[4] = NULL;
184 : :
185 : : /* early packet from current sequence window - full ready buffer */
186 : 1 : *rte_reorder_seqn(bufs[5]) = 2 * size;
187 : 1 : ret = rte_reorder_insert(b, bufs[5]);
188 [ + - - + ]: 1 : if (!((ret == -1) && (rte_errno == ENOSPC))) {
189 : : printf("%s:%d: No error inserting early packet with full ready buffer\n",
190 : : __func__, __LINE__);
191 : : ret = -1;
192 : 0 : goto exit;
193 : : }
194 : 1 : bufs[5] = NULL;
195 : :
196 : : /* late packet */
197 : 1 : *rte_reorder_seqn(bufs[6]) = 3 * size;
198 : 1 : ret = rte_reorder_insert(b, bufs[6]);
199 [ + - - + ]: 1 : if (!((ret == -1) && (rte_errno == ERANGE))) {
200 : : printf("%s:%d: No error inserting late packet with seqn:"
201 : : " 3 * size\n", __func__, __LINE__);
202 : : ret = -1;
203 : 0 : goto exit;
204 : : }
205 : 1 : bufs[6] = NULL;
206 : :
207 : : ret = 0;
208 : 1 : exit:
209 : 1 : rte_reorder_free(b);
210 [ + + ]: 8 : for (i = 0; i < num_bufs; i++) {
211 : 7 : rte_pktmbuf_free(bufs[i]);
212 : : }
213 : : return ret;
214 : : }
215 : :
216 : : static int
217 : 1 : test_reorder_drain(void)
218 : 1 : {
219 : : struct rte_reorder_buffer *b = NULL;
220 : 1 : struct rte_mempool *p = test_params->p;
221 : : const unsigned int size = 4;
222 : : const unsigned int num_bufs = 8;
223 : 1 : struct rte_mbuf *bufs[num_bufs];
224 : 1 : struct rte_mbuf *robufs[num_bufs];
225 : : int ret = 0;
226 : : unsigned i, cnt;
227 : :
228 : : /* initialize all robufs to NULL */
229 [ + + ]: 9 : for (i = 0; i < num_bufs; i++)
230 : 8 : robufs[i] = NULL;
231 : :
232 : : /* This would create a reorder buffer instance consisting of:
233 : : * reorder_seq = 0
234 : : * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
235 : : * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
236 : : */
237 : 1 : b = rte_reorder_create("test_drain", rte_socket_id(), size);
238 [ - + ]: 1 : TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
239 : :
240 : : /* Check no drained packets if reorder is empty */
241 : 1 : cnt = rte_reorder_drain(b, robufs, 1);
242 [ - + ]: 1 : if (cnt != 0) {
243 : : printf("%s:%d: drained packets from empty reorder buffer\n",
244 : : __func__, __LINE__);
245 : : ret = -1;
246 : 0 : goto exit;
247 : : }
248 : :
249 [ + + ]: 9 : for (i = 0; i < num_bufs; i++) {
250 : 8 : bufs[i] = rte_pktmbuf_alloc(p);
251 [ - + ]: 8 : TEST_ASSERT_NOT_NULL(bufs[i], "Packet allocation failed\n");
252 : 8 : *rte_reorder_seqn(bufs[i]) = i;
253 : : }
254 : :
255 : : /* Insert packet with seqn 1:
256 : : * reorder_seq = 0
257 : : * RB[] = {NULL, NULL, NULL, NULL}
258 : : * OB[] = {1, NULL, NULL, NULL}
259 : : */
260 : 1 : rte_reorder_insert(b, bufs[1]);
261 : 1 : bufs[1] = NULL;
262 : :
263 : 1 : cnt = rte_reorder_drain(b, robufs, 1);
264 [ - + ]: 1 : if (cnt != 1) {
265 : : printf("%s:%d:%d: number of expected packets not drained\n",
266 : : __func__, __LINE__, cnt);
267 : : ret = -1;
268 : 0 : goto exit;
269 : : }
270 : 1 : rte_pktmbuf_free(robufs[0]);
271 : : memset(robufs, 0, sizeof(robufs));
272 : :
273 : : /* Insert more packets
274 : : * RB[] = {NULL, NULL, NULL, NULL}
275 : : * OB[] = {NULL, 2, 3, NULL}
276 : : */
277 : 1 : rte_reorder_insert(b, bufs[2]);
278 : 1 : rte_reorder_insert(b, bufs[3]);
279 : 1 : bufs[2] = NULL;
280 : 1 : bufs[3] = NULL;
281 : :
282 : : /* Insert more packets
283 : : * RB[] = {NULL, NULL, NULL, NULL}
284 : : * OB[] = {NULL, 2, 3, 4}
285 : : */
286 : 1 : rte_reorder_insert(b, bufs[4]);
287 : 1 : bufs[4] = NULL;
288 : :
289 : : /* Insert more packets
290 : : * RB[] = {2, 3, 4, NULL}
291 : : * OB[] = {NULL, NULL, 7, NULL}
292 : : */
293 : 1 : rte_reorder_insert(b, bufs[7]);
294 : 1 : bufs[7] = NULL;
295 : :
296 : : /* drained expected packets */
297 : 1 : cnt = rte_reorder_drain(b, robufs, 4);
298 [ - + ]: 1 : if (cnt != 3) {
299 : : printf("%s:%d:%d: number of expected packets not drained\n",
300 : : __func__, __LINE__, cnt);
301 : : ret = -1;
302 : 0 : goto exit;
303 : : }
304 [ + + ]: 4 : for (i = 0; i < 3; i++) {
305 : 3 : rte_pktmbuf_free(robufs[i]);
306 : : }
307 : : memset(robufs, 0, sizeof(robufs));
308 : :
309 : : /*
310 : : * RB[] = {NULL, NULL, NULL, NULL}
311 : : * OB[] = {NULL, NULL, 7, NULL}
312 : : */
313 : 1 : cnt = rte_reorder_drain(b, robufs, 1);
314 [ - + ]: 1 : if (cnt != 0) {
315 : : printf("%s:%d:%d: number of expected packets not drained\n",
316 : : __func__, __LINE__, cnt);
317 : : ret = -1;
318 : 0 : goto exit;
319 : : }
320 : : ret = 0;
321 : 1 : exit:
322 : 1 : rte_reorder_free(b);
323 [ + + ]: 9 : for (i = 0; i < num_bufs; i++) {
324 : 8 : rte_pktmbuf_free(bufs[i]);
325 : 8 : rte_pktmbuf_free(robufs[i]);
326 : : }
327 : : return ret;
328 : : }
329 : :
330 : : static void
331 : : buffer_to_reorder_move(struct rte_mbuf **mbuf, struct rte_reorder_buffer *b)
332 : : {
333 : 2 : rte_reorder_insert(b, *mbuf);
334 : 2 : *mbuf = NULL;
335 : : }
336 : :
337 : : static int
338 : 1 : test_reorder_drain_up_to_seqn(void)
339 : 1 : {
340 : 1 : struct rte_mempool *p = test_params->p;
341 : : struct rte_reorder_buffer *b = NULL;
342 : : const unsigned int num_bufs = 10;
343 : : const unsigned int size = 4;
344 : : unsigned int i, cnt;
345 : : int ret = 0;
346 : :
347 : 1 : struct rte_mbuf *bufs[num_bufs];
348 : 1 : struct rte_mbuf *robufs[num_bufs];
349 : :
350 : : /* initialize all robufs to NULL */
351 : : memset(robufs, 0, sizeof(robufs));
352 : :
353 : : /* This would create a reorder buffer instance consisting of:
354 : : * reorder_seq = 0
355 : : * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
356 : : * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
357 : : */
358 : 1 : b = rte_reorder_create("test_drain_up_to_seqn", rte_socket_id(), size);
359 [ - + ]: 1 : TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
360 : :
361 [ + + ]: 11 : for (i = 0; i < num_bufs; i++) {
362 : 10 : bufs[i] = rte_pktmbuf_alloc(p);
363 [ - + ]: 10 : TEST_ASSERT_NOT_NULL(bufs[i], "Packet allocation failed\n");
364 : 10 : *rte_reorder_seqn(bufs[i]) = i;
365 : : }
366 : :
367 : : /* Insert packet with seqn 1 and 3:
368 : : * RB[] = {NULL, NULL, NULL, NULL}
369 : : * OB[] = {1, 2, 3, NULL}
370 : : */
371 : : buffer_to_reorder_move(&bufs[1], b);
372 : : buffer_to_reorder_move(&bufs[2], b);
373 : : buffer_to_reorder_move(&bufs[3], b);
374 : : /* Draining 1, 2 */
375 : 1 : cnt = rte_reorder_drain_up_to_seqn(b, robufs, num_bufs, 3);
376 [ - + ]: 1 : if (cnt != 2) {
377 : : printf("%s:%d:%d: number of expected packets not drained\n",
378 : : __func__, __LINE__, cnt);
379 : : ret = -1;
380 : 0 : goto exit;
381 : : }
382 [ + + ]: 3 : for (i = 0; i < 2; i++)
383 : 2 : rte_pktmbuf_free(robufs[i]);
384 : : memset(robufs, 0, sizeof(robufs));
385 : :
386 : : /* Insert more packets
387 : : * RB[] = {NULL, NULL, NULL, NULL}
388 : : * OB[] = {3, 4, NULL, 6}
389 : : */
390 : : buffer_to_reorder_move(&bufs[4], b);
391 : : buffer_to_reorder_move(&bufs[6], b);
392 : : /* Insert more packets to utilize Ready buffer
393 : : * RB[] = {3, NULL, 5, 6}
394 : : * OB[] = {NULL, NULL, 8, NULL}
395 : : */
396 : : buffer_to_reorder_move(&bufs[8], b);
397 : :
398 : : /* Drain 3 and 5 */
399 : 1 : cnt = rte_reorder_drain_up_to_seqn(b, robufs, num_bufs, 6);
400 [ - + ]: 1 : if (cnt != 2) {
401 : : printf("%s:%d:%d: number of expected packets not drained\n",
402 : : __func__, __LINE__, cnt);
403 : : ret = -1;
404 : 0 : goto exit;
405 : : }
406 [ + + ]: 3 : for (i = 0; i < 2; i++)
407 : 2 : rte_pktmbuf_free(robufs[i]);
408 : : memset(robufs, 0, sizeof(robufs));
409 : :
410 : : ret = 0;
411 : 1 : exit:
412 : 1 : rte_reorder_free(b);
413 [ + + ]: 11 : for (i = 0; i < num_bufs; i++) {
414 : 10 : rte_pktmbuf_free(bufs[i]);
415 : 10 : rte_pktmbuf_free(robufs[i]);
416 : : }
417 : : return ret;
418 : : }
419 : :
420 : : static int
421 : 1 : test_reorder_set_seqn(void)
422 : 1 : {
423 : 1 : struct rte_mempool *p = test_params->p;
424 : : struct rte_reorder_buffer *b = NULL;
425 : : const unsigned int num_bufs = 7;
426 : : const unsigned int size = 4;
427 : : unsigned int i;
428 : : int ret = 0;
429 : :
430 : 1 : struct rte_mbuf *bufs[num_bufs];
431 : :
432 : : /* This would create a reorder buffer instance consisting of:
433 : : * reorder_seq = 0
434 : : * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
435 : : * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
436 : : */
437 : 1 : b = rte_reorder_create("test_min_seqn_set", rte_socket_id(), size);
438 [ - + ]: 1 : TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
439 : :
440 [ + + ]: 8 : for (i = 0; i < num_bufs; i++) {
441 : 7 : bufs[i] = rte_pktmbuf_alloc(p);
442 [ - + ]: 7 : if (bufs[i] == NULL) {
443 : : printf("Packet allocation failed\n");
444 : 0 : goto exit;
445 : : }
446 : 7 : *rte_reorder_seqn(bufs[i]) = i;
447 : : }
448 : :
449 : 1 : ret = rte_reorder_min_seqn_set(b, 5);
450 [ - + ]: 1 : if (ret != 0) {
451 : : printf("%s:%d: Error in setting min sequence number\n", __func__, __LINE__);
452 : : ret = -1;
453 : 0 : goto exit;
454 : : }
455 : :
456 : 1 : ret = rte_reorder_insert(b, bufs[0]);
457 [ - + ]: 1 : if (ret >= 0) {
458 : : printf("%s:%d: Insertion with value less the min seq number\n", __func__, __LINE__);
459 : : ret = -1;
460 : 0 : goto exit;
461 : : }
462 : :
463 : 1 : ret = rte_reorder_insert(b, bufs[5]);
464 [ - + ]: 1 : if (ret != 0) {
465 : : printf("%s:%d: Error inserting packet with valid seqn\n", __func__, __LINE__);
466 : : ret = -1;
467 : 0 : goto exit;
468 : : }
469 : 1 : bufs[5] = NULL;
470 : :
471 : 1 : ret = rte_reorder_min_seqn_set(b, 0);
472 [ - + ]: 1 : if (ret >= 0) {
473 : : printf("%s:%d: Error in setting min sequence number with non-empty buffer\n",
474 : : __func__, __LINE__);
475 : : ret = -1;
476 : 0 : goto exit;
477 : : }
478 : :
479 : : ret = 0;
480 : 1 : exit:
481 : 1 : rte_reorder_free(b);
482 [ + + ]: 8 : for (i = 0; i < num_bufs; i++)
483 : 7 : rte_pktmbuf_free(bufs[i]);
484 : :
485 : : return ret;
486 : : }
487 : :
488 : : static int
489 : 1 : test_setup(void)
490 : : {
491 : : /* reorder buffer instance creation */
492 [ + - ]: 1 : if (test_params->b == NULL) {
493 : 1 : test_params->b = rte_reorder_create("PKT_RO1", rte_socket_id(),
494 : : REORDER_BUFFER_SIZE);
495 [ - + ]: 1 : if (test_params->b == NULL) {
496 : : printf("%s: Error creating reorder buffer instance b\n",
497 : : __func__);
498 : 0 : return -1;
499 : : }
500 : : } else
501 : 0 : rte_reorder_reset(test_params->b);
502 : :
503 : : /* mempool creation */
504 [ + - ]: 1 : if (test_params->p == NULL) {
505 : 1 : test_params->p = rte_pktmbuf_pool_create("RO_MBUF_POOL",
506 : : NUM_MBUFS, BURST, 0, RTE_MBUF_DEFAULT_BUF_SIZE,
507 : 1 : rte_socket_id());
508 [ - + ]: 1 : if (test_params->p == NULL) {
509 : : printf("%s: Error creating mempool\n", __func__);
510 : 0 : return -1;
511 : : }
512 : : }
513 : : return 0;
514 : : }
515 : :
516 : : static void
517 : 1 : test_teardown(void)
518 : : {
519 : 1 : rte_reorder_free(test_params->b);
520 : 1 : test_params->b = NULL;
521 : 1 : rte_mempool_free(test_params->p);
522 : 1 : test_params->p = NULL;
523 : 1 : }
524 : :
525 : :
526 : : static struct unit_test_suite reorder_test_suite = {
527 : :
528 : : .setup = test_setup,
529 : : .teardown = test_teardown,
530 : : .suite_name = "Reorder Unit Test Suite",
531 : : .unit_test_cases = {
532 : : TEST_CASE(test_reorder_create),
533 : : TEST_CASE(test_reorder_init),
534 : : TEST_CASE(test_reorder_find_existing),
535 : : TEST_CASE(test_reorder_free),
536 : : TEST_CASE(test_reorder_insert),
537 : : TEST_CASE(test_reorder_drain),
538 : : TEST_CASE(test_reorder_drain_up_to_seqn),
539 : : TEST_CASE(test_reorder_set_seqn),
540 : : TEST_CASES_END()
541 : : }
542 : : };
543 : :
544 : : static int
545 : 1 : test_reorder(void)
546 : : {
547 : 1 : return unit_test_suite_runner(&reorder_test_suite);
548 : : }
549 : :
550 : :
551 : 252 : REGISTER_FAST_TEST(reorder_autotest, true, true, test_reorder);
|
