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 : : {
551 : : #define OPS_COUNT 32
552 : : struct rte_mempool *mp_dec;
553 : :
554 : : struct rte_bbdev_dec_op *dec_ops_arr[OPS_COUNT];
555 : : 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 : : #undef OPS_COUNT
580 : : }
581 : :
582 : : static int
583 : 0 : test_bbdev_op_pool_size(void)
584 : : {
585 : : #define OPS_COUNT 128
586 : : struct rte_mempool *mp_none;
587 : :
588 : : struct rte_bbdev_enc_op *ops_enc_arr[OPS_COUNT];
589 : : struct rte_bbdev_enc_op *ops_ext_arr[OPS_COUNT];
590 : : struct rte_bbdev_enc_op *ops_ext2_arr[OPS_COUNT];
591 : :
592 : : const char *pool_none = "Test_pool_size";
593 : :
594 : : /* Valid pool configuration */
595 : : uint32_t num_elements = 256;
596 : : uint32_t cache_size = 0;
597 : :
598 : : /* Create mempool type : RTE_BBDEV_OP_TURBO_ENC, size : 256 */
599 : 0 : mp_none = rte_bbdev_op_pool_create(pool_none, RTE_BBDEV_OP_TURBO_ENC,
600 : : num_elements, cache_size, 0);
601 : 0 : TEST_ASSERT(mp_none != NULL, "Failed to create %s mempool", pool_none);
602 : :
603 : : /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
604 : 0 : rte_bbdev_enc_op_alloc_bulk(mp_none, ops_enc_arr, OPS_COUNT);
605 : :
606 : : /* Add 128 RTE_BBDEV_OP_TURBO_ENC ops */
607 : 0 : TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext_arr,
608 : : OPS_COUNT) == 0,
609 : : "Failed test for allocating bbdev ops: "
610 : : "Mempool size: 256, Free : 128, Attempted to add: 128");
611 : :
612 : : /* Try adding 128 more RTE_BBDEV_OP_TURBO_ENC ops, this should fail */
613 : 0 : TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
614 : : OPS_COUNT) != 0,
615 : : "Failed test for allocating bbdev ops: "
616 : : "Mempool size: 256, Free : 0, Attempted to add: 128");
617 : :
618 : : /* Free-up 128 RTE_BBDEV_OP_TURBO_ENC ops */
619 : 0 : rte_bbdev_enc_op_free_bulk(ops_enc_arr, OPS_COUNT);
620 : :
621 : : /* Try adding 128 RTE_BBDEV_OP_TURBO_DEC ops, this should succeed */
622 : : /* Cache size > 0 causes reallocation of ops size > 127 fail */
623 : 0 : TEST_ASSERT(rte_bbdev_enc_op_alloc_bulk(mp_none, ops_ext2_arr,
624 : : OPS_COUNT) == 0,
625 : : "Failed test for allocating ops after mempool freed: "
626 : : "Mempool size: 256, Free : 128, Attempted to add: 128");
627 : :
628 : 0 : rte_mempool_free(mp_none);
629 : :
630 : 0 : return TEST_SUCCESS;
631 : : #undef OPS_COUNT
632 : : }
633 : :
634 : : static int
635 : 0 : test_bbdev_count(void)
636 : : {
637 : : uint8_t num_devs, num_valid_devs = 0;
638 : :
639 : 0 : for (num_devs = 0; num_devs < RTE_BBDEV_MAX_DEVS; num_devs++) {
640 : 0 : if (rte_bbdev_is_valid(num_devs))
641 : 0 : num_valid_devs++;
642 : : }
643 : :
644 : 0 : num_devs = rte_bbdev_count();
645 : 0 : TEST_ASSERT(num_valid_devs == num_devs,
646 : : "Failed test for rte_bbdev_is_valid: "
647 : : "invalid num_devs %u ", num_devs);
648 : :
649 : : return TEST_SUCCESS;
650 : : }
651 : :
652 : : static int
653 : 0 : test_bbdev_stats(void)
654 : : {
655 : 0 : uint8_t dev_id = null_dev_id;
656 : : uint16_t queue_id = 0;
657 : 0 : struct rte_bbdev_dec_op *dec_ops[4096] = { 0 };
658 : 0 : struct rte_bbdev_dec_op *dec_proc_ops[4096] = { 0 };
659 : 0 : struct rte_bbdev_enc_op *enc_ops[4096] = { 0 };
660 : 0 : struct rte_bbdev_enc_op *enc_proc_ops[4096] = { 0 };
661 : : uint16_t num_ops = 236;
662 : : struct rte_bbdev_stats stats;
663 : : struct bbdev_testsuite_params *ts_params = &testsuite_params;
664 : :
665 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
666 : : "Failed to stop queue %u on device %u ", queue_id,
667 : : dev_id);
668 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
669 : : "Failed to stop bbdev %u ", dev_id);
670 : :
671 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
672 : : &ts_params->qconf),
673 : : "Failed to configure queue %u on device %u ",
674 : : queue_id, dev_id);
675 : :
676 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
677 : : "Failed to start bbdev %u ", dev_id);
678 : :
679 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
680 : : "Failed to start queue %u on device %u ", queue_id,
681 : : dev_id);
682 : :
683 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
684 : : "Failed to start queue %u on device %u ", queue_id,
685 : : dev_id);
686 : :
687 : : /* Tests after enqueue operation */
688 : 0 : rte_bbdev_enqueue_enc_ops(dev_id, queue_id, enc_ops, num_ops);
689 : 0 : rte_bbdev_enqueue_dec_ops(dev_id, queue_id, dec_ops, num_ops);
690 : :
691 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stats_get(RTE_BBDEV_MAX_DEVS, &stats),
692 : : "Failed test for rte_bbdev_stats_get on device %u ",
693 : : dev_id);
694 : :
695 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, NULL),
696 : : "Failed test for rte_bbdev_stats_get on device %u ",
697 : : dev_id);
698 : :
699 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
700 : : "Failed test for rte_bbdev_stats_get on device %u ",
701 : : dev_id);
702 : :
703 : 0 : TEST_ASSERT(stats.enqueued_count == 2 * num_ops,
704 : : "Failed test for rte_bbdev_enqueue_ops: "
705 : : "invalid enqueued_count %" PRIu64 " ",
706 : : stats.enqueued_count);
707 : :
708 : 0 : TEST_ASSERT(stats.dequeued_count == 0,
709 : : "Failed test for rte_bbdev_stats_reset: "
710 : : "invalid dequeued_count %" PRIu64 " ",
711 : : stats.dequeued_count);
712 : :
713 : : /* Tests after dequeue operation */
714 : 0 : rte_bbdev_dequeue_enc_ops(dev_id, queue_id, enc_proc_ops, num_ops);
715 : 0 : rte_bbdev_dequeue_dec_ops(dev_id, queue_id, dec_proc_ops, num_ops);
716 : :
717 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
718 : : "Failed test for rte_bbdev_stats_get on device %u ",
719 : : dev_id);
720 : :
721 : 0 : TEST_ASSERT(stats.dequeued_count == 2 * num_ops,
722 : : "Failed test for rte_bbdev_dequeue_ops: "
723 : : "invalid enqueued_count %" PRIu64 " ",
724 : : stats.dequeued_count);
725 : :
726 : 0 : TEST_ASSERT(stats.enqueue_err_count == 0,
727 : : "Failed test for rte_bbdev_stats_reset: "
728 : : "invalid enqueue_err_count %" PRIu64 " ",
729 : : stats.enqueue_err_count);
730 : :
731 : 0 : TEST_ASSERT(stats.dequeue_err_count == 0,
732 : : "Failed test for rte_bbdev_stats_reset: "
733 : : "invalid dequeue_err_count %" PRIu64 " ",
734 : : stats.dequeue_err_count);
735 : :
736 : : /* Tests after reset operation */
737 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stats_reset(RTE_BBDEV_MAX_DEVS),
738 : : "Failed to reset statistic for device %u ", dev_id);
739 : :
740 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
741 : : "Failed to reset statistic for device %u ", dev_id);
742 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
743 : : "Failed test for rte_bbdev_stats_get on device %u ",
744 : : dev_id);
745 : :
746 : 0 : TEST_ASSERT(stats.enqueued_count == 0,
747 : : "Failed test for rte_bbdev_stats_reset: "
748 : : "invalid enqueued_count %" PRIu64 " ",
749 : : stats.enqueued_count);
750 : :
751 : 0 : TEST_ASSERT(stats.dequeued_count == 0,
752 : : "Failed test for rte_bbdev_stats_reset: "
753 : : "invalid dequeued_count %" PRIu64 " ",
754 : : stats.dequeued_count);
755 : :
756 : 0 : TEST_ASSERT(stats.enqueue_err_count == 0,
757 : : "Failed test for rte_bbdev_stats_reset: "
758 : : "invalid enqueue_err_count %" PRIu64 " ",
759 : : stats.enqueue_err_count);
760 : :
761 : 0 : TEST_ASSERT(stats.dequeue_err_count == 0,
762 : : "Failed test for rte_bbdev_stats_reset: "
763 : : "invalid dequeue_err_count %" PRIu64 " ",
764 : : stats.dequeue_err_count);
765 : :
766 : : return TEST_SUCCESS;
767 : : }
768 : :
769 : : static int
770 : 0 : test_bbdev_driver_init(void)
771 : : {
772 : : struct rte_bbdev *dev1, *dev2;
773 : : const char *name = "dev_name";
774 : : char name_tmp[32];
775 : : int num_devs, num_devs_tmp;
776 : :
777 : 0 : dev1 = rte_bbdev_allocate(NULL);
778 : 0 : TEST_ASSERT(dev1 == NULL,
779 : : "Failed initialize bbdev driver with NULL name");
780 : :
781 : 0 : dev1 = rte_bbdev_allocate(name);
782 : 0 : TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
783 : :
784 : 0 : dev2 = rte_bbdev_allocate(name);
785 : 0 : TEST_ASSERT(dev2 == NULL,
786 : : "Failed to initialize bbdev driver: "
787 : : "driver with the same name has been initialized before");
788 : :
789 : 0 : num_devs = rte_bbdev_count() - 1;
790 : : num_devs_tmp = num_devs;
791 : :
792 : : /* Initialize the maximum amount of devices */
793 : : do {
794 : : sprintf(name_tmp, "%s%i", "name_", num_devs);
795 : 0 : dev2 = rte_bbdev_allocate(name_tmp);
796 : 0 : TEST_ASSERT(dev2 != NULL,
797 : : "Failed to initialize bbdev driver");
798 : 0 : ++num_devs;
799 : 0 : } while (num_devs < (RTE_BBDEV_MAX_DEVS - 1));
800 : :
801 : : sprintf(name_tmp, "%s%i", "name_", num_devs);
802 : 0 : dev2 = rte_bbdev_allocate(name_tmp);
803 : 0 : TEST_ASSERT(dev2 == NULL, "Failed to initialize bbdev driver number %d "
804 : : "more drivers than RTE_BBDEV_MAX_DEVS: %d ", num_devs,
805 : : RTE_BBDEV_MAX_DEVS);
806 : :
807 : : num_devs--;
808 : :
809 : 0 : while (num_devs >= num_devs_tmp) {
810 : : sprintf(name_tmp, "%s%i", "name_", num_devs);
811 : 0 : dev2 = rte_bbdev_get_named_dev(name_tmp);
812 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
813 : : "Failed to uninitialize bbdev driver %s ",
814 : : name_tmp);
815 : 0 : num_devs--;
816 : : }
817 : :
818 : 0 : TEST_ASSERT(dev1->data->dev_id < RTE_BBDEV_MAX_DEVS,
819 : : "Failed test rte_bbdev_allocate: "
820 : : "invalid dev_id %" PRIu16 ", max number of devices %d ",
821 : : dev1->data->dev_id, RTE_BBDEV_MAX_DEVS);
822 : :
823 : 0 : TEST_ASSERT(dev1->state == RTE_BBDEV_INITIALIZED,
824 : : "Failed test rte_bbdev_allocate: "
825 : : "invalid state %d (0 - RTE_BBDEV_UNUSED, 1 - RTE_BBDEV_INITIALIZED",
826 : : dev1->state);
827 : :
828 : 0 : TEST_ASSERT_FAIL(rte_bbdev_release(NULL),
829 : : "Failed to uninitialize bbdev driver with NULL bbdev");
830 : :
831 : : sprintf(name_tmp, "%s", "invalid_name");
832 : 0 : dev2 = rte_bbdev_get_named_dev(name_tmp);
833 : 0 : TEST_ASSERT_FAIL(rte_bbdev_release(dev2),
834 : : "Failed to uninitialize bbdev driver with invalid name");
835 : :
836 : 0 : dev2 = rte_bbdev_get_named_dev(name);
837 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_release(dev2),
838 : : "Failed to uninitialize bbdev driver: %s ", name);
839 : :
840 : : return TEST_SUCCESS;
841 : : }
842 : :
843 : : static void
844 : 0 : event_callback(uint16_t dev_id, enum rte_bbdev_event_type type, void *param,
845 : : void *ret_param)
846 : : {
847 : : RTE_SET_USED(dev_id);
848 : : RTE_SET_USED(ret_param);
849 : :
850 : 0 : if (param == NULL)
851 : : return;
852 : :
853 : 0 : if (type == RTE_BBDEV_EVENT_UNKNOWN ||
854 : 0 : type == RTE_BBDEV_EVENT_ERROR ||
855 : 0 : type == RTE_BBDEV_EVENT_MAX)
856 : 0 : *(int *)param = type;
857 : : }
858 : :
859 : : static int
860 : 0 : test_bbdev_callback(void)
861 : : {
862 : : struct rte_bbdev *dev1, *dev2;
863 : : const char *name = "dev_name1";
864 : : const char *name2 = "dev_name2";
865 : : int event_status;
866 : : uint8_t invalid_dev_id = RTE_BBDEV_MAX_DEVS;
867 : : enum rte_bbdev_event_type invalid_event_type = RTE_BBDEV_EVENT_MAX;
868 : : uint8_t dev_id;
869 : :
870 : 0 : dev1 = rte_bbdev_allocate(name);
871 : 0 : TEST_ASSERT(dev1 != NULL, "Failed to initialize bbdev driver");
872 : :
873 : : /*
874 : : * RTE_BBDEV_EVENT_UNKNOWN - unregistered
875 : : * RTE_BBDEV_EVENT_ERROR - unregistered
876 : : */
877 : 0 : event_status = -1;
878 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
879 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
880 : 0 : TEST_ASSERT(event_status == -1,
881 : : "Failed test for rte_bbdev_pmd_callback_process: "
882 : : "events were not registered ");
883 : :
884 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
885 : : RTE_BBDEV_EVENT_MAX, event_callback, NULL),
886 : : "Failed to callback register for RTE_BBDEV_EVENT_MAX ");
887 : :
888 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
889 : : RTE_BBDEV_EVENT_MAX, event_callback, NULL),
890 : : "Failed to unregister RTE_BBDEV_EVENT_MAX ");
891 : :
892 : : /*
893 : : * RTE_BBDEV_EVENT_UNKNOWN - registered
894 : : * RTE_BBDEV_EVENT_ERROR - unregistered
895 : : */
896 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
897 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
898 : : "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
899 : :
900 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
901 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
902 : : "Failed test for rte_bbdev_pmd_callback_process "
903 : : "for RTE_BBDEV_EVENT_UNKNOWN ");
904 : :
905 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
906 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
907 : : "Failed test for rte_bbdev_pmd_callback_process: "
908 : : "event RTE_BBDEV_EVENT_ERROR was not registered ");
909 : :
910 : : /*
911 : : * RTE_BBDEV_EVENT_UNKNOWN - registered
912 : : * RTE_BBDEV_EVENT_ERROR - registered
913 : : */
914 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
915 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
916 : : "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR ");
917 : :
918 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev1->data->dev_id,
919 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
920 : : "Failed to callback register for RTE_BBDEV_EVENT_ERROR"
921 : : "(re-registration) ");
922 : :
923 : 0 : event_status = -1;
924 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
925 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
926 : : "Failed test for rte_bbdev_pmd_callback_process "
927 : : "for RTE_BBDEV_EVENT_UNKNOWN ");
928 : :
929 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
930 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_ERROR,
931 : : "Failed test for rte_bbdev_pmd_callback_process "
932 : : "for RTE_BBDEV_EVENT_ERROR ");
933 : :
934 : : /*
935 : : * RTE_BBDEV_EVENT_UNKNOWN - registered
936 : : * RTE_BBDEV_EVENT_ERROR - unregistered
937 : : */
938 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev1->data->dev_id,
939 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
940 : : "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
941 : :
942 : 0 : event_status = -1;
943 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
944 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
945 : : "Failed test for rte_bbdev_pmd_callback_process "
946 : : "for RTE_BBDEV_EVENT_UNKNOWN ");
947 : :
948 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
949 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
950 : : "Failed test for rte_bbdev_pmd_callback_process: "
951 : : "event RTE_BBDEV_EVENT_ERROR was unregistered ");
952 : :
953 : : /* rte_bbdev_callback_register with invalid inputs */
954 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_register(invalid_dev_id,
955 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
956 : : "Failed test for rte_bbdev_callback_register "
957 : : "for invalid_dev_id ");
958 : :
959 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
960 : : invalid_event_type, event_callback, &event_status),
961 : : "Failed to callback register for invalid event type ");
962 : :
963 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev1->data->dev_id,
964 : : RTE_BBDEV_EVENT_ERROR, NULL, &event_status),
965 : : "Failed to callback register - no callback function ");
966 : :
967 : : /* The impact of devices on each other */
968 : 0 : dev2 = rte_bbdev_allocate(name2);
969 : 0 : TEST_ASSERT(dev2 != NULL,
970 : : "Failed to initialize bbdev driver");
971 : :
972 : : /*
973 : : * dev2:
974 : : * RTE_BBDEV_EVENT_UNKNOWN - unregistered
975 : : * RTE_BBDEV_EVENT_ERROR - unregistered
976 : : */
977 : 0 : event_status = -1;
978 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
979 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
980 : 0 : TEST_ASSERT(event_status == -1,
981 : : "Failed test for rte_bbdev_pmd_callback_process: "
982 : : "events were not registered ");
983 : :
984 : : /*
985 : : * dev1: RTE_BBDEV_EVENT_ERROR - unregistered
986 : : * dev2: RTE_BBDEV_EVENT_ERROR - registered
987 : : */
988 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
989 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
990 : : "Failed to callback rgstr for RTE_BBDEV_EVENT_ERROR");
991 : :
992 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
993 : 0 : TEST_ASSERT(event_status == -1,
994 : : "Failed test for rte_bbdev_pmd_callback_process in dev1 "
995 : : "for RTE_BBDEV_EVENT_ERROR ");
996 : :
997 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
998 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_ERROR,
999 : : "Failed test for rte_bbdev_pmd_callback_process in dev2 "
1000 : : "for RTE_BBDEV_EVENT_ERROR ");
1001 : :
1002 : : /*
1003 : : * dev1: RTE_BBDEV_EVENT_UNKNOWN - registered
1004 : : * dev2: RTE_BBDEV_EVENT_UNKNOWN - unregistered
1005 : : */
1006 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev2->data->dev_id,
1007 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1008 : : "Failed to callback register for RTE_BBDEV_EVENT_UNKNOWN "
1009 : : "in dev 2 ");
1010 : :
1011 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1012 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
1013 : : "Failed test for rte_bbdev_pmd_callback_process in dev2"
1014 : : " for RTE_BBDEV_EVENT_UNKNOWN ");
1015 : :
1016 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1017 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1018 : : "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN ");
1019 : :
1020 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev2->data->dev_id,
1021 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1022 : : "Failed to unregister RTE_BBDEV_EVENT_UNKNOWN : "
1023 : : "unregister function called once again ");
1024 : :
1025 : 0 : event_status = -1;
1026 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1027 : 0 : TEST_ASSERT(event_status == -1,
1028 : : "Failed test for rte_bbdev_pmd_callback_process in dev2"
1029 : : " for RTE_BBDEV_EVENT_UNKNOWN ");
1030 : :
1031 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1032 : 0 : TEST_ASSERT(event_status == (int) RTE_BBDEV_EVENT_UNKNOWN,
1033 : : "Failed test for rte_bbdev_pmd_callback_process in dev2 "
1034 : : "for RTE_BBDEV_EVENT_UNKNOWN ");
1035 : :
1036 : : /* rte_bbdev_pmd_callback_process with invalid inputs */
1037 : 0 : rte_bbdev_pmd_callback_process(NULL, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1038 : :
1039 : 0 : event_status = -1;
1040 : 0 : rte_bbdev_pmd_callback_process(dev1, invalid_event_type, NULL);
1041 : 0 : TEST_ASSERT(event_status == -1,
1042 : : "Failed test for rte_bbdev_pmd_callback_process: "
1043 : : "for invalid event type ");
1044 : :
1045 : : /* rte_dev_callback_unregister with invalid inputs */
1046 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(invalid_dev_id,
1047 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, &event_status),
1048 : : "Failed test for rte_dev_callback_unregister "
1049 : : "for invalid_dev_id ");
1050 : :
1051 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1052 : : invalid_event_type, event_callback, &event_status),
1053 : : "Failed rte_dev_callback_unregister "
1054 : : "for invalid event type ");
1055 : :
1056 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev1->data->dev_id,
1057 : : invalid_event_type, NULL, &event_status),
1058 : : "Failed rte_dev_callback_unregister "
1059 : : "when no callback function ");
1060 : :
1061 : 0 : dev_id = dev1->data->dev_id;
1062 : :
1063 : 0 : rte_bbdev_release(dev1);
1064 : 0 : rte_bbdev_release(dev2);
1065 : :
1066 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_register(dev_id,
1067 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1068 : : "Failed test for rte_bbdev_callback_register: "
1069 : : "function called after rte_bbdev_driver_uninit .");
1070 : :
1071 : 0 : TEST_ASSERT_FAIL(rte_bbdev_callback_unregister(dev_id,
1072 : : RTE_BBDEV_EVENT_ERROR, event_callback, &event_status),
1073 : : "Failed test for rte_dev_callback_unregister: "
1074 : : "function called after rte_bbdev_driver_uninit. ");
1075 : :
1076 : 0 : event_status = -1;
1077 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1078 : 0 : rte_bbdev_pmd_callback_process(dev1, RTE_BBDEV_EVENT_ERROR, NULL);
1079 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1080 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_ERROR, NULL);
1081 : 0 : TEST_ASSERT(event_status == -1,
1082 : : "Failed test for rte_bbdev_pmd_callback_process: "
1083 : : "callback function was called after rte_bbdev_driver_uninit");
1084 : :
1085 : : return TEST_SUCCESS;
1086 : : }
1087 : :
1088 : : static int
1089 : 0 : test_bbdev_invalid_driver(void)
1090 : : {
1091 : : struct rte_bbdev dev1, *dev2;
1092 : 0 : uint8_t dev_id = null_dev_id;
1093 : : uint16_t queue_id = 0;
1094 : : struct rte_bbdev_stats stats;
1095 : : struct bbdev_testsuite_params *ts_params = &testsuite_params;
1096 : : struct rte_bbdev_queue_info qinfo;
1097 : : struct rte_bbdev_ops dev_ops_tmp;
1098 : :
1099 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id), "Failed to stop bbdev %u ",
1100 : : dev_id);
1101 : :
1102 : 0 : dev1 = rte_bbdev_devices[dev_id];
1103 : 0 : dev2 = &rte_bbdev_devices[dev_id];
1104 : :
1105 : : /* Tests for rte_bbdev_setup_queues */
1106 : 0 : dev2->dev_ops = NULL;
1107 : 0 : TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1108 : : "Failed test for rte_bbdev_setup_queues: "
1109 : : "NULL dev_ops structure ");
1110 : : dev2->dev_ops = dev1.dev_ops;
1111 : :
1112 : 0 : dev_ops_tmp = *dev2->dev_ops;
1113 : 0 : dev_ops_tmp.info_get = NULL;
1114 : 0 : dev2->dev_ops = &dev_ops_tmp;
1115 : 0 : TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1116 : : "Failed test for rte_bbdev_setup_queues: "
1117 : : "NULL info_get ");
1118 : : dev2->dev_ops = dev1.dev_ops;
1119 : :
1120 : 0 : dev_ops_tmp = *dev2->dev_ops;
1121 : 0 : dev_ops_tmp.queue_release = NULL;
1122 : 0 : dev2->dev_ops = &dev_ops_tmp;
1123 : 0 : TEST_ASSERT_FAIL(rte_bbdev_setup_queues(dev_id, 1, SOCKET_ID_ANY),
1124 : : "Failed test for rte_bbdev_setup_queues: "
1125 : : "NULL queue_release ");
1126 : 0 : dev2->dev_ops = dev1.dev_ops;
1127 : :
1128 : 0 : dev2->data->socket_id = SOCKET_ID_ANY;
1129 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_setup_queues(dev_id, 1,
1130 : : SOCKET_ID_ANY), "Failed to configure bbdev %u", dev_id);
1131 : :
1132 : : /* Test for rte_bbdev_queue_configure */
1133 : 0 : dev2->dev_ops = NULL;
1134 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1135 : : &ts_params->qconf),
1136 : : "Failed to configure queue %u on device %u "
1137 : : "with NULL dev_ops structure ", queue_id, dev_id);
1138 : : dev2->dev_ops = dev1.dev_ops;
1139 : :
1140 : 0 : dev_ops_tmp = *dev2->dev_ops;
1141 : 0 : dev_ops_tmp.queue_setup = NULL;
1142 : 0 : dev2->dev_ops = &dev_ops_tmp;
1143 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1144 : : &ts_params->qconf),
1145 : : "Failed to configure queue %u on device %u "
1146 : : "with NULL queue_setup ", queue_id, dev_id);
1147 : : dev2->dev_ops = dev1.dev_ops;
1148 : :
1149 : 0 : dev_ops_tmp = *dev2->dev_ops;
1150 : 0 : dev_ops_tmp.info_get = NULL;
1151 : 0 : dev2->dev_ops = &dev_ops_tmp;
1152 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(dev_id, queue_id,
1153 : : &ts_params->qconf),
1154 : : "Failed to configure queue %u on device %u "
1155 : : "with NULL info_get ", queue_id, dev_id);
1156 : 0 : dev2->dev_ops = dev1.dev_ops;
1157 : :
1158 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_configure(RTE_BBDEV_MAX_DEVS,
1159 : : queue_id, &ts_params->qconf),
1160 : : "Failed to configure queue %u on device %u ",
1161 : : queue_id, dev_id);
1162 : :
1163 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_configure(dev_id, queue_id,
1164 : : &ts_params->qconf),
1165 : : "Failed to configure queue %u on device %u ",
1166 : : queue_id, dev_id);
1167 : :
1168 : : /* Test for rte_bbdev_queue_info_get */
1169 : 0 : dev2->dev_ops = NULL;
1170 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_info_get(dev_id, queue_id, &qinfo),
1171 : : "Failed test for rte_bbdev_info_get: "
1172 : : "NULL dev_ops structure ");
1173 : 0 : dev2->dev_ops = dev1.dev_ops;
1174 : :
1175 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(RTE_BBDEV_MAX_DEVS,
1176 : : queue_id, &qinfo),
1177 : : "Failed test for rte_bbdev_info_get: "
1178 : : "invalid dev_id ");
1179 : :
1180 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id,
1181 : : RTE_MAX_QUEUES_PER_PORT, &qinfo),
1182 : : "Failed test for rte_bbdev_info_get: "
1183 : : "invalid queue_id ");
1184 : :
1185 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_info_get(dev_id, queue_id, NULL),
1186 : : "Failed test for rte_bbdev_info_get: "
1187 : : "invalid dev_info ");
1188 : :
1189 : : /* Test for rte_bbdev_start */
1190 : 0 : dev2->dev_ops = NULL;
1191 : 0 : TEST_ASSERT_FAIL(rte_bbdev_start(dev_id),
1192 : : "Failed to start bbdev %u "
1193 : : "with NULL dev_ops structure ", dev_id);
1194 : 0 : dev2->dev_ops = dev1.dev_ops;
1195 : :
1196 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_start(dev_id),
1197 : : "Failed to start bbdev %u ", dev_id);
1198 : :
1199 : : /* Test for rte_bbdev_queue_start */
1200 : 0 : dev2->dev_ops = NULL;
1201 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_start(dev_id, queue_id),
1202 : : "Failed to start queue %u on device %u: "
1203 : : "NULL dev_ops structure", queue_id, dev_id);
1204 : 0 : dev2->dev_ops = dev1.dev_ops;
1205 : :
1206 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_start(dev_id, queue_id),
1207 : : "Failed to start queue %u on device %u ", queue_id,
1208 : : dev_id);
1209 : :
1210 : : /* Tests for rte_bbdev_stats_get */
1211 : 0 : dev2->dev_ops = NULL;
1212 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stats_get(dev_id, &stats),
1213 : : "Failed test for rte_bbdev_stats_get on device %u ",
1214 : : dev_id);
1215 : : dev2->dev_ops = dev1.dev_ops;
1216 : :
1217 : 0 : dev_ops_tmp = *dev2->dev_ops;
1218 : 0 : dev_ops_tmp.stats_reset = NULL;
1219 : 0 : dev2->dev_ops = &dev_ops_tmp;
1220 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1221 : : "Failed test for rte_bbdev_stats_get: "
1222 : : "NULL stats_get ");
1223 : 0 : dev2->dev_ops = dev1.dev_ops;
1224 : :
1225 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_get(dev_id, &stats),
1226 : : "Failed test for rte_bbdev_stats_get on device %u ",
1227 : : dev_id);
1228 : :
1229 : : /*
1230 : : * Tests for:
1231 : : * rte_bbdev_callback_register,
1232 : : * rte_bbdev_pmd_callback_process,
1233 : : * rte_dev_callback_unregister
1234 : : */
1235 : 0 : dev2->dev_ops = NULL;
1236 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_register(dev_id,
1237 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1238 : : "Failed to callback rgstr for RTE_BBDEV_EVENT_UNKNOWN");
1239 : 0 : rte_bbdev_pmd_callback_process(dev2, RTE_BBDEV_EVENT_UNKNOWN, NULL);
1240 : :
1241 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_callback_unregister(dev_id,
1242 : : RTE_BBDEV_EVENT_UNKNOWN, event_callback, NULL),
1243 : : "Failed to unregister RTE_BBDEV_EVENT_ERROR ");
1244 : :
1245 : : /* Tests for rte_bbdev_stats_reset */
1246 : 0 : dev2->dev_ops = NULL;
1247 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stats_reset(dev_id),
1248 : : "Failed to reset statistic for device %u ", dev_id);
1249 : : dev2->dev_ops = dev1.dev_ops;
1250 : :
1251 : 0 : dev_ops_tmp = *dev2->dev_ops;
1252 : 0 : dev_ops_tmp.stats_reset = NULL;
1253 : 0 : dev2->dev_ops = &dev_ops_tmp;
1254 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1255 : : "Failed test for rte_bbdev_stats_reset: "
1256 : : "NULL stats_reset ");
1257 : 0 : dev2->dev_ops = dev1.dev_ops;
1258 : :
1259 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stats_reset(dev_id),
1260 : : "Failed to reset statistic for device %u ", dev_id);
1261 : :
1262 : : /* Tests for rte_bbdev_queue_stop */
1263 : 0 : dev2->dev_ops = NULL;
1264 : 0 : TEST_ASSERT_FAIL(rte_bbdev_queue_stop(dev_id, queue_id),
1265 : : "Failed to stop queue %u on device %u: "
1266 : : "NULL dev_ops structure", queue_id, dev_id);
1267 : 0 : dev2->dev_ops = dev1.dev_ops;
1268 : :
1269 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_queue_stop(dev_id, queue_id),
1270 : : "Failed to stop queue %u on device %u ", queue_id,
1271 : : dev_id);
1272 : :
1273 : : /* Tests for rte_bbdev_stop */
1274 : 0 : dev2->dev_ops = NULL;
1275 : 0 : TEST_ASSERT_FAIL(rte_bbdev_stop(dev_id),
1276 : : "Failed to stop bbdev %u with NULL dev_ops structure ",
1277 : : dev_id);
1278 : 0 : dev2->dev_ops = dev1.dev_ops;
1279 : :
1280 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_stop(dev_id),
1281 : : "Failed to stop bbdev %u ", dev_id);
1282 : :
1283 : : /* Tests for rte_bbdev_close */
1284 : 0 : TEST_ASSERT_FAIL(rte_bbdev_close(RTE_BBDEV_MAX_DEVS),
1285 : : "Failed to close bbdev with invalid dev_id");
1286 : :
1287 : 0 : dev2->dev_ops = NULL;
1288 : 0 : TEST_ASSERT_FAIL(rte_bbdev_close(dev_id),
1289 : : "Failed to close bbdev %u with NULL dev_ops structure ",
1290 : : dev_id);
1291 : 0 : dev2->dev_ops = dev1.dev_ops;
1292 : :
1293 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_close(dev_id),
1294 : : "Failed to close bbdev %u ", dev_id);
1295 : :
1296 : : return TEST_SUCCESS;
1297 : : }
1298 : :
1299 : : static int
1300 : 0 : test_bbdev_get_named_dev(void)
1301 : : {
1302 : : struct rte_bbdev *dev, *dev_tmp;
1303 : : const char *name = "name";
1304 : :
1305 : 0 : dev = rte_bbdev_allocate(name);
1306 : 0 : TEST_ASSERT(dev != NULL, "Failed to initialize bbdev driver");
1307 : :
1308 : 0 : dev_tmp = rte_bbdev_get_named_dev(NULL);
1309 : 0 : TEST_ASSERT(dev_tmp == NULL, "Failed test for rte_bbdev_get_named_dev: "
1310 : : "function called with NULL parameter");
1311 : :
1312 : 0 : dev_tmp = rte_bbdev_get_named_dev(name);
1313 : :
1314 : 0 : TEST_ASSERT(dev == dev_tmp, "Failed test for rte_bbdev_get_named_dev: "
1315 : : "wrong device was returned ");
1316 : :
1317 : 0 : TEST_ASSERT_SUCCESS(rte_bbdev_release(dev),
1318 : : "Failed to uninitialize bbdev driver %s ", name);
1319 : :
1320 : : return TEST_SUCCESS;
1321 : : }
1322 : :
1323 : : static struct unit_test_suite bbdev_null_testsuite = {
1324 : : .suite_name = "BBDEV NULL Unit Test Suite",
1325 : : .setup = testsuite_setup,
1326 : : .teardown = testsuite_teardown,
1327 : : .unit_test_cases = {
1328 : :
1329 : : TEST_CASE(test_bbdev_configure_invalid_dev_id),
1330 : :
1331 : : TEST_CASE_ST(ut_setup, ut_teardown,
1332 : : test_bbdev_configure_invalid_num_queues),
1333 : :
1334 : : TEST_CASE_ST(ut_setup, ut_teardown,
1335 : : test_bbdev_configure_stop_device),
1336 : :
1337 : : TEST_CASE_ST(ut_setup, ut_teardown,
1338 : : test_bbdev_configure_stop_queue),
1339 : :
1340 : : TEST_CASE_ST(ut_setup, ut_teardown,
1341 : : test_bbdev_configure_invalid_queue_configure),
1342 : :
1343 : : TEST_CASE_ST(ut_setup, ut_teardown,
1344 : : test_bbdev_op_pool),
1345 : :
1346 : : TEST_CASE_ST(ut_setup, ut_teardown,
1347 : : test_bbdev_op_type),
1348 : :
1349 : : TEST_CASE_ST(ut_setup, ut_teardown,
1350 : : test_bbdev_op_pool_size),
1351 : :
1352 : : TEST_CASE_ST(ut_setup, ut_teardown,
1353 : : test_bbdev_stats),
1354 : :
1355 : : TEST_CASE_ST(ut_setup, ut_teardown,
1356 : : test_bbdev_driver_init),
1357 : :
1358 : : TEST_CASE_ST(ut_setup, ut_teardown,
1359 : : test_bbdev_callback),
1360 : :
1361 : : TEST_CASE_ST(ut_setup, ut_teardown,
1362 : : test_bbdev_invalid_driver),
1363 : :
1364 : : TEST_CASE_ST(ut_setup, ut_teardown,
1365 : : test_bbdev_get_named_dev),
1366 : :
1367 : : TEST_CASE(test_bbdev_count),
1368 : :
1369 : : TEST_CASES_END() /**< NULL terminate unit test array */
1370 : : }
1371 : : };
1372 : :
1373 : 0 : REGISTER_TEST_COMMAND(unittest, bbdev_null_testsuite);
|
