Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2017 Intel Corporation
3 : : */
4 : :
5 : : #include <rte_common.h>
6 : : #include <rte_hexdump.h>
7 : : #include <rte_mbuf.h>
8 : : #include <rte_malloc.h>
9 : : #include <rte_memcpy.h>
10 : : #include <rte_cycles.h>
11 : :
12 : : #include <rte_bus_vdev.h>
13 : :
14 : : #include <rte_bbdev.h>
15 : : #include <rte_bbdev_op.h>
16 : : #include <rte_bbdev_pmd.h>
17 : :
18 : : #include "main.h"
19 : :
20 : :
21 : : #define BBDEV_NAME_NULL ("bbdev_null")
22 : :
23 : : struct bbdev_testsuite_params {
24 : : struct rte_bbdev_queue_conf qconf;
25 : : };
26 : :
27 : : static struct bbdev_testsuite_params testsuite_params;
28 : :
29 : : static uint8_t null_dev_id;
30 : :
31 : : static int
32 : 0 : testsuite_setup(void)
33 : : {
34 : : uint8_t nb_devs;
35 : : int ret;
36 : : char buf[RTE_BBDEV_NAME_MAX_LEN];
37 : :
38 : : /* Create test device */
39 : : snprintf(buf, sizeof(buf), "%s_unittest", BBDEV_NAME_NULL);
40 : 0 : ret = rte_vdev_init(buf, NULL);
41 : 0 : TEST_ASSERT(ret == 0, "Failed to create instance of pmd: %s", buf);
42 : :
43 : 0 : nb_devs = rte_bbdev_count();
44 : 0 : TEST_ASSERT(nb_devs != 0, "No devices found");
45 : :
46 : : /* Most recently created device is our device */
47 : 0 : null_dev_id = nb_devs - 1;
48 : :
49 : 0 : return TEST_SUCCESS;
50 : : }
51 : :
52 : : static void
53 : 0 : testsuite_teardown(void)
54 : : {
55 : : char buf[RTE_BBDEV_NAME_MAX_LEN];
56 : :
57 : : snprintf(buf, sizeof(buf), "%s_unittest", BBDEV_NAME_NULL);
58 : 0 : rte_vdev_uninit(buf);
59 : 0 : }
60 : :
61 : : static int
62 : 0 : ut_setup(void)
63 : : {
64 : : struct bbdev_testsuite_params *ts_params = &testsuite_params;
65 : : uint8_t num_queues;
66 : :
67 : : /* Valid queue configuration */
68 : 0 : ts_params->qconf.priority = 0;
69 : 0 : ts_params->qconf.socket = SOCKET_ID_ANY;
70 : 0 : ts_params->qconf.deferred_start = 1;
71 : :
72 : : num_queues = 1;
73 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(null_dev_id, num_queues,
74 : : SOCKET_ID_ANY), "Failed to setup queues for bbdev %u",
75 : : 0);
76 : :
77 : : /* Start the device */
78 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_start(null_dev_id),
79 : : "Failed to start bbdev %u", 0);
80 : :
81 : : return TEST_SUCCESS;
82 : : }
83 : :
84 : : static void
85 : 0 : ut_teardown(void)
86 : : {
87 : 0 : rte_bbdev_close(null_dev_id);
88 : 0 : }
89 : :
90 : : static int
91 : 0 : test_bbdev_configure_invalid_dev_id(void)
92 : : {
93 : : uint8_t dev_id;
94 : : uint8_t num_queues;
95 : :
96 : : num_queues = 1;
97 : 0 : for (dev_id = 0; dev_id < RTE_BBDEV_MAX_DEVS; dev_id++) {
98 : 0 : if (!rte_bbdev_is_valid(dev_id)) {
99 : 0 : TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id,
100 : : num_queues, SOCKET_ID_ANY),
101 : : "Failed test for rte_bbdev_setup_queues: "
102 : : "invalid dev_num %u", dev_id);
103 : 0 : TEST_ASSERT(rte_bbdev_intr_enable(dev_id) == -ENODEV,
104 : : "Failed test for rte_bbdev_intr_enable: "
105 : : "invalid dev_num %u", dev_id);
106 : : break;
107 : : }
108 : : }
109 : :
110 : : return TEST_SUCCESS;
111 : : }
112 : :
113 : : static int
114 : 0 : test_bbdev_configure_invalid_num_queues(void)
115 : : {
116 : : struct rte_bbdev_info info;
117 : : uint8_t dev_id, num_devs;
118 : : uint8_t num_queues;
119 : : int return_value;
120 : :
121 : 0 : TEST_ASSERT((num_devs = rte_bbdev_count()) >= 1,
122 : : "Need at least %d devices for test", 1);
123 : :
124 : : /* valid num_queues values */
125 : : num_queues = 8;
126 : :
127 : : /* valid dev_id values */
128 : 0 : dev_id = null_dev_id;
129 : :
130 : : /* Stop the device in case it's started so it can be configured */
131 : 0 : rte_bbdev_stop(dev_id);
132 : :
133 : 0 : TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 0, SOCKET_ID_ANY),
134 : : "Failed test for rte_bbdev_setup_queues: "
135 : : "invalid num_queues %d", 0);
136 : :
137 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, num_queues,
138 : : SOCKET_ID_ANY),
139 : : "Failed test for rte_bbdev_setup_queues: "
140 : : "invalid dev_num %u", dev_id);
141 : :
142 : 0 : TEST_ASSERT_FAIL(return_value = rte_bbdev_info_get(dev_id, NULL),
143 : : "Failed test for rte_bbdev_info_get: "
144 : : "returned value:%i", return_value);
145 : :
146 : 0 : TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
147 : : "Failed test for rte_bbdev_info_get: "
148 : : "invalid return value:%i", return_value);
149 : :
150 : 0 : TEST_ASSERT(info.num_queues == num_queues,
151 : : "Failed test for rte_bbdev_info_get: "
152 : : "invalid num_queues:%u", info.num_queues);
153 : :
154 : 0 : num_queues = info.drv.max_num_queues;
155 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, num_queues,
156 : : SOCKET_ID_ANY),
157 : : "Failed test for rte_bbdev_setup_queues: "
158 : : "invalid num_queues: %u", num_queues);
159 : :
160 : 0 : num_queues++;
161 : 0 : TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, num_queues,
162 : : SOCKET_ID_ANY),
163 : : "Failed test for rte_bbdev_setup_queues: "
164 : : "invalid num_queues: %u", num_queues);
165 : :
166 : : return TEST_SUCCESS;
167 : : }
168 : :
169 : : static int
170 : 0 : test_bbdev_configure_stop_device(void)
171 : : {
172 : : struct rte_bbdev_info info;
173 : : uint8_t dev_id;
174 : : int return_value;
175 : :
176 : : /* valid dev_id values */
177 : 0 : dev_id = null_dev_id;
178 : :
179 : : /* Stop the device so it can be configured */
180 : 0 : rte_bbdev_stop(dev_id);
181 : :
182 : 0 : TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
183 : : "Failed test for rte_bbdev_info_get: "
184 : : "invalid return value from "
185 : : "rte_bbdev_info_get function: %i", return_value);
186 : :
187 : 0 : TEST_ASSERT_SUCCESS(info.started, "Failed test for rte_bbdev_info_get: "
188 : : "started value: %u", info.started);
189 : :
190 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id,
191 : : info.drv.max_num_queues, SOCKET_ID_ANY),
192 : : "Failed test for rte_bbdev_setup_queues: "
193 : : "device should be stopped, dev_id: %u", dev_id);
194 : :
195 : 0 : return_value = rte_bbdev_intr_enable(dev_id);
196 : 0 : TEST_ASSERT(return_value != -EBUSY,
197 : : "Failed test for rte_bbdev_intr_enable: device should be stopped, dev_id: %u",
198 : : dev_id);
199 : :
200 : : /* Start the device so it cannot be configured */
201 : 0 : TEST_ASSERT_FAIL(rte_bbdev_start(RTE_BBDEV_MAX_DEVS),
202 : : "Failed to start bbdev %u", dev_id);
203 : :
204 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
205 : : "Failed to start bbdev %u", dev_id);
206 : :
207 : 0 : TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
208 : : "Failed test for rte_bbdev_info_get: "
209 : : "invalid return value from "
210 : : "rte_bbdev_info_get function: %i", return_value);
211 : :
212 : 0 : TEST_ASSERT_FAIL(info.started, "Failed test for rte_bbdev_info_get: "
213 : : "started value: %u", info.started);
214 : :
215 : 0 : TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id,
216 : : info.drv.max_num_queues, SOCKET_ID_ANY),
217 : : "Failed test for rte_bbdev_setup_queues: "
218 : : "device should be started, dev_id: %u", dev_id);
219 : :
220 : 0 : return_value = rte_bbdev_intr_enable(dev_id);
221 : 0 : TEST_ASSERT(return_value == -EBUSY,
222 : : "Failed test for rte_bbdev_intr_enable: device should be started, dev_id: %u",
223 : : dev_id);
224 : :
225 : : /* Stop again the device so it can be once again configured */
226 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stop(RTE_BBDEV_MAX_DEVS),
227 : : "Failed to start bbdev %u", dev_id);
228 : :
229 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u",
230 : : dev_id);
231 : :
232 : 0 : TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
233 : : "Failed test for rte_bbdev_info_get: "
234 : : "invalid return value from "
235 : : "rte_bbdev_info_get function: %i", return_value);
236 : :
237 : 0 : TEST_ASSERT_SUCCESS(info.started, "Failed test for rte_bbdev_info_get: "
238 : : "started value: %u", info.started);
239 : :
240 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id,
241 : : info.drv.max_num_queues, SOCKET_ID_ANY),
242 : : "Failed test for rte_bbdev_setup_queues: "
243 : : "device should be stopped, dev_id: %u", dev_id);
244 : :
245 : 0 : return_value = rte_bbdev_intr_enable(dev_id);
246 : 0 : TEST_ASSERT(return_value != -EBUSY,
247 : : "Failed test for rte_bbdev_intr_enable: device should be stopped, dev_id: %u",
248 : : dev_id);
249 : :
250 : : return TEST_SUCCESS;
251 : : }
252 : :
253 : : static int
254 : 0 : test_bbdev_configure_stop_queue(void)
255 : : {
256 : : struct bbdev_testsuite_params *ts_params = &testsuite_params;
257 : : struct rte_bbdev_info info;
258 : : struct rte_bbdev_queue_info qinfo;
259 : : uint8_t dev_id;
260 : : uint16_t queue_id;
261 : : int return_value;
262 : :
263 : : /* Valid dev_id values */
264 : 0 : dev_id = null_dev_id;
265 : :
266 : : /* Valid queue_id values */
267 : : queue_id = 0;
268 : :
269 : 0 : rte_bbdev_stop(dev_id);
270 : 0 : TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
271 : : "Failed test for rte_bbdev_info_get: "
272 : : "invalid return value:%i", return_value);
273 : :
274 : : /* Valid queue configuration */
275 : 0 : ts_params->qconf.queue_size = info.drv.queue_size_lim;
276 : 0 : ts_params->qconf.priority = info.drv.max_ul_queue_priority;
277 : :
278 : : /* Device - started; queue - started */
279 : 0 : rte_bbdev_start(dev_id);
280 : :
281 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
282 : : &ts_params->qconf),
283 : : "Failed test for rte_bbdev_queue_configure: "
284 : : "queue:%u on device:%u should be stopped",
285 : : queue_id, dev_id);
286 : :
287 : : /* Device - stopped; queue - started */
288 : 0 : rte_bbdev_stop(dev_id);
289 : :
290 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
291 : : &ts_params->qconf),
292 : : "Failed test for rte_bbdev_queue_configure: "
293 : : "queue:%u on device:%u should be stopped",
294 : : queue_id, dev_id);
295 : :
296 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_stop(RTE_BBDEV_MAX_DEVS, queue_id),
297 : : "Failed test for rte_bbdev_queue_stop "
298 : : "invalid dev_id ");
299 : :
300 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, RTE_MAX_QUEUES_PER_PORT),
301 : : "Failed test for rte_bbdev_queue_stop "
302 : : "invalid queue_id ");
303 : :
304 : : /* Device - stopped; queue - stopped */
305 : 0 : rte_bbdev_queue_stop(dev_id, queue_id);
306 : :
307 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
308 : : &ts_params->qconf),
309 : : "Failed test for rte_bbdev_queue_configure: "
310 : : "queue:%u on device:%u should be stopped", queue_id,
311 : : dev_id);
312 : :
313 : 0 : TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
314 : : queue_id, &qinfo),
315 : : "Failed test for rte_bbdev_info_get: "
316 : : "invalid return value from "
317 : : "rte_bbdev_queue_info_get function: %i", return_value);
318 : :
319 : 0 : TEST_ASSERT(qinfo.conf.socket == ts_params->qconf.socket,
320 : : "Failed test for rte_bbdev_queue_info_get: "
321 : : "invalid queue_size:%u", qinfo.conf.socket);
322 : :
323 : 0 : TEST_ASSERT(qinfo.conf.queue_size == ts_params->qconf.queue_size,
324 : : "Failed test for rte_bbdev_queue_info_get: "
325 : : "invalid queue_size:%u", qinfo.conf.queue_size);
326 : :
327 : 0 : TEST_ASSERT(qinfo.conf.priority == ts_params->qconf.priority,
328 : : "Failed test for rte_bbdev_queue_info_get: "
329 : : "invalid queue_size:%u", qinfo.conf.priority);
330 : :
331 : 0 : TEST_ASSERT(qinfo.conf.deferred_start ==
332 : : ts_params->qconf.deferred_start,
333 : : "Failed test for rte_bbdev_queue_info_get: "
334 : : "invalid queue_size:%u", qinfo.conf.deferred_start);
335 : :
336 : : /* Device - started; queue - stopped */
337 : 0 : rte_bbdev_start(dev_id);
338 : 0 : rte_bbdev_queue_stop(dev_id, queue_id);
339 : :
340 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
341 : : &ts_params->qconf),
342 : : "Failed test for rte_bbdev_queue_configure: "
343 : : "queue:%u on device:%u should be stopped", queue_id,
344 : : dev_id);
345 : :
346 : 0 : rte_bbdev_stop(dev_id);
347 : :
348 : : /* After rte_bbdev_start(dev_id):
349 : : * - queue should be still stopped if deferred_start ==
350 : : */
351 : 0 : rte_bbdev_start(dev_id);
352 : :
353 : 0 : TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
354 : : queue_id, &qinfo),
355 : : "Failed test for rte_bbdev_info_get: "
356 : : "invalid return value from "
357 : : "rte_bbdev_queue_info_get function: %i", return_value);
358 : :
359 : 0 : TEST_ASSERT(qinfo.started == 0,
360 : : "Failed test for rte_bbdev_queue_info_get: "
361 : : "invalid value for qinfo.started:%u", qinfo.started);
362 : :
363 : 0 : rte_bbdev_stop(dev_id);
364 : :
365 : : /* After rte_bbdev_start(dev_id):
366 : : * - queue should be started if deferred_start ==
367 : : */
368 : 0 : ts_params->qconf.deferred_start = 0;
369 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, &ts_params->qconf),
370 : : "Failed test for rte_bbdev_queue_configure");
371 : 0 : rte_bbdev_start(dev_id);
372 : :
373 : 0 : TEST_ASSERT_SUCCESS(return_value = rte_bbdev_queue_info_get(dev_id,
374 : : queue_id, &qinfo),
375 : : "Failed test for rte_bbdev_info_get: "
376 : : "invalid return value from "
377 : : "rte_bbdev_queue_info_get function: %i", return_value);
378 : :
379 : 0 : TEST_ASSERT(qinfo.started == 1,
380 : : "Failed test for rte_bbdev_queue_info_get: "
381 : : "invalid value for qinfo.started:%u", qinfo.started);
382 : :
383 : : return TEST_SUCCESS;
384 : : }
385 : :
386 : : static int
387 : 0 : test_bbdev_configure_invalid_queue_configure(void)
388 : : {
389 : : struct bbdev_testsuite_params *ts_params = &testsuite_params;
390 : : int return_value;
391 : : struct rte_bbdev_info info;
392 : : uint8_t dev_id;
393 : : uint16_t queue_id;
394 : :
395 : : /* Valid dev_id values */
396 : 0 : dev_id = null_dev_id;
397 : :
398 : : /* Valid queue_id values */
399 : : queue_id = 0;
400 : :
401 : 0 : rte_bbdev_stop(dev_id);
402 : :
403 : 0 : TEST_ASSERT_SUCCESS(return_value = rte_bbdev_info_get(dev_id, &info),
404 : : "Failed test for rte_bbdev_info_get: "
405 : : "invalid return value:%i", return_value);
406 : :
407 : 0 : rte_bbdev_queue_stop(dev_id, queue_id);
408 : :
409 : 0 : ts_params->qconf.queue_size = info.drv.queue_size_lim + 1;
410 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
411 : : &ts_params->qconf),
412 : : "Failed test for rte_bbdev_queue_configure: "
413 : : "invalid value qconf.queue_size: %u",
414 : : ts_params->qconf.queue_size);
415 : :
416 : 0 : ts_params->qconf.queue_size = info.drv.queue_size_lim;
417 : 0 : ts_params->qconf.priority = info.drv.max_ul_queue_priority;
418 : 0 : queue_id = info.num_queues;
419 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
420 : : &ts_params->qconf),
421 : : "Failed test for rte_bbdev_queue_configure: "
422 : : "invalid value queue_id: %u", queue_id);
423 : :
424 : : queue_id = 0;
425 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
426 : : "Failed test for rte_bbdev_queue_configure: "
427 : : "NULL qconf structure ");
428 : :
429 : 0 : ts_params->qconf.socket = RTE_MAX_NUMA_NODES;
430 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
431 : : &ts_params->qconf),
432 : : "Failed test for rte_bbdev_queue_configure: "
433 : : "invalid socket number ");
434 : :
435 : 0 : ts_params->qconf.socket = SOCKET_ID_ANY;
436 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
437 : : &ts_params->qconf),
438 : : "Failed test for rte_bbdev_queue_configure: "
439 : : "invalid value qconf.queue_size: %u",
440 : : ts_params->qconf.queue_size);
441 : :
442 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS, queue_id,
443 : : &ts_params->qconf),
444 : : "Failed test for rte_bbdev_queue_configure: "
445 : : "invalid dev_id");
446 : :
447 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id, NULL),
448 : : "Failed test for rte_bbdev_queue_configure: "
449 : : "invalid value qconf.queue_size: %u",
450 : : ts_params->qconf.queue_size);
451 : :
452 : : return TEST_SUCCESS;
453 : : }
454 : :
455 : : static int
456 : 0 : test_bbdev_op_pool(void)
457 : : {
458 : : struct rte_mempool *mp;
459 : :
460 : : unsigned int dec_size = sizeof(struct rte_bbdev_dec_op);
461 : : unsigned int enc_size = sizeof(struct rte_bbdev_enc_op);
462 : :
463 : : const char *pool_dec = "Test_DEC";
464 : : const char *pool_enc = "Test_ENC";
465 : :
466 : : /* Valid pool configuration */
467 : : uint32_t size = 256;
468 : : uint32_t cache_size = 128;
469 : :
470 : 0 : TEST_ASSERT(rte_bbdev_op_pool_create(NULL,
471 : : RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0) == NULL,
472 : : "Failed test for rte_bbdev_op_pool_create: "
473 : : "NULL name parameter");
474 : :
475 : 0 : TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_dec,
476 : : RTE_BBDEV_OP_TURBO_DEC, size, cache_size, 0)) != NULL,
477 : : "Failed test for rte_bbdev_op_pool_create: "
478 : : "returned value is empty");
479 : :
480 : 0 : TEST_ASSERT(mp->size == size,
481 : : "Failed test for rte_bbdev_op_pool_create: "
482 : : "invalid size of the mempool, mp->size: %u", mp->size);
483 : :
484 : 0 : TEST_ASSERT(mp->cache_size == cache_size,
485 : : "Failed test for rte_bbdev_op_pool_create: "
486 : : "invalid size of the mempool, mp->size: %u",
487 : : mp->cache_size);
488 : :
489 : 0 : TEST_ASSERT_SUCCESS(strcmp(mp->name, pool_dec),
490 : : "Failed test for rte_bbdev_op_pool_create: "
491 : : "invalid name of mempool, mp->name: %s", mp->name);
492 : :
493 : 0 : TEST_ASSERT(mp->elt_size == dec_size,
494 : : "Failed test for rte_bbdev_op_pool_create: "
495 : : "invalid element size for RTE_BBDEV_OP_TURBO_DEC, "
496 : : "mp->elt_size: %u", mp->elt_size);
497 : :
498 : 0 : rte_mempool_free(mp);
499 : :
500 : 0 : TEST_ASSERT((mp = rte_bbdev_op_pool_create(pool_enc,
501 : : RTE_BBDEV_OP_TURBO_ENC, size, cache_size, 0)) != NULL,
502 : : "Failed test for rte_bbdev_op_pool_create: "
503 : : "returned value is empty");
504 : :
505 : 0 : TEST_ASSERT(mp->elt_size == enc_size,
506 : : "Failed test for rte_bbdev_op_pool_create: "
507 : : "invalid element size for RTE_BBDEV_OP_TURBO_ENC, "
508 : : "mp->elt_size: %u", mp->elt_size);
509 : :
510 : 0 : rte_mempool_free(mp);
511 : :
512 : 0 : TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_NONE",
513 : : RTE_BBDEV_OP_NONE, size, cache_size, 0)) != NULL,
514 : : "Failed test for rte_bbdev_op_pool_create: "
515 : : "returned value is empty for RTE_BBDEV_OP_NONE");
516 : :
517 : 0 : TEST_ASSERT(mp->elt_size == (enc_size > dec_size ? enc_size : dec_size),
518 : : "Failed test for rte_bbdev_op_pool_create: "
519 : : "invalid size for RTE_BBDEV_OP_NONE, mp->elt_size: %u",
520 : : mp->elt_size);
521 : :
522 : 0 : rte_mempool_free(mp);
523 : :
524 : 0 : TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_INV",
525 : : RTE_BBDEV_OP_TYPE_SIZE_MAX, size, cache_size, 0)) == NULL,
526 : : "Failed test for rte_bbdev_op_pool_create: "
527 : : "returned value is not NULL for invalid type");
528 : :
529 : : /* Invalid pool configuration */
530 : : size = 128;
531 : : cache_size = 256;
532 : :
533 : 0 : TEST_ASSERT((mp = rte_bbdev_op_pool_create("Test_InvSize",
534 : : RTE_BBDEV_OP_NONE, size, cache_size, 0)) == NULL,
535 : : "Failed test for rte_bbdev_op_pool_create: "
536 : : "returned value should be empty "
537 : : "because size of per-lcore local cache "
538 : : "is greater than size of the mempool.");
539 : :
540 : : return TEST_SUCCESS;
541 : : }
542 : :
543 : : /**
544 : : * Create pool of OP types RTE_BBDEV_OP_NONE, RTE_BBDEV_OP_TURBO_DEC and
545 : : * RTE_BBDEV_OP_TURBO_ENC and check that only ops of that type can be
546 : : * allocated
547 : : */
548 : : static int
549 : 0 : test_bbdev_op_type(void)
550 : 0 : {
551 : : struct rte_mempool *mp_dec;
552 : :
553 : : const unsigned int OPS_COUNT = 32;
554 : 0 : struct rte_bbdev_dec_op *dec_ops_arr[OPS_COUNT];
555 : 0 : struct rte_bbdev_enc_op *enc_ops_arr[OPS_COUNT];
556 : :
557 : : const char *pool_dec = "Test_op_dec";
558 : :
559 : : /* Valid pool configuration */
560 : : uint32_t num_elements = 256;
561 : : uint32_t cache_size = 128;
562 : :
563 : : /* mempool type : RTE_BBDEV_OP_TURBO_DEC */
564 : 0 : mp_dec = rte_bbdev_op_pool_create(pool_dec,
565 : : RTE_BBDEV_OP_TURBO_DEC, num_elements, cache_size, 0);
566 : 0 : TEST_ASSERT(mp_dec != NULL, "Failed to create %s mempool", pool_dec);
567 : :
568 : 0 : TEST_ASSERT(rte_bbdev_dec_op_alloc_bulk(mp_dec, dec_ops_arr, 1) == 0,
569 : : "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
570 : : "OPs type: RTE_BBDEV_OP_TURBO_DEC");
571 : :
572 : 0 : TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_dec, enc_ops_arr, 1) != 0,
573 : : "Failed test for rte_bbdev_op_alloc_bulk TURBO_DEC: "
574 : : "OPs type: RTE_BBDEV_OP_TURBO_ENC");
575 : :
576 : 0 : rte_mempool_free(mp_dec);
577 : :
578 : 0 : return TEST_SUCCESS;
579 : : }
580 : :
581 : : static int
582 : 0 : test_bbdev_op_pool_size(void)
583 : 0 : {
584 : : struct rte_mempool *mp_none;
585 : :
586 : : const unsigned int OPS_COUNT = 128;
587 : 0 : struct rte_bbdev_enc_op *ops_enc_arr[OPS_COUNT];
588 : 0 : struct rte_bbdev_enc_op *ops_ext_arr[OPS_COUNT];
589 : 0 : struct rte_bbdev_enc_op *ops_ext2_arr[OPS_COUNT];
590 : :
591 : : const char *pool_none = "Test_pool_size";
592 : :
593 : : /* Valid pool configuration */
594 : : uint32_t num_elements = 256;
595 : : uint32_t cache_size = 0;
596 : :
597 : : /* Create mempool type : RTE_BBDEV_OP_TURBO_ENC, size : 256 */
598 : 0 : mp_none = rte_bbdev_op_pool_create(pool_none, RTE_BBDEV_OP_TURBO_ENC,
599 : : num_elements, cache_size, 0);
600 : 0 : TEST_ASSERT(mp_none != NULL, "Failed to create %s mempool", pool_none);
601 : :
602 : : /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
603 : 0 : rte_bbdev_enc_op_alloc_bulk(mp_none, ops_enc_arr, OPS_COUNT);
604 : :
605 : : /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
606 : 0 : TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext_arr,
607 : : OPS_COUNT) == 0,
608 : : "Failed test for allocating bbdev ops: "
609 : : "Mempool size: 256, Free : 128, Attempted to add: 128");
610 : :
611 : : /* Try adding 128 more RTE_BBDEV_OP_TURBO_ENC ops, this should fail */
612 : 0 : TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
613 : : OPS_COUNT) != 0,
614 : : "Failed test for allocating bbdev ops: "
615 : : "Mempool size: 256, Free : 0, Attempted to add: 128");
616 : :
617 : : /* Free-up 128 RTE_BBDEV_OP_TURBO_ENC ops */
618 : 0 : rte_bbdev_enc_op_free_bulk(ops_enc_arr, OPS_COUNT);
619 : :
620 : : /* Try adding 128 RTE_BBDEV_OP_TURBO_DEC ops, this should succeed */
621 : : /* Cache size > 0 causes reallocation of ops size > 127 fail */
622 : 0 : TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
623 : : OPS_COUNT) == 0,
624 : : "Failed test for allocating ops after mempool freed: "
625 : : "Mempool size: 256, Free : 128, Attempted to add: 128");
626 : :
627 : 0 : rte_mempool_free(mp_none);
628 : :
629 : 0 : return TEST_SUCCESS;
630 : : }
631 : :
632 : : static int
633 : 0 : test_bbdev_count(void)
634 : : {
635 : : uint8_t num_devs, num_valid_devs = 0;
636 : :
637 : 0 : for (num_devs = 0; num_devs < RTE_BBDEV_MAX_DEVS; num_devs++) {
638 : 0 : if (rte_bbdev_is_valid(num_devs))
639 : 0 : num_valid_devs++;
640 : : }
641 : :
642 : 0 : num_devs = rte_bbdev_count();
643 : 0 : TEST_ASSERT(num_valid_devs == num_devs,
644 : : "Failed test for rte_bbdev_is_valid: "
645 : : "invalid num_devs %u ", num_devs);
646 : :
647 : : return TEST_SUCCESS;
648 : : }
649 : :
650 : : static int
651 : 0 : test_bbdev_stats(void)
652 : : {
653 : 0 : uint8_t dev_id = null_dev_id;
654 : : uint16_t queue_id = 0;
655 : 0 : struct rte_bbdev_dec_op *dec_ops[4096] = { 0 };
656 : 0 : struct rte_bbdev_dec_op *dec_proc_ops[4096] = { 0 };
657 : 0 : struct rte_bbdev_enc_op *enc_ops[4096] = { 0 };
658 : 0 : struct rte_bbdev_enc_op *enc_proc_ops[4096] = { 0 };
659 : : uint16_t num_ops = 236;
660 : : struct rte_bbdev_stats stats;
661 : : struct bbdev_testsuite_params *ts_params = &testsuite_params;
662 : :
663 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
664 : : "Failed to stop queue %u on device %u ", queue_id,
665 : : dev_id);
666 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
667 : : "Failed to stop bbdev %u ", dev_id);
668 : :
669 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
670 : : &ts_params->qconf),
671 : : "Failed to configure queue %u on device %u ",
672 : : queue_id, dev_id);
673 : :
674 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
675 : : "Failed to start bbdev %u ", dev_id);
676 : :
677 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
678 : : "Failed to start queue %u on device %u ", queue_id,
679 : : dev_id);
680 : :
681 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
682 : : "Failed to start queue %u on device %u ", queue_id,
683 : : dev_id);
684 : :
685 : : /* Tests after enqueue operation */
686 : : rte_bbdev_enqueue_enc_ops(dev_id, queue_id, enc_ops, num_ops);
687 : : rte_bbdev_enqueue_dec_ops(dev_id, queue_id, dec_ops, num_ops);
688 : :
689 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stats_get(RTE_BBDEV_MAX_DEVS, &stats),
690 : : "Failed test for rte_bbdev_stats_get on device %u ",
691 : : dev_id);
692 : :
693 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, NULL),
694 : : "Failed test for rte_bbdev_stats_get on device %u ",
695 : : dev_id);
696 : :
697 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
698 : : "Failed test for rte_bbdev_stats_get on device %u ",
699 : : dev_id);
700 : :
701 : 0 : TEST_ASSERT(stats.enqueued_count == 2 * num_ops,
702 : : "Failed test for rte_bbdev_enqueue_ops: "
703 : : "invalid enqueued_count %" PRIu64 " ",
704 : : stats.enqueued_count);
705 : :
706 : 0 : TEST_ASSERT(stats.dequeued_count == 0,
707 : : "Failed test for rte_bbdev_stats_reset: "
708 : : "invalid dequeued_count %" PRIu64 " ",
709 : : stats.dequeued_count);
710 : :
711 : : /* Tests after dequeue operation */
712 : : rte_bbdev_dequeue_enc_ops(dev_id, queue_id, enc_proc_ops, num_ops);
713 : : rte_bbdev_dequeue_dec_ops(dev_id, queue_id, dec_proc_ops, num_ops);
714 : :
715 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
716 : : "Failed test for rte_bbdev_stats_get on device %u ",
717 : : dev_id);
718 : :
719 : 0 : TEST_ASSERT(stats.dequeued_count == 2 * num_ops,
720 : : "Failed test for rte_bbdev_dequeue_ops: "
721 : : "invalid enqueued_count %" PRIu64 " ",
722 : : stats.dequeued_count);
723 : :
724 : 0 : TEST_ASSERT(stats.enqueue_err_count == 0,
725 : : "Failed test for rte_bbdev_stats_reset: "
726 : : "invalid enqueue_err_count %" PRIu64 " ",
727 : : stats.enqueue_err_count);
728 : :
729 : 0 : TEST_ASSERT(stats.dequeue_err_count == 0,
730 : : "Failed test for rte_bbdev_stats_reset: "
731 : : "invalid dequeue_err_count %" PRIu64 " ",
732 : : stats.dequeue_err_count);
733 : :
734 : : /* Tests after reset operation */
735 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stats_reset(RTE_BBDEV_MAX_DEVS),
736 : : "Failed to reset statistic for device %u ", dev_id);
737 : :
738 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
739 : : "Failed to reset statistic for device %u ", dev_id);
740 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
741 : : "Failed test for rte_bbdev_stats_get on device %u ",
742 : : dev_id);
743 : :
744 : 0 : TEST_ASSERT(stats.enqueued_count == 0,
745 : : "Failed test for rte_bbdev_stats_reset: "
746 : : "invalid enqueued_count %" PRIu64 " ",
747 : : stats.enqueued_count);
748 : :
749 : 0 : TEST_ASSERT(stats.dequeued_count == 0,
750 : : "Failed test for rte_bbdev_stats_reset: "
751 : : "invalid dequeued_count %" PRIu64 " ",
752 : : stats.dequeued_count);
753 : :
754 : 0 : TEST_ASSERT(stats.enqueue_err_count == 0,
755 : : "Failed test for rte_bbdev_stats_reset: "
756 : : "invalid enqueue_err_count %" PRIu64 " ",
757 : : stats.enqueue_err_count);
758 : :
759 : 0 : TEST_ASSERT(stats.dequeue_err_count == 0,
760 : : "Failed test for rte_bbdev_stats_reset: "
761 : : "invalid dequeue_err_count %" PRIu64 " ",
762 : : stats.dequeue_err_count);
763 : :
764 : : return TEST_SUCCESS;
765 : : }
766 : :
767 : : static int
768 : 0 : test_bbdev_driver_init(void)
769 : : {
770 : : struct rte_bbdev *dev1, *dev2;
771 : : const char *name = "dev_name";
772 : : char name_tmp[32];
773 : : int num_devs, num_devs_tmp;
774 : :
775 : 0 : dev1 = rte_bbdev_allocate(NULL);
776 : 0 : TEST_ASSERT(dev1 == NULL,
777 : : "Failed initialize bbdev driver with NULL name");
778 : :
779 : 0 : dev1 = rte_bbdev_allocate(name);
780 : 0 : TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
781 : :
782 : 0 : dev2 = rte_bbdev_allocate(name);
783 : 0 : TEST_ASSERT(dev2 == NULL,
784 : : "Failed to initialize bbdev driver: "
785 : : "driver with the same name has been initialized before");
786 : :
787 : 0 : num_devs = rte_bbdev_count() - 1;
788 : : num_devs_tmp = num_devs;
789 : :
790 : : /* Initialize the maximum amount of devices */
791 : : do {
792 : : sprintf(name_tmp, "%s%i", "name_", num_devs);
793 : 0 : dev2 = rte_bbdev_allocate(name_tmp);
794 : 0 : TEST_ASSERT(dev2 != NULL,
795 : : "Failed to initialize bbdev driver");
796 : 0 : ++num_devs;
797 : 0 : } while (num_devs < (RTE_BBDEV_MAX_DEVS - 1));
798 : :
799 : : sprintf(name_tmp, "%s%i", "name_", num_devs);
800 : 0 : dev2 = rte_bbdev_allocate(name_tmp);
801 : 0 : TEST_ASSERT(dev2 == NULL, "Failed to initialize bbdev driver number %d "
802 : : "more drivers than RTE_BBDEV_MAX_DEVS: %d ", num_devs,
803 : : RTE_BBDEV_MAX_DEVS);
804 : :
805 : : num_devs--;
806 : :
807 : 0 : while (num_devs >= num_devs_tmp) {
808 : : sprintf(name_tmp, "%s%i", "name_", num_devs);
809 : 0 : dev2 = rte_bbdev_get_named_dev(name_tmp);
810 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
811 : : "Failed to uninitialize bbdev driver %s ",
812 : : name_tmp);
813 : 0 : num_devs--;
814 : : }
815 : :
816 : 0 : TEST_ASSERT(dev1->data->dev_id < RTE_BBDEV_MAX_DEVS,
817 : : "Failed test rte_bbdev_allocate: "
818 : : "invalid dev_id %" PRIu8 ", max number of devices %d ",
819 : : dev1->data->dev_id, RTE_BBDEV_MAX_DEVS);
820 : :
821 : 0 : TEST_ASSERT(dev1->state == RTE_BBDEV_INITIALIZED,
822 : : "Failed test rte_bbdev_allocate: "
823 : : "invalid state %d (0 - RTE_BBDEV_UNUSED, 1 - RTE_BBDEV_INITIALIZED",
824 : : dev1->state);
825 : :
826 : 0 : TEST_ASSERT_FAIL(rte_bbdev_release(NULL),
827 : : "Failed to uninitialize bbdev driver with NULL bbdev");
828 : :
829 : : sprintf(name_tmp, "%s", "invalid_name");
830 : 0 : dev2 = rte_bbdev_get_named_dev(name_tmp);
831 : 0 : TEST_ASSERT_FAIL(rte_bbdev_release(dev2),
832 : : "Failed to uninitialize bbdev driver with invalid name");
833 : :
834 : 0 : dev2 = rte_bbdev_get_named_dev(name);
835 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
836 : : "Failed to uninitialize bbdev driver: %s ", name);
837 : :
838 : : return TEST_SUCCESS;
839 : : }
840 : :
841 : : static void
842 : 0 : event_callback(uint16_t dev_id, enum rte_bbdev_event_type type, void *param,
843 : : void *ret_param)
844 : : {
845 : : RTE_SET_USED(dev_id);
846 : : RTE_SET_USED(ret_param);
847 : :
848 : 0 : if (param == NULL)
849 : : return;
850 : :
851 : 0 : if (type == RTE_BBDEV_EVENT_UNKNOWN ||
852 : 0 : type == RTE_BBDEV_EVENT_ERROR ||
853 : 0 : type == RTE_BBDEV_EVENT_MAX)
854 : 0 : *(int *)param = type;
855 : : }
856 : :
857 : : static int
858 : 0 : test_bbdev_callback(void)
859 : : {
860 : : struct rte_bbdev *dev1, *dev2;
861 : : const char *name = "dev_name1";
862 : : const char *name2 = "dev_name2";
863 : : int event_status;
864 : : uint8_t invalid_dev_id = RTE_BBDEV_MAX_DEVS;
865 : : enum rte_bbdev_event_type invalid_event_type = RTE_BBDEV_EVENT_MAX;
866 : : uint8_t dev_id;
867 : :
868 : 0 : dev1 = rte_bbdev_allocate(name);
869 : 0 : TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
870 : :
871 : : /*
872 : : * RTE_BBDEV_EVENT_UNKNOWN - unregistered
873 : : * RTE_BBDEV_EVENT_ERROR - unregistered
874 : : */
875 : 0 : event_status = -1;
876 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
877 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
878 : 0 : TEST_ASSERT(event_status == -1,
879 : : "Failed test for rte_bbdev_pmd_callback_process: "
880 : : "events were not registered ");
881 : :
882 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
883 : : RTE_BBDEV_EVENT_MAX, event_callback, NULL),
884 : : "Failed to callback register for RTE_BBDEV_EVENT_MAX ");
885 : :
886 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
887 : : RTE_BBDEV_EVENT_MAX, event_callback, NULL),
888 : : "Failed to unregister RTE_BBDEV_EVENT_MAX ");
889 : :
890 : : /*
891 : : * RTE_BBDEV_EVENT_UNKNOWN - registered
892 : : * RTE_BBDEV_EVENT_ERROR - unregistered
893 : : */
894 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
895 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
896 : : "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
897 : :
898 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
899 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
900 : : "Failed test for rte_bbdev_pmd_callback_process "
901 : : "for RTE_BBDEV_EVENT_UNKNOWN ");
902 : :
903 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
904 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
905 : : "Failed test for rte_bbdev_pmd_callback_process: "
906 : : "event RTE_BBDEV_EVENT_ERROR was not registered ");
907 : :
908 : : /*
909 : : * RTE_BBDEV_EVENT_UNKNOWN - registered
910 : : * RTE_BBDEV_EVENT_ERROR - registered
911 : : */
912 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
913 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
914 : : "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR ");
915 : :
916 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
917 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
918 : : "Failed to callback register for RTE_BBDEV_EVENT_ERROR"
919 : : "(re-registration) ");
920 : :
921 : 0 : event_status = -1;
922 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
923 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
924 : : "Failed test for rte_bbdev_pmd_callback_process "
925 : : "for RTE_BBDEV_EVENT_UNKNOWN ");
926 : :
927 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
928 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_ERROR,
929 : : "Failed test for rte_bbdev_pmd_callback_process "
930 : : "for RTE_BBDEV_EVENT_ERROR ");
931 : :
932 : : /*
933 : : * RTE_BBDEV_EVENT_UNKNOWN - registered
934 : : * RTE_BBDEV_EVENT_ERROR - unregistered
935 : : */
936 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev1->data->dev_id,
937 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
938 : : "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
939 : :
940 : 0 : event_status = -1;
941 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
942 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
943 : : "Failed test for rte_bbdev_pmd_callback_process "
944 : : "for RTE_BBDEV_EVENT_UNKNOWN ");
945 : :
946 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
947 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
948 : : "Failed test for rte_bbdev_pmd_callback_process: "
949 : : "event RTE_BBDEV_EVENT_ERROR was unregistered ");
950 : :
951 : : /* rte_bbdev_callback_register with invalid inputs */
952 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_register(invalid_dev_id,
953 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
954 : : "Failed test for rte_bbdev_callback_register "
955 : : "for invalid_dev_id ");
956 : :
957 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
958 : : invalid_event_type, event_callback, &event_status),
959 : : "Failed to callback register for invalid event type ");
960 : :
961 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
962 : : RTE_BBDEV_EVENT_ERROR, NULL, &event_status),
963 : : "Failed to callback register - no callback function ");
964 : :
965 : : /* The impact of devices on each other */
966 : 0 : dev2 = rte_bbdev_allocate(name2);
967 : 0 : TEST_ASSERT(dev2 != NULL,
968 : : "Failed to initialize bbdev driver");
969 : :
970 : : /*
971 : : * dev2:
972 : : * RTE_BBDEV_EVENT_UNKNOWN - unregistered
973 : : * RTE_BBDEV_EVENT_ERROR - unregistered
974 : : */
975 : 0 : event_status = -1;
976 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
977 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
978 : 0 : TEST_ASSERT(event_status == -1,
979 : : "Failed test for rte_bbdev_pmd_callback_process: "
980 : : "events were not registered ");
981 : :
982 : : /*
983 : : * dev1: RTE_BBDEV_EVENT_ERROR - unregistered
984 : : * dev2: RTE_BBDEV_EVENT_ERROR - registered
985 : : */
986 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
987 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
988 : : "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR");
989 : :
990 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
991 : 0 : TEST_ASSERT(event_status == -1,
992 : : "Failed test for rte_bbdev_pmd_callback_process in dev1 "
993 : : "for RTE_BBDEV_EVENT_ERROR ");
994 : :
995 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
996 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_ERROR,
997 : : "Failed test for rte_bbdev_pmd_callback_process in dev2 "
998 : : "for RTE_BBDEV_EVENT_ERROR ");
999 : :
1000 : : /*
1001 : : * dev1: RTE_BBDEV_EVENT_UNKNOWN - registered
1002 : : * dev2: RTE_BBDEV_EVENT_UNKNOWN - unregistered
1003 : : */
1004 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
1005 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1006 : : "Failed to callback register for RTE_BBDEV_EVENT_UNKNOWN "
1007 : : "in dev 2 ");
1008 : :
1009 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1010 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
1011 : : "Failed test for rte_bbdev_pmd_callback_process in dev2"
1012 : : " for RTE_BBDEV_EVENT_UNKNOWN ");
1013 : :
1014 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1015 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1016 : : "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN ");
1017 : :
1018 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1019 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1020 : : "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN : "
1021 : : "unregister function called once again ");
1022 : :
1023 : 0 : event_status = -1;
1024 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1025 : 0 : TEST_ASSERT(event_status == -1,
1026 : : "Failed test for rte_bbdev_pmd_callback_process in dev2"
1027 : : " for RTE_BBDEV_EVENT_UNKNOWN ");
1028 : :
1029 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1030 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
1031 : : "Failed test for rte_bbdev_pmd_callback_process in dev2 "
1032 : : "for RTE_BBDEV_EVENT_UNKNOWN ");
1033 : :
1034 : : /* rte_bbdev_pmd_callback_process with invalid inputs */
1035 : 0 : rte_bbdev_pmd_callback_process(NULL, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1036 : :
1037 : 0 : event_status = -1;
1038 : 0 : rte_bbdev_pmd_callback_process(dev1, invalid_event_type, NULL);
1039 : 0 : TEST_ASSERT(event_status == -1,
1040 : : "Failed test for rte_bbdev_pmd_callback_process: "
1041 : : "for invalid event type ");
1042 : :
1043 : : /* rte_dev_callback_unregister with invalid inputs */
1044 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(invalid_dev_id,
1045 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1046 : : "Failed test for rte_dev_callback_unregister "
1047 : : "for invalid_dev_id ");
1048 : :
1049 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1050 : : invalid_event_type, event_callback, &event_status),
1051 : : "Failed rte_dev_callback_unregister "
1052 : : "for invalid event type ");
1053 : :
1054 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1055 : : invalid_event_type, NULL, &event_status),
1056 : : "Failed rte_dev_callback_unregister "
1057 : : "when no callback function ");
1058 : :
1059 : 0 : dev_id = dev1->data->dev_id;
1060 : :
1061 : 0 : rte_bbdev_release(dev1);
1062 : 0 : rte_bbdev_release(dev2);
1063 : :
1064 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev_id,
1065 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1066 : : "Failed test for rte_bbdev_callback_register: "
1067 : : "function called after rte_bbdev_driver_uninit .");
1068 : :
1069 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev_id,
1070 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1071 : : "Failed test for rte_dev_callback_unregister: "
1072 : : "function called after rte_bbdev_driver_uninit. ");
1073 : :
1074 : 0 : event_status = -1;
1075 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1076 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
1077 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1078 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
1079 : 0 : TEST_ASSERT(event_status == -1,
1080 : : "Failed test for rte_bbdev_pmd_callback_process: "
1081 : : "callback function was called after rte_bbdev_driver_uninit");
1082 : :
1083 : : return TEST_SUCCESS;
1084 : : }
1085 : :
1086 : : static int
1087 : 0 : test_bbdev_invalid_driver(void)
1088 : : {
1089 : : struct rte_bbdev dev1, *dev2;
1090 : 0 : uint8_t dev_id = null_dev_id;
1091 : : uint16_t queue_id = 0;
1092 : : struct rte_bbdev_stats stats;
1093 : : struct bbdev_testsuite_params *ts_params = &testsuite_params;
1094 : : struct rte_bbdev_queue_info qinfo;
1095 : : struct rte_bbdev_ops dev_ops_tmp;
1096 : :
1097 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u ",
1098 : : dev_id);
1099 : :
1100 : 0 : dev1 = rte_bbdev_devices[dev_id];
1101 : 0 : dev2 = &rte_bbdev_devices[dev_id];
1102 : :
1103 : : /* Tests for rte_bbdev_setup_queues */
1104 : 0 : dev2->dev_ops = NULL;
1105 : 0 : TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1106 : : "Failed test for rte_bbdev_setup_queues: "
1107 : : "NULL dev_ops structure ");
1108 : : dev2->dev_ops = dev1.dev_ops;
1109 : :
1110 : 0 : dev_ops_tmp = *dev2->dev_ops;
1111 : 0 : dev_ops_tmp.info_get = NULL;
1112 : 0 : dev2->dev_ops = &dev_ops_tmp;
1113 : 0 : TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1114 : : "Failed test for rte_bbdev_setup_queues: "
1115 : : "NULL info_get ");
1116 : : dev2->dev_ops = dev1.dev_ops;
1117 : :
1118 : 0 : dev_ops_tmp = *dev2->dev_ops;
1119 : 0 : dev_ops_tmp.queue_release = NULL;
1120 : 0 : dev2->dev_ops = &dev_ops_tmp;
1121 : 0 : TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1122 : : "Failed test for rte_bbdev_setup_queues: "
1123 : : "NULL queue_release ");
1124 : 0 : dev2->dev_ops = dev1.dev_ops;
1125 : :
1126 : 0 : dev2->data->socket_id = SOCKET_ID_ANY;
1127 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, 1,
1128 : : SOCKET_ID_ANY), "Failed to configure bbdev %u", dev_id);
1129 : :
1130 : : /* Test for rte_bbdev_queue_configure */
1131 : 0 : dev2->dev_ops = NULL;
1132 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1133 : : &ts_params->qconf),
1134 : : "Failed to configure queue %u on device %u "
1135 : : "with NULL dev_ops structure ", queue_id, dev_id);
1136 : : dev2->dev_ops = dev1.dev_ops;
1137 : :
1138 : 0 : dev_ops_tmp = *dev2->dev_ops;
1139 : 0 : dev_ops_tmp.queue_setup = NULL;
1140 : 0 : dev2->dev_ops = &dev_ops_tmp;
1141 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1142 : : &ts_params->qconf),
1143 : : "Failed to configure queue %u on device %u "
1144 : : "with NULL queue_setup ", queue_id, dev_id);
1145 : : dev2->dev_ops = dev1.dev_ops;
1146 : :
1147 : 0 : dev_ops_tmp = *dev2->dev_ops;
1148 : 0 : dev_ops_tmp.info_get = NULL;
1149 : 0 : dev2->dev_ops = &dev_ops_tmp;
1150 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1151 : : &ts_params->qconf),
1152 : : "Failed to configure queue %u on device %u "
1153 : : "with NULL info_get ", queue_id, dev_id);
1154 : 0 : dev2->dev_ops = dev1.dev_ops;
1155 : :
1156 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS,
1157 : : queue_id, &ts_params->qconf),
1158 : : "Failed to configure queue %u on device %u ",
1159 : : queue_id, dev_id);
1160 : :
1161 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
1162 : : &ts_params->qconf),
1163 : : "Failed to configure queue %u on device %u ",
1164 : : queue_id, dev_id);
1165 : :
1166 : : /* Test for rte_bbdev_queue_info_get */
1167 : 0 : dev2->dev_ops = NULL;
1168 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_info_get(dev_id, queue_id, &qinfo),
1169 : : "Failed test for rte_bbdev_info_get: "
1170 : : "NULL dev_ops structure ");
1171 : 0 : dev2->dev_ops = dev1.dev_ops;
1172 : :
1173 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(RTE_BBDEV_MAX_DEVS,
1174 : : queue_id, &qinfo),
1175 : : "Failed test for rte_bbdev_info_get: "
1176 : : "invalid dev_id ");
1177 : :
1178 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id,
1179 : : RTE_MAX_QUEUES_PER_PORT, &qinfo),
1180 : : "Failed test for rte_bbdev_info_get: "
1181 : : "invalid queue_id ");
1182 : :
1183 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id, queue_id, NULL),
1184 : : "Failed test for rte_bbdev_info_get: "
1185 : : "invalid dev_info ");
1186 : :
1187 : : /* Test for rte_bbdev_start */
1188 : 0 : dev2->dev_ops = NULL;
1189 : 0 : TEST_ASSERT_FAIL(rte_bbdev_start(dev_id),
1190 : : "Failed to start bbdev %u "
1191 : : "with NULL dev_ops structure ", dev_id);
1192 : 0 : dev2->dev_ops = dev1.dev_ops;
1193 : :
1194 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
1195 : : "Failed to start bbdev %u ", dev_id);
1196 : :
1197 : : /* Test for rte_bbdev_queue_start */
1198 : 0 : dev2->dev_ops = NULL;
1199 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_start(dev_id, queue_id),
1200 : : "Failed to start queue %u on device %u: "
1201 : : "NULL dev_ops structure", queue_id, dev_id);
1202 : 0 : dev2->dev_ops = dev1.dev_ops;
1203 : :
1204 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
1205 : : "Failed to start queue %u on device %u ", queue_id,
1206 : : dev_id);
1207 : :
1208 : : /* Tests for rte_bbdev_stats_get */
1209 : 0 : dev2->dev_ops = NULL;
1210 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, &stats),
1211 : : "Failed test for rte_bbdev_stats_get on device %u ",
1212 : : dev_id);
1213 : : dev2->dev_ops = dev1.dev_ops;
1214 : :
1215 : 0 : dev_ops_tmp = *dev2->dev_ops;
1216 : 0 : dev_ops_tmp.stats_reset = NULL;
1217 : 0 : dev2->dev_ops = &dev_ops_tmp;
1218 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1219 : : "Failed test for rte_bbdev_stats_get: "
1220 : : "NULL stats_get ");
1221 : 0 : dev2->dev_ops = dev1.dev_ops;
1222 : :
1223 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1224 : : "Failed test for rte_bbdev_stats_get on device %u ",
1225 : : dev_id);
1226 : :
1227 : : /*
1228 : : * Tests for:
1229 : : * rte_bbdev_callback_register,
1230 : : * rte_bbdev_pmd_callback_process,
1231 : : * rte_dev_callback_unregister
1232 : : */
1233 : 0 : dev2->dev_ops = NULL;
1234 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev_id,
1235 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1236 : : "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
1237 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1238 : :
1239 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev_id,
1240 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1241 : : "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
1242 : :
1243 : : /* Tests for rte_bbdev_stats_reset */
1244 : 0 : dev2->dev_ops = NULL;
1245 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stats_reset(dev_id),
1246 : : "Failed to reset statistic for device %u ", dev_id);
1247 : : dev2->dev_ops = dev1.dev_ops;
1248 : :
1249 : 0 : dev_ops_tmp = *dev2->dev_ops;
1250 : 0 : dev_ops_tmp.stats_reset = NULL;
1251 : 0 : dev2->dev_ops = &dev_ops_tmp;
1252 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1253 : : "Failed test for rte_bbdev_stats_reset: "
1254 : : "NULL stats_reset ");
1255 : 0 : dev2->dev_ops = dev1.dev_ops;
1256 : :
1257 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1258 : : "Failed to reset statistic for device %u ", dev_id);
1259 : :
1260 : : /* Tests for rte_bbdev_queue_stop */
1261 : 0 : dev2->dev_ops = NULL;
1262 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, queue_id),
1263 : : "Failed to stop queue %u on device %u: "
1264 : : "NULL dev_ops structure", queue_id, dev_id);
1265 : 0 : dev2->dev_ops = dev1.dev_ops;
1266 : :
1267 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
1268 : : "Failed to stop queue %u on device %u ", queue_id,
1269 : : dev_id);
1270 : :
1271 : : /* Tests for rte_bbdev_stop */
1272 : 0 : dev2->dev_ops = NULL;
1273 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stop(dev_id),
1274 : : "Failed to stop bbdev %u with NULL dev_ops structure ",
1275 : : dev_id);
1276 : 0 : dev2->dev_ops = dev1.dev_ops;
1277 : :
1278 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
1279 : : "Failed to stop bbdev %u ", dev_id);
1280 : :
1281 : : /* Tests for rte_bbdev_close */
1282 : 0 : TEST_ASSERT_FAIL(rte_bbdev_close(RTE_BBDEV_MAX_DEVS),
1283 : : "Failed to close bbdev with invalid dev_id");
1284 : :
1285 : 0 : dev2->dev_ops = NULL;
1286 : 0 : TEST_ASSERT_FAIL(rte_bbdev_close(dev_id),
1287 : : "Failed to close bbdev %u with NULL dev_ops structure ",
1288 : : dev_id);
1289 : 0 : dev2->dev_ops = dev1.dev_ops;
1290 : :
1291 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_close(dev_id),
1292 : : "Failed to close bbdev %u ", dev_id);
1293 : :
1294 : : return TEST_SUCCESS;
1295 : : }
1296 : :
1297 : : static int
1298 : 0 : test_bbdev_get_named_dev(void)
1299 : : {
1300 : : struct rte_bbdev *dev, *dev_tmp;
1301 : : const char *name = "name";
1302 : :
1303 : 0 : dev = rte_bbdev_allocate(name);
1304 : 0 : TEST_ASSERT(dev != NULL, "Failed to initialize bbdev driver");
1305 : :
1306 : 0 : dev_tmp = rte_bbdev_get_named_dev(NULL);
1307 : 0 : TEST_ASSERT(dev_tmp == NULL, "Failed test for rte_bbdev_get_named_dev: "
1308 : : "function called with NULL parameter");
1309 : :
1310 : 0 : dev_tmp = rte_bbdev_get_named_dev(name);
1311 : :
1312 : 0 : TEST_ASSERT(dev == dev_tmp, "Failed test for rte_bbdev_get_named_dev: "
1313 : : "wrong device was returned ");
1314 : :
1315 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_release(dev),
1316 : : "Failed to uninitialize bbdev driver %s ", name);
1317 : :
1318 : : return TEST_SUCCESS;
1319 : : }
1320 : :
1321 : : static struct unit_test_suite bbdev_null_testsuite = {
1322 : : .suite_name = "BBDEV NULL Unit Test Suite",
1323 : : .setup = testsuite_setup,
1324 : : .teardown = testsuite_teardown,
1325 : : .unit_test_cases = {
1326 : :
1327 : : TEST_CASE(test_bbdev_configure_invalid_dev_id),
1328 : :
1329 : : TEST_CASE_ST(ut_setup, ut_teardown,
1330 : : test_bbdev_configure_invalid_num_queues),
1331 : :
1332 : : TEST_CASE_ST(ut_setup, ut_teardown,
1333 : : test_bbdev_configure_stop_device),
1334 : :
1335 : : TEST_CASE_ST(ut_setup, ut_teardown,
1336 : : test_bbdev_configure_stop_queue),
1337 : :
1338 : : TEST_CASE_ST(ut_setup, ut_teardown,
1339 : : test_bbdev_configure_invalid_queue_configure),
1340 : :
1341 : : TEST_CASE_ST(ut_setup, ut_teardown,
1342 : : test_bbdev_op_pool),
1343 : :
1344 : : TEST_CASE_ST(ut_setup, ut_teardown,
1345 : : test_bbdev_op_type),
1346 : :
1347 : : TEST_CASE_ST(ut_setup, ut_teardown,
1348 : : test_bbdev_op_pool_size),
1349 : :
1350 : : TEST_CASE_ST(ut_setup, ut_teardown,
1351 : : test_bbdev_stats),
1352 : :
1353 : : TEST_CASE_ST(ut_setup, ut_teardown,
1354 : : test_bbdev_driver_init),
1355 : :
1356 : : TEST_CASE_ST(ut_setup, ut_teardown,
1357 : : test_bbdev_callback),
1358 : :
1359 : : TEST_CASE_ST(ut_setup, ut_teardown,
1360 : : test_bbdev_invalid_driver),
1361 : :
1362 : : TEST_CASE_ST(ut_setup, ut_teardown,
1363 : : test_bbdev_get_named_dev),
1364 : :
1365 : : TEST_CASE(test_bbdev_count),
1366 : :
1367 : : TEST_CASES_END() /**< NULL terminate unit test array */
1368 : : }
1369 : : };
1370 : :
1371 : 0 : REGISTER_TEST_COMMAND(unittest, bbdev_null_testsuite);
|
