2 *------------------------------------------------------------------
3 * Copyright (c) 2017 Cisco and/or its affiliates.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *------------------------------------------------------------------
17 #include <sys/types.h>
21 #include <main_test.h>
23 #include <memif_private.h>
25 #define SOCKET_FILENAME "/run/vpp/memif.sock"
28 #define read_call (1 << 0)
29 #define write_call (1 << 1)
30 #define error_call (1 << 2)
33 read_fn (memif_connection_t * c)
35 ready_called |= read_call;
40 write_fn (memif_connection_t * c)
42 ready_called |= write_call;
47 error_fn (memif_connection_t * c)
49 ready_called |= error_call;
54 register_fd_ready_fn (memif_connection_t * c,
55 memif_fn * read_fn, memif_fn * write_fn,
59 c->write_fn = write_fn;
60 c->error_fn = error_fn;
63 START_TEST (test_init)
68 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
69 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
71 libmemif_main_t *lm = &libmemif_main;
73 ck_assert_ptr_ne (lm, NULL);
74 ck_assert_ptr_ne (lm->control_fd_update, NULL);
75 ck_assert_int_gt (lm->timerfd, 2);
83 START_TEST (test_init_epoll)
87 if ((err = memif_init (NULL, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
88 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
90 libmemif_main_t *lm = &libmemif_main;
92 ck_assert_ptr_ne (lm, NULL);
93 ck_assert_ptr_ne (lm->control_fd_update, NULL);
94 ck_assert_int_gt (lm->timerfd, 2);
95 ck_assert_int_gt (memif_epfd, -1);
103 START_TEST (test_create)
106 memif_conn_handle_t conn = NULL;
107 memif_conn_args_t args;
108 memset (&args, 0, sizeof (args));
110 libmemif_main_t *lm = &libmemif_main;
113 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
114 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
116 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
117 strncpy ((char *) args.instance_name, TEST_APP_NAME,
118 strlen (TEST_APP_NAME));
120 if ((err = memif_create (&conn, &args, on_connect,
121 on_disconnect, on_interrupt,
122 NULL)) != MEMIF_ERR_SUCCESS)
123 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
125 memif_connection_t *c = (memif_connection_t *) conn;
127 ck_assert_ptr_ne (c, NULL);
129 ck_assert_uint_eq (c->args.interface_id, args.interface_id);
130 ck_assert_uint_eq (c->args.is_master, args.is_master);
131 ck_assert_uint_eq (c->args.mode, args.mode);
133 ck_assert_uint_eq (c->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
134 ck_assert_uint_eq (c->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
135 ck_assert_uint_eq (c->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
136 ck_assert_uint_eq (c->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
138 ck_assert_ptr_eq (c->msg_queue, NULL);
139 ck_assert_ptr_eq (c->regions, NULL);
140 ck_assert_ptr_eq (c->tx_queues, NULL);
141 ck_assert_ptr_eq (c->rx_queues, NULL);
143 ck_assert_int_eq (c->fd, -1);
145 ck_assert_ptr_ne (c->on_connect, NULL);
146 ck_assert_ptr_ne (c->on_disconnect, NULL);
147 ck_assert_ptr_ne (c->on_interrupt, NULL);
149 ck_assert_str_eq (c->args.interface_name, args.interface_name);
150 ck_assert_str_eq (c->args.instance_name, args.instance_name);
151 ck_assert_str_eq (c->args.socket_filename, SOCKET_FILENAME);
153 struct itimerspec timer;
154 timerfd_gettime (lm->timerfd, &timer);
156 ck_assert_msg (timer.it_interval.tv_sec == lm->arm.it_interval.tv_sec,
157 "timerfd not armed!");
163 memif_delete (&conn);
164 ck_assert_ptr_eq (conn, NULL);
168 START_TEST (test_create_master)
171 memif_conn_handle_t conn = NULL;
172 memif_conn_args_t args;
173 memset (&args, 0, sizeof (args));
176 libmemif_main_t *lm = &libmemif_main;
179 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
180 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
182 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
183 strncpy ((char *) args.instance_name, TEST_APP_NAME,
184 strlen (TEST_APP_NAME));
186 if ((err = memif_create (&conn, &args, on_connect,
187 on_disconnect, on_interrupt,
188 NULL)) != MEMIF_ERR_SUCCESS)
189 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
191 memif_connection_t *c = (memif_connection_t *) conn;
193 ck_assert_ptr_ne (c, NULL);
195 ck_assert_uint_eq (c->args.interface_id, args.interface_id);
196 ck_assert_uint_eq (c->args.is_master, args.is_master);
197 ck_assert_uint_eq (c->args.mode, args.mode);
199 ck_assert_uint_eq (c->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
200 ck_assert_uint_eq (c->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
201 ck_assert_uint_eq (c->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
202 ck_assert_uint_eq (c->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
204 ck_assert_ptr_eq (c->msg_queue, NULL);
205 ck_assert_ptr_eq (c->regions, NULL);
206 ck_assert_ptr_eq (c->tx_queues, NULL);
207 ck_assert_ptr_eq (c->rx_queues, NULL);
209 ck_assert_int_eq (c->fd, -1);
211 ck_assert_ptr_ne (c->on_connect, NULL);
212 ck_assert_ptr_ne (c->on_disconnect, NULL);
213 ck_assert_ptr_ne (c->on_interrupt, NULL);
215 ck_assert_str_eq (c->args.interface_name, args.interface_name);
216 ck_assert_str_eq (c->args.instance_name, args.instance_name);
217 ck_assert_str_eq (c->args.socket_filename, SOCKET_FILENAME);
219 struct stat file_stat;
221 rv = stat (SOCKET_FILENAME, &file_stat);
222 ck_assert_int_eq (rv, 0);
224 ck_assert (S_ISSOCK (file_stat.st_mode));
226 memif_delete (&conn);
227 ck_assert_ptr_eq (conn, NULL);
231 START_TEST (test_create_mult)
234 memif_conn_handle_t conn = NULL;
235 memif_conn_handle_t conn1 = NULL;
236 memif_conn_args_t args;
237 memset (&args, 0, sizeof (args));
239 libmemif_main_t *lm = &libmemif_main;
242 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
243 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
245 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
246 strncpy ((char *) args.instance_name, TEST_APP_NAME,
247 strlen (TEST_APP_NAME));
249 if ((err = memif_create (&conn, &args, on_connect,
250 on_disconnect, on_interrupt,
251 NULL)) != MEMIF_ERR_SUCCESS)
252 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
254 args.interface_id = 1;
256 if ((err = memif_create (&conn1, &args, on_connect,
257 on_disconnect, on_interrupt,
258 NULL)) != MEMIF_ERR_SUCCESS)
259 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
261 memif_connection_t *c = (memif_connection_t *) conn;
262 memif_connection_t *c1 = (memif_connection_t *) conn1;
264 ck_assert_ptr_ne (c, NULL);
265 ck_assert_ptr_ne (c1, NULL);
267 ck_assert_uint_eq (c->args.interface_id, 0);
268 ck_assert_uint_eq (c->args.is_master, args.is_master);
269 ck_assert_uint_eq (c->args.mode, args.mode);
270 ck_assert_uint_eq (c1->args.interface_id, 1);
271 ck_assert_uint_eq (c1->args.is_master, args.is_master);
272 ck_assert_uint_eq (c1->args.mode, args.mode);
274 ck_assert_uint_eq (c->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
275 ck_assert_uint_eq (c->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
276 ck_assert_uint_eq (c->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
277 ck_assert_uint_eq (c->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
278 ck_assert_uint_eq (c1->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
279 ck_assert_uint_eq (c1->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
280 ck_assert_uint_eq (c1->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
281 ck_assert_uint_eq (c1->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
283 ck_assert_ptr_eq (c->msg_queue, NULL);
284 ck_assert_ptr_eq (c->regions, NULL);
285 ck_assert_ptr_eq (c->tx_queues, NULL);
286 ck_assert_ptr_eq (c->rx_queues, NULL);
287 ck_assert_ptr_eq (c1->msg_queue, NULL);
288 ck_assert_ptr_eq (c1->regions, NULL);
289 ck_assert_ptr_eq (c1->tx_queues, NULL);
290 ck_assert_ptr_eq (c1->rx_queues, NULL);
292 ck_assert_int_eq (c->fd, -1);
293 ck_assert_int_eq (c1->fd, -1);
295 ck_assert_ptr_ne (c->on_connect, NULL);
296 ck_assert_ptr_ne (c->on_disconnect, NULL);
297 ck_assert_ptr_ne (c->on_interrupt, NULL);
298 ck_assert_ptr_ne (c1->on_connect, NULL);
299 ck_assert_ptr_ne (c1->on_disconnect, NULL);
300 ck_assert_ptr_ne (c1->on_interrupt, NULL);
302 ck_assert_str_eq (c->args.interface_name, args.interface_name);
303 ck_assert_str_eq (c->args.instance_name, args.instance_name);
304 ck_assert_str_eq (c->args.socket_filename, SOCKET_FILENAME);
305 ck_assert_str_eq (c1->args.interface_name, args.interface_name);
306 ck_assert_str_eq (c1->args.instance_name, args.instance_name);
307 ck_assert_str_eq (c1->args.socket_filename, SOCKET_FILENAME);
309 struct itimerspec timer;
310 timerfd_gettime (lm->timerfd, &timer);
312 ck_assert_msg (timer.it_interval.tv_sec == lm->arm.it_interval.tv_sec,
313 "timerfd not armed!");
319 memif_delete (&conn);
320 ck_assert_ptr_eq (conn, NULL);
324 START_TEST (test_control_fd_handler)
328 memif_conn_handle_t conn = NULL;
329 memif_conn_args_t args;
330 memset (&args, 0, sizeof (args));
331 args.num_s2m_rings = 2;
332 args.num_m2s_rings = 2;
334 libmemif_main_t *lm = &libmemif_main;
337 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
338 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
340 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
341 strncpy ((char *) args.instance_name, TEST_APP_NAME,
342 strlen (TEST_APP_NAME));
344 if ((err = memif_create (&conn, &args, on_connect,
345 on_disconnect, on_interrupt,
346 NULL)) != MEMIF_ERR_SUCCESS)
347 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
349 memif_connection_t *c = (memif_connection_t *) conn;
352 memif_control_fd_handler (lm->timerfd,
353 MEMIF_FD_EVENT_READ)) != MEMIF_ERR_SUCCESS)
354 ck_assert_msg (err == MEMIF_ERR_NO_FILE, "err code: %u, err msg: %s", err,
355 memif_strerror (err));
357 register_fd_ready_fn (c, read_fn, write_fn, error_fn);
359 lm->control_list[0].key = c->fd;
360 lm->control_list[0].data_struct = c;
363 memif_control_fd_handler (c->fd,
364 MEMIF_FD_EVENT_READ)) != MEMIF_ERR_SUCCESS)
365 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
367 ck_assert (ready_called & read_call);
370 memif_control_fd_handler (c->fd,
371 MEMIF_FD_EVENT_WRITE)) != MEMIF_ERR_SUCCESS)
372 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
374 ck_assert (ready_called & write_call);
377 memif_control_fd_handler (c->fd,
378 MEMIF_FD_EVENT_ERROR)) != MEMIF_ERR_SUCCESS)
379 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
381 ck_assert (ready_called & error_call);
387 memif_delete (&conn);
388 ck_assert_ptr_eq (conn, NULL);
392 START_TEST (test_buffer_alloc)
397 memif_buffer_t *bufs;
398 uint16_t max_buf = 10;
400 memif_conn_handle_t conn = NULL;
401 memif_conn_args_t args;
402 memset (&args, 0, sizeof (args));
403 args.num_s2m_rings = 2;
404 args.num_m2s_rings = 2;
406 libmemif_main_t *lm = &libmemif_main;
409 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
410 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
412 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
413 strncpy ((char *) args.instance_name, TEST_APP_NAME,
414 strlen (TEST_APP_NAME));
416 if ((err = memif_create (&conn, &args, on_connect,
417 on_disconnect, on_interrupt,
418 NULL)) != MEMIF_ERR_SUCCESS)
419 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
421 memif_connection_t *c = (memif_connection_t *) conn;
423 c->run_args.num_s2m_rings = 2;
424 c->run_args.num_m2s_rings = 2;
425 c->run_args.log2_ring_size = 10;
426 c->run_args.buffer_size = 2048;
428 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
429 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
433 /* test buffer allocation qid 0 (positive) */
435 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
439 memif_buffer_alloc (conn, qid, bufs, max_buf,
440 &buf)) != MEMIF_ERR_SUCCESS)
441 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
443 ck_assert_uint_eq (buf, max_buf);
444 for (i = 0; i < max_buf; i++)
445 ck_assert_uint_eq (bufs[i].buffer_len, MEMIF_DEFAULT_BUFFER_SIZE);
447 /* test buffer allocation qid 1 (positive) */
449 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
453 memif_buffer_alloc (conn, qid, bufs, max_buf,
454 &buf)) != MEMIF_ERR_SUCCESS)
455 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
457 ck_assert_uint_eq (buf, max_buf);
458 for (i = 0; i < max_buf; i++)
459 ck_assert_uint_eq (bufs[i].buffer_len, MEMIF_DEFAULT_BUFFER_SIZE);
461 /* test buffer allocation qid 2 (negative) */
464 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
468 memif_buffer_alloc (conn, qid, bufs, max_buf,
469 &buf)) != MEMIF_ERR_SUCCESS)
470 ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
471 memif_strerror (err));
480 memif_delete (&conn);
481 ck_assert_ptr_eq (conn, NULL);
485 START_TEST (test_tx_burst)
488 uint16_t max_buf = 10, buf, tx;
490 memif_buffer_t *bufs;
492 memif_conn_handle_t conn = NULL;
493 memif_conn_args_t args;
494 memset (&args, 0, sizeof (args));
495 args.num_s2m_rings = 2;
496 args.num_m2s_rings = 2;
498 libmemif_main_t *lm = &libmemif_main;
501 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
502 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
504 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
505 strncpy ((char *) args.instance_name, TEST_APP_NAME,
506 strlen (TEST_APP_NAME));
508 if ((err = memif_create (&conn, &args, on_connect,
509 on_disconnect, on_interrupt,
510 NULL)) != MEMIF_ERR_SUCCESS)
511 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
513 memif_connection_t *c = (memif_connection_t *) conn;
515 c->run_args.num_s2m_rings = 2;
516 c->run_args.num_m2s_rings = 2;
517 c->run_args.log2_ring_size = 10;
518 c->run_args.buffer_size = 2048;
520 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
521 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
525 /* test transmit qid 0 (positive) */
527 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
530 memif_buffer_alloc (conn, qid, bufs, max_buf,
531 &buf)) != MEMIF_ERR_SUCCESS)
532 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
534 ck_assert_uint_eq (buf, max_buf);
535 for (i = 0; i < max_buf; i++)
536 ck_assert_uint_eq (bufs[i].buffer_len, MEMIF_DEFAULT_BUFFER_SIZE);
539 memif_tx_burst (conn, qid, bufs, max_buf, &tx)) != MEMIF_ERR_SUCCESS)
540 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
542 ck_assert_uint_eq (tx, max_buf);
543 for (i = 0; i < max_buf; i++)
544 ck_assert_ptr_eq (bufs[i].data, NULL);
546 /* test transmit qid 1 (positive) */
548 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
551 memif_buffer_alloc (conn, qid, bufs, max_buf,
552 &buf)) != MEMIF_ERR_SUCCESS)
553 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
555 ck_assert_uint_eq (buf, max_buf);
556 for (i = 0; i < max_buf; i++)
557 ck_assert_uint_eq (bufs[i].buffer_len, MEMIF_DEFAULT_BUFFER_SIZE);
560 memif_tx_burst (conn, qid, bufs, max_buf, &tx)) != MEMIF_ERR_SUCCESS)
561 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
563 ck_assert_uint_eq (tx, max_buf);
564 for (i = 0; i < max_buf; i++)
565 ck_assert_ptr_eq (bufs[i].data, NULL);
567 /* test transmit qid 2 (negative) */
569 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
572 memif_tx_burst (conn, qid, bufs, max_buf, &tx)) != MEMIF_ERR_SUCCESS)
573 ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
574 memif_strerror (err));
582 memif_delete (&conn);
583 ck_assert_ptr_eq (conn, NULL);
587 START_TEST (test_rx_burst)
590 uint16_t max_buf = 10, buf, rx;
592 memif_buffer_t *bufs;
596 memif_conn_handle_t conn = NULL;
597 memif_conn_args_t args;
598 memset (&args, 0, sizeof (args));
599 args.num_s2m_rings = 2;
600 args.num_m2s_rings = 2;
602 libmemif_main_t *lm = &libmemif_main;
605 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
606 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
608 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
609 strncpy ((char *) args.instance_name, TEST_APP_NAME,
610 strlen (TEST_APP_NAME));
612 if ((err = memif_create (&conn, &args, on_connect,
613 on_disconnect, on_interrupt,
614 NULL)) != MEMIF_ERR_SUCCESS)
615 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
617 memif_connection_t *c = (memif_connection_t *) conn;
619 c->run_args.num_s2m_rings = 2;
620 c->run_args.num_m2s_rings = 2;
621 c->run_args.log2_ring_size = 10;
622 c->run_args.buffer_size = 2048;
624 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
625 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
629 /* test receive qid 0 (positive) */
631 mq = &c->rx_queues[qid];
633 ring->head += max_buf;
635 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
638 memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
639 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
641 ck_assert_uint_eq (rx, max_buf);
642 for (i = 0; i < max_buf; i++)
643 ck_assert_ptr_ne (bufs[i].data, NULL);
645 /* test receive qid 1 (positive) */
647 mq = &c->rx_queues[qid];
649 ring->head += max_buf;
652 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
655 memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
656 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
658 ck_assert_uint_eq (rx, max_buf);
659 for (i = 0; i < max_buf; i++)
660 ck_assert_ptr_ne (bufs[i].data, NULL);
662 /* test receive qid 2 (negative) */
664 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
667 memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
668 ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
669 memif_strerror (err));
677 memif_delete (&conn);
678 ck_assert_ptr_eq (conn, NULL);
682 START_TEST (test_buffer_free)
685 uint16_t max_buf = 10, buf, rx;
687 memif_buffer_t *bufs;
691 memif_conn_handle_t conn = NULL;
692 memif_conn_args_t args;
693 memset (&args, 0, sizeof (args));
694 args.num_s2m_rings = 2;
695 args.num_m2s_rings = 2;
697 libmemif_main_t *lm = &libmemif_main;
700 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
701 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
703 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
704 strncpy ((char *) args.instance_name, TEST_APP_NAME,
705 strlen (TEST_APP_NAME));
707 if ((err = memif_create (&conn, &args, on_connect,
708 on_disconnect, on_interrupt,
709 NULL)) != MEMIF_ERR_SUCCESS)
710 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
712 memif_connection_t *c = (memif_connection_t *) conn;
714 c->run_args.num_s2m_rings = 2;
715 c->run_args.num_m2s_rings = 2;
716 c->run_args.log2_ring_size = 10;
717 c->run_args.buffer_size = 2048;
719 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
720 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
724 /* test buffer free qid 0 (positive) */
726 mq = &c->rx_queues[qid];
730 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
733 memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
734 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
736 ck_assert_uint_eq (rx, max_buf);
737 for (i = 0; i < max_buf; i++)
738 ck_assert_ptr_ne (bufs[i].data, NULL);
741 memif_buffer_free (conn, qid, bufs, max_buf,
742 &buf)) != MEMIF_ERR_SUCCESS)
743 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
745 ck_assert_uint_eq (buf, max_buf);
746 for (i = 0; i < max_buf; i++)
747 ck_assert_ptr_eq (bufs[i].data, NULL);
748 ck_assert_uint_eq (ring->head, ring->tail);
750 /* test buffer free qid 1 (positive) */
752 mq = &c->rx_queues[qid];
757 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
760 memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
761 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
763 ck_assert_uint_eq (rx, max_buf);
764 for (i = 0; i < max_buf; i++)
765 ck_assert_ptr_ne (bufs[i].data, NULL);
768 memif_buffer_free (conn, qid, bufs, max_buf,
769 &buf)) != MEMIF_ERR_SUCCESS)
770 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
772 ck_assert_uint_eq (buf, max_buf);
773 for (i = 0; i < max_buf; i++)
774 ck_assert_ptr_eq (bufs[i].data, NULL);
775 ck_assert_uint_eq (ring->head, ring->tail);
778 /* test buffer free qid 2 (negative) */
781 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
784 memif_buffer_free (conn, qid, bufs, max_buf,
785 &buf)) != MEMIF_ERR_SUCCESS)
786 ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
787 memif_strerror (err));
795 memif_delete (&conn);
796 ck_assert_ptr_eq (conn, NULL);
800 START_TEST (test_get_details)
804 memif_conn_handle_t conn = NULL;
805 memif_conn_args_t args;
806 memset (&args, 0, sizeof (args));
807 args.num_s2m_rings = 2;
808 args.num_m2s_rings = 2;
810 libmemif_main_t *lm = &libmemif_main;
813 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
814 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
816 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
817 strncpy ((char *) args.instance_name, TEST_APP_NAME,
818 strlen (TEST_APP_NAME));
820 if ((err = memif_create (&conn, &args, on_connect,
821 on_disconnect, on_interrupt,
822 NULL)) != MEMIF_ERR_SUCCESS)
823 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
825 memif_connection_t *c = (memif_connection_t *) conn;
827 c->run_args.num_s2m_rings = 2;
828 c->run_args.num_m2s_rings = 2;
829 c->run_args.log2_ring_size = 10;
830 c->run_args.buffer_size = 2048;
832 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
833 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
836 memset (&md, 0, sizeof (md));
837 ssize_t buflen = 2048;
838 char *buf = malloc (buflen);
839 memset (buf, 0, buflen);
841 if ((err = memif_get_details (conn, &md, buf, buflen)) != MEMIF_ERR_SUCCESS)
842 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
844 ck_assert_str_eq (md.if_name, c->args.interface_name);
845 ck_assert_str_eq (md.inst_name, c->args.instance_name);
846 ck_assert_str_eq (md.remote_if_name, c->remote_if_name);
847 ck_assert_str_eq (md.remote_inst_name, c->remote_name);
848 ck_assert_str_eq (md.secret, c->args.secret);
849 ck_assert_str_eq (md.socket_filename, c->args.socket_filename);
851 ck_assert_uint_eq (md.id, c->args.interface_id);
852 ck_assert_uint_ne (md.role, c->args.is_master);
853 ck_assert_uint_eq (md.mode, c->args.mode);
854 for (i = 0; i < md.rx_queues_num; i++)
856 ck_assert_uint_eq (md.rx_queues[i].qid, i);
857 ck_assert_uint_eq (md.rx_queues[i].ring_size,
858 (1 << c->args.log2_ring_size));
859 ck_assert_uint_eq (md.rx_queues[i].buffer_size, c->args.buffer_size);
861 for (i = 0; i < md.tx_queues_num; i++)
863 ck_assert_uint_eq (md.tx_queues[i].qid, i);
864 ck_assert_uint_eq (md.tx_queues[i].ring_size,
865 (1 << c->args.log2_ring_size));
866 ck_assert_uint_eq (md.tx_queues[i].buffer_size, c->args.buffer_size);
868 ck_assert_uint_eq (md.link_up_down, 0);
874 memif_delete (&conn);
875 ck_assert_ptr_eq (conn, NULL);
879 START_TEST (test_init_regions_and_queues)
883 memif_conn_handle_t conn = NULL;
884 memif_conn_args_t args;
885 memset (&args, 0, sizeof (args));
886 args.num_s2m_rings = 2;
887 args.num_m2s_rings = 2;
889 libmemif_main_t *lm = &libmemif_main;
892 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
893 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
895 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
896 strncpy ((char *) args.instance_name, TEST_APP_NAME,
897 strlen (TEST_APP_NAME));
899 if ((err = memif_create (&conn, &args, on_connect,
900 on_disconnect, on_interrupt,
901 NULL)) != MEMIF_ERR_SUCCESS)
902 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
904 memif_connection_t *c = (memif_connection_t *) conn;
906 c->run_args.num_s2m_rings = 2;
907 c->run_args.num_m2s_rings = 2;
908 c->run_args.log2_ring_size = 10;
909 c->run_args.buffer_size = 2048;
911 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
912 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
914 ck_assert_ptr_ne (c->regions, NULL);
915 ck_assert_ptr_ne (c->tx_queues, NULL);
916 ck_assert_ptr_ne (c->rx_queues, NULL);
918 ck_assert_ptr_ne (c->regions->shm, NULL);
919 ck_assert_ptr_ne (c->tx_queues->ring, NULL);
920 ck_assert_ptr_ne (c->rx_queues->ring, NULL);
922 ck_assert_int_ne (c->regions->fd, -1);
923 ck_assert_uint_eq (c->tx_queues->ring->cookie, MEMIF_COOKIE);
924 ck_assert_uint_eq (c->rx_queues->ring->cookie, MEMIF_COOKIE);
930 memif_delete (&conn);
931 ck_assert_ptr_eq (conn, NULL);
935 START_TEST (test_connect1)
939 memif_conn_handle_t conn = NULL;
940 memif_conn_args_t args;
941 memset (&args, 0, sizeof (args));
942 args.num_s2m_rings = 2;
943 args.num_m2s_rings = 2;
945 libmemif_main_t *lm = &libmemif_main;
948 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
949 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
951 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
952 strncpy ((char *) args.instance_name, TEST_APP_NAME,
953 strlen (TEST_APP_NAME));
955 if ((err = memif_create (&conn, &args, on_connect,
956 on_disconnect, on_interrupt,
957 NULL)) != MEMIF_ERR_SUCCESS)
958 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
960 memif_connection_t *c = (memif_connection_t *) conn;
962 c->run_args.num_s2m_rings = 2;
963 c->run_args.num_m2s_rings = 2;
964 c->run_args.log2_ring_size = 10;
965 c->run_args.buffer_size = 2048;
967 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
968 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
970 if ((err = memif_connect1 (c)) != MEMIF_ERR_SUCCESS)
971 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
977 memif_delete (&conn);
978 ck_assert_ptr_eq (conn, NULL);
982 START_TEST (test_disconnect_internal)
986 memif_conn_handle_t conn = NULL;
987 memif_conn_args_t args;
988 memset (&args, 0, sizeof (args));
989 args.num_s2m_rings = 2;
990 args.num_m2s_rings = 2;
992 libmemif_main_t *lm = &libmemif_main;
995 memif_init (control_fd_update, TEST_APP_NAME)) != MEMIF_ERR_SUCCESS)
996 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
998 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
999 strncpy ((char *) args.instance_name, TEST_APP_NAME,
1000 strlen (TEST_APP_NAME));
1002 if ((err = memif_create (&conn, &args, on_connect,
1003 on_disconnect, on_interrupt,
1004 NULL)) != MEMIF_ERR_SUCCESS)
1005 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
1007 memif_connection_t *c = (memif_connection_t *) conn;
1009 c->run_args.num_s2m_rings = 2;
1010 c->run_args.num_m2s_rings = 2;
1011 c->run_args.log2_ring_size = 10;
1012 c->run_args.buffer_size = 2048;
1014 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
1015 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
1017 if ((err = memif_disconnect_internal (c)) != MEMIF_ERR_SUCCESS)
1018 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
1020 ck_assert_int_eq (c->fd, -1);
1022 ck_assert_ptr_eq (c->tx_queues, NULL);
1023 ck_assert_ptr_eq (c->rx_queues, NULL);
1024 ck_assert_ptr_eq (c->regions, NULL);
1025 ck_assert_ptr_eq (c->msg_queue, NULL);
1027 struct itimerspec timer;
1028 timerfd_gettime (lm->timerfd, &timer);
1030 ck_assert_msg (timer.it_interval.tv_sec == lm->arm.it_interval.tv_sec,
1031 "timerfd not armed!");
1033 if (lm->timerfd > 0)
1034 close (lm->timerfd);
1037 memif_delete (&conn);
1038 ck_assert_ptr_eq (conn, NULL);
1041 END_TEST Suite * main_suite ()
1048 /* create main test suite */
1049 s = suite_create ("Libmemif main");
1051 /* create api test case */
1052 tc_api = tcase_create ("Api calls");
1053 /* add tests to test case */
1054 tcase_add_test (tc_api, test_init);
1055 tcase_add_test (tc_api, test_init_epoll);
1056 tcase_add_test (tc_api, test_create);
1057 tcase_add_test (tc_api, test_create_master);
1058 tcase_add_test (tc_api, test_create_mult);
1059 tcase_add_test (tc_api, test_control_fd_handler);
1060 tcase_add_test (tc_api, test_buffer_alloc);
1061 tcase_add_test (tc_api, test_tx_burst);
1062 tcase_add_test (tc_api, test_rx_burst);
1063 tcase_add_test (tc_api, test_buffer_free);
1064 tcase_add_test (tc_api, test_get_details);
1066 /* create internal test case */
1067 tc_internal = tcase_create ("Internal");
1068 /* add tests to test case */
1069 tcase_add_test (tc_internal, test_init_regions_and_queues);
1070 tcase_add_test (tc_internal, test_connect1);
1071 tcase_add_test (tc_internal, test_disconnect_internal);
1073 /* add test cases to test suite */
1074 suite_add_tcase (s, tc_api);
1075 suite_add_tcase (s, tc_internal);
1077 /* return main test suite to test runner */