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, NULL,
69 NULL)) != MEMIF_ERR_SUCCESS)
70 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
72 libmemif_main_t *lm = &libmemif_main;
74 ck_assert_ptr_ne (lm, NULL);
75 ck_assert_ptr_ne (lm->control_fd_update, NULL);
76 ck_assert_int_gt (lm->timerfd, 2);
84 START_TEST (test_init_epoll)
89 memif_init (NULL, TEST_APP_NAME, NULL, NULL)) != MEMIF_ERR_SUCCESS)
90 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
92 libmemif_main_t *lm = &libmemif_main;
94 ck_assert_ptr_ne (lm, NULL);
95 ck_assert_ptr_ne (lm->control_fd_update, NULL);
96 ck_assert_int_gt (lm->timerfd, 2);
97 ck_assert_int_gt (memif_epfd, -1);
105 START_TEST (test_create)
108 memif_conn_handle_t conn = NULL;
109 memif_conn_args_t args;
110 memset (&args, 0, sizeof (args));
112 libmemif_main_t *lm = &libmemif_main;
115 memif_init (control_fd_update, TEST_APP_NAME, NULL,
116 NULL)) != MEMIF_ERR_SUCCESS)
117 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
119 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
121 if ((err = memif_create (&conn, &args, on_connect,
122 on_disconnect, on_interrupt,
123 NULL)) != MEMIF_ERR_SUCCESS)
124 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
126 memif_connection_t *c = (memif_connection_t *) conn;
128 ck_assert_ptr_ne (c, NULL);
130 ck_assert_uint_eq (c->args.interface_id, args.interface_id);
131 ck_assert_uint_eq (c->args.is_master, args.is_master);
132 ck_assert_uint_eq (c->args.mode, args.mode);
134 ck_assert_uint_eq (c->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
135 ck_assert_uint_eq (c->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
136 ck_assert_uint_eq (c->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
137 ck_assert_uint_eq (c->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
139 ck_assert_ptr_eq (c->msg_queue, NULL);
140 ck_assert_ptr_eq (c->regions, NULL);
141 ck_assert_ptr_eq (c->tx_queues, NULL);
142 ck_assert_ptr_eq (c->rx_queues, NULL);
144 ck_assert_int_eq (c->fd, -1);
146 ck_assert_ptr_ne (c->on_connect, NULL);
147 ck_assert_ptr_ne (c->on_disconnect, NULL);
148 ck_assert_ptr_ne (c->on_interrupt, NULL);
150 ck_assert_str_eq (c->args.interface_name, args.interface_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, NULL,
180 NULL)) != MEMIF_ERR_SUCCESS)
181 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
183 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
185 if ((err = memif_create (&conn, &args, on_connect,
186 on_disconnect, on_interrupt,
187 NULL)) != MEMIF_ERR_SUCCESS)
188 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
190 memif_connection_t *c = (memif_connection_t *) conn;
192 ck_assert_ptr_ne (c, NULL);
194 ck_assert_uint_eq (c->args.interface_id, args.interface_id);
195 ck_assert_uint_eq (c->args.is_master, args.is_master);
196 ck_assert_uint_eq (c->args.mode, args.mode);
198 ck_assert_uint_eq (c->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
199 ck_assert_uint_eq (c->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
200 ck_assert_uint_eq (c->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
201 ck_assert_uint_eq (c->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
203 ck_assert_ptr_eq (c->msg_queue, NULL);
204 ck_assert_ptr_eq (c->regions, NULL);
205 ck_assert_ptr_eq (c->tx_queues, NULL);
206 ck_assert_ptr_eq (c->rx_queues, NULL);
208 ck_assert_int_eq (c->fd, -1);
210 ck_assert_ptr_ne (c->on_connect, NULL);
211 ck_assert_ptr_ne (c->on_disconnect, NULL);
212 ck_assert_ptr_ne (c->on_interrupt, NULL);
214 ck_assert_str_eq (c->args.interface_name, args.interface_name);
215 ck_assert_str_eq (c->args.socket_filename, SOCKET_FILENAME);
217 struct stat file_stat;
219 rv = stat (SOCKET_FILENAME, &file_stat);
220 ck_assert_int_eq (rv, 0);
222 ck_assert (S_ISSOCK (file_stat.st_mode));
224 memif_delete (&conn);
225 ck_assert_ptr_eq (conn, NULL);
229 START_TEST (test_create_mult)
232 memif_conn_handle_t conn = NULL;
233 memif_conn_handle_t conn1 = NULL;
234 memif_conn_args_t args;
235 memset (&args, 0, sizeof (args));
237 libmemif_main_t *lm = &libmemif_main;
240 memif_init (control_fd_update, TEST_APP_NAME, NULL,
241 NULL)) != MEMIF_ERR_SUCCESS)
242 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
244 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
246 if ((err = memif_create (&conn, &args, on_connect,
247 on_disconnect, on_interrupt,
248 NULL)) != MEMIF_ERR_SUCCESS)
249 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
251 args.interface_id = 1;
253 if ((err = memif_create (&conn1, &args, on_connect,
254 on_disconnect, on_interrupt,
255 NULL)) != MEMIF_ERR_SUCCESS)
256 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
258 memif_connection_t *c = (memif_connection_t *) conn;
259 memif_connection_t *c1 = (memif_connection_t *) conn1;
261 ck_assert_ptr_ne (c, NULL);
262 ck_assert_ptr_ne (c1, NULL);
264 ck_assert_uint_eq (c->args.interface_id, 0);
265 ck_assert_uint_eq (c->args.is_master, args.is_master);
266 ck_assert_uint_eq (c->args.mode, args.mode);
267 ck_assert_uint_eq (c1->args.interface_id, 1);
268 ck_assert_uint_eq (c1->args.is_master, args.is_master);
269 ck_assert_uint_eq (c1->args.mode, args.mode);
271 ck_assert_uint_eq (c->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
272 ck_assert_uint_eq (c->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
273 ck_assert_uint_eq (c->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
274 ck_assert_uint_eq (c->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
275 ck_assert_uint_eq (c1->args.num_s2m_rings, MEMIF_DEFAULT_TX_QUEUES);
276 ck_assert_uint_eq (c1->args.num_m2s_rings, MEMIF_DEFAULT_RX_QUEUES);
277 ck_assert_uint_eq (c1->args.buffer_size, MEMIF_DEFAULT_BUFFER_SIZE);
278 ck_assert_uint_eq (c1->args.log2_ring_size, MEMIF_DEFAULT_LOG2_RING_SIZE);
280 ck_assert_ptr_eq (c->msg_queue, NULL);
281 ck_assert_ptr_eq (c->regions, NULL);
282 ck_assert_ptr_eq (c->tx_queues, NULL);
283 ck_assert_ptr_eq (c->rx_queues, NULL);
284 ck_assert_ptr_eq (c1->msg_queue, NULL);
285 ck_assert_ptr_eq (c1->regions, NULL);
286 ck_assert_ptr_eq (c1->tx_queues, NULL);
287 ck_assert_ptr_eq (c1->rx_queues, NULL);
289 ck_assert_int_eq (c->fd, -1);
290 ck_assert_int_eq (c1->fd, -1);
292 ck_assert_ptr_ne (c->on_connect, NULL);
293 ck_assert_ptr_ne (c->on_disconnect, NULL);
294 ck_assert_ptr_ne (c->on_interrupt, NULL);
295 ck_assert_ptr_ne (c1->on_connect, NULL);
296 ck_assert_ptr_ne (c1->on_disconnect, NULL);
297 ck_assert_ptr_ne (c1->on_interrupt, NULL);
299 ck_assert_str_eq (c->args.interface_name, args.interface_name);
300 ck_assert_str_eq (c->args.socket_filename, SOCKET_FILENAME);
301 ck_assert_str_eq (c1->args.interface_name, args.interface_name);
302 ck_assert_str_eq (c1->args.socket_filename, SOCKET_FILENAME);
304 struct itimerspec timer;
305 timerfd_gettime (lm->timerfd, &timer);
307 ck_assert_msg (timer.it_interval.tv_sec == lm->arm.it_interval.tv_sec,
308 "timerfd not armed!");
314 memif_delete (&conn);
315 ck_assert_ptr_eq (conn, NULL);
319 START_TEST (test_control_fd_handler)
323 memif_conn_handle_t conn = NULL;
324 memif_conn_args_t args;
325 memset (&args, 0, sizeof (args));
326 args.num_s2m_rings = 2;
327 args.num_m2s_rings = 2;
329 libmemif_main_t *lm = &libmemif_main;
332 memif_init (control_fd_update, TEST_APP_NAME, NULL,
333 NULL)) != MEMIF_ERR_SUCCESS)
334 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
336 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
338 if ((err = memif_create (&conn, &args, on_connect,
339 on_disconnect, on_interrupt,
340 NULL)) != MEMIF_ERR_SUCCESS)
341 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
343 memif_connection_t *c = (memif_connection_t *) conn;
346 memif_control_fd_handler (lm->timerfd,
347 MEMIF_FD_EVENT_READ)) != MEMIF_ERR_SUCCESS)
348 ck_assert_msg (err == MEMIF_ERR_NO_FILE, "err code: %u, err msg: %s", err,
349 memif_strerror (err));
351 register_fd_ready_fn (c, read_fn, write_fn, error_fn);
353 lm->control_list[0].key = c->fd;
354 lm->control_list[0].data_struct = c;
357 memif_control_fd_handler (c->fd,
358 MEMIF_FD_EVENT_READ)) != MEMIF_ERR_SUCCESS)
359 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
361 ck_assert (ready_called & read_call);
364 memif_control_fd_handler (c->fd,
365 MEMIF_FD_EVENT_WRITE)) != MEMIF_ERR_SUCCESS)
366 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
368 ck_assert (ready_called & write_call);
371 memif_control_fd_handler (c->fd,
372 MEMIF_FD_EVENT_ERROR)) != MEMIF_ERR_SUCCESS)
373 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
375 ck_assert (ready_called & error_call);
381 memif_delete (&conn);
382 ck_assert_ptr_eq (conn, NULL);
386 START_TEST (test_buffer_alloc)
391 memif_buffer_t *bufs;
392 uint16_t max_buf = 10;
394 memif_conn_handle_t conn = NULL;
395 memif_conn_args_t args;
396 memset (&args, 0, sizeof (args));
397 args.num_s2m_rings = 2;
398 args.num_m2s_rings = 2;
400 libmemif_main_t *lm = &libmemif_main;
403 memif_init (control_fd_update, TEST_APP_NAME, NULL,
404 NULL)) != MEMIF_ERR_SUCCESS)
405 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
407 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
409 if ((err = memif_create (&conn, &args, on_connect,
410 on_disconnect, on_interrupt,
411 NULL)) != MEMIF_ERR_SUCCESS)
412 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
414 memif_connection_t *c = (memif_connection_t *) conn;
416 c->run_args.num_s2m_rings = 2;
417 c->run_args.num_m2s_rings = 2;
418 c->run_args.log2_ring_size = 10;
419 c->run_args.buffer_size = 2048;
421 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
422 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
426 /* test buffer allocation qid 0 (positive) */
428 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
432 memif_buffer_alloc (conn, qid, bufs, max_buf,
434 MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
435 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
437 ck_assert_uint_eq (buf, max_buf);
438 for (i = 0; i < max_buf; i++)
439 ck_assert_uint_eq (bufs[i].len, MEMIF_DEFAULT_BUFFER_SIZE);
441 /* test buffer allocation qid 1 (positive) */
443 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
447 memif_buffer_alloc (conn, qid, bufs, max_buf,
449 MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
450 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
452 ck_assert_uint_eq (buf, max_buf);
453 for (i = 0; i < max_buf; i++)
454 ck_assert_uint_eq (bufs[i].len, MEMIF_DEFAULT_BUFFER_SIZE);
456 /* test buffer allocation qid 2 (negative) */
459 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
463 memif_buffer_alloc (conn, qid, bufs, max_buf,
465 MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
466 ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
467 memif_strerror (err));
476 memif_delete (&conn);
477 ck_assert_ptr_eq (conn, NULL);
481 START_TEST (test_tx_burst)
484 uint16_t max_buf = 10, buf, tx;
486 memif_buffer_t *bufs;
488 memif_conn_handle_t conn = NULL;
489 memif_conn_args_t args;
490 memset (&args, 0, sizeof (args));
491 args.num_s2m_rings = 2;
492 args.num_m2s_rings = 2;
494 libmemif_main_t *lm = &libmemif_main;
497 memif_init (control_fd_update, TEST_APP_NAME, NULL,
498 NULL)) != MEMIF_ERR_SUCCESS)
499 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
501 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
503 if ((err = memif_create (&conn, &args, on_connect,
504 on_disconnect, on_interrupt,
505 NULL)) != MEMIF_ERR_SUCCESS)
506 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
508 memif_connection_t *c = (memif_connection_t *) conn;
510 c->run_args.num_s2m_rings = 2;
511 c->run_args.num_m2s_rings = 2;
512 c->run_args.log2_ring_size = 10;
513 c->run_args.buffer_size = 2048;
515 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
516 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
520 /* test transmit qid 0 (positive) */
522 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
525 memif_buffer_alloc (conn, qid, bufs, max_buf,
527 MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
528 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
530 ck_assert_uint_eq (buf, max_buf);
531 for (i = 0; i < max_buf; i++)
532 ck_assert_uint_eq (bufs[i].len, MEMIF_DEFAULT_BUFFER_SIZE);
535 memif_tx_burst (conn, qid, bufs, max_buf, &tx)) != MEMIF_ERR_SUCCESS)
536 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
538 ck_assert_uint_eq (tx, max_buf);
539 for (i = 0; i < max_buf; i++)
540 ck_assert_ptr_eq (bufs[i].data, NULL);
542 /* test transmit qid 1 (positive) */
544 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
547 memif_buffer_alloc (conn, qid, bufs, max_buf,
549 MEMIF_DEFAULT_BUFFER_SIZE)) != MEMIF_ERR_SUCCESS)
550 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
552 ck_assert_uint_eq (buf, max_buf);
553 for (i = 0; i < max_buf; i++)
554 ck_assert_uint_eq (bufs[i].len, MEMIF_DEFAULT_BUFFER_SIZE);
557 memif_tx_burst (conn, qid, bufs, max_buf, &tx)) != MEMIF_ERR_SUCCESS)
558 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
560 ck_assert_uint_eq (tx, max_buf);
561 for (i = 0; i < max_buf; i++)
562 ck_assert_ptr_eq (bufs[i].data, NULL);
564 /* test transmit qid 2 (negative) */
566 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
569 memif_tx_burst (conn, qid, bufs, max_buf, &tx)) != MEMIF_ERR_SUCCESS)
570 ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
571 memif_strerror (err));
579 memif_delete (&conn);
580 ck_assert_ptr_eq (conn, NULL);
584 START_TEST (test_rx_burst)
587 uint16_t max_buf = 10, buf, rx;
589 memif_buffer_t *bufs;
593 memif_conn_handle_t conn = NULL;
594 memif_conn_args_t args;
595 memset (&args, 0, sizeof (args));
596 args.num_s2m_rings = 2;
597 args.num_m2s_rings = 2;
599 libmemif_main_t *lm = &libmemif_main;
602 memif_init (control_fd_update, TEST_APP_NAME, NULL,
603 NULL)) != MEMIF_ERR_SUCCESS)
604 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
606 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
608 if ((err = memif_create (&conn, &args, on_connect,
609 on_disconnect, on_interrupt,
610 NULL)) != MEMIF_ERR_SUCCESS)
611 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
613 memif_connection_t *c = (memif_connection_t *) conn;
615 c->run_args.num_s2m_rings = 2;
616 c->run_args.num_m2s_rings = 2;
617 c->run_args.log2_ring_size = 10;
618 c->run_args.buffer_size = 2048;
620 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
621 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
625 /* test receive qid 0 (positive) */
627 mq = &c->rx_queues[qid];
629 ring->tail += max_buf;
631 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
634 memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
635 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
637 ck_assert_uint_eq (rx, max_buf);
638 for (i = 0; i < max_buf; i++)
639 ck_assert_ptr_ne (bufs[i].data, NULL);
641 /* test receive qid 1 (positive) */
643 mq = &c->rx_queues[qid];
645 ring->tail += max_buf;
648 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
651 memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
652 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
654 ck_assert_uint_eq (rx, max_buf);
655 for (i = 0; i < max_buf; i++)
656 ck_assert_ptr_ne (bufs[i].data, NULL);
658 /* test receive qid 2 (negative) */
660 bufs = malloc (sizeof (memif_buffer_t) * max_buf);
663 memif_rx_burst (conn, qid, bufs, max_buf, &rx)) != MEMIF_ERR_SUCCESS)
664 ck_assert_msg (err == MEMIF_ERR_QID, "err code: %u, err msg: %s", err,
665 memif_strerror (err));
673 memif_delete (&conn);
674 ck_assert_ptr_eq (conn, NULL);
678 START_TEST (test_get_details)
682 memif_conn_handle_t conn = NULL;
683 memif_conn_args_t args;
684 memset (&args, 0, sizeof (args));
685 args.num_s2m_rings = 2;
686 args.num_m2s_rings = 2;
688 libmemif_main_t *lm = &libmemif_main;
691 memif_init (control_fd_update, TEST_APP_NAME, NULL,
692 NULL)) != MEMIF_ERR_SUCCESS)
693 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
695 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
697 if ((err = memif_create (&conn, &args, on_connect,
698 on_disconnect, on_interrupt,
699 NULL)) != MEMIF_ERR_SUCCESS)
700 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
702 memif_connection_t *c = (memif_connection_t *) conn;
704 c->run_args.num_s2m_rings = 2;
705 c->run_args.num_m2s_rings = 2;
706 c->run_args.log2_ring_size = 10;
707 c->run_args.buffer_size = 2048;
709 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
710 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
713 memset (&md, 0, sizeof (md));
714 ssize_t buflen = 2048;
715 char *buf = malloc (buflen);
716 memset (buf, 0, buflen);
718 if ((err = memif_get_details (conn, &md, buf, buflen)) != MEMIF_ERR_SUCCESS)
719 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
721 ck_assert_str_eq (md.if_name, c->args.interface_name);
722 ck_assert_str_eq (md.remote_if_name, c->remote_if_name);
723 ck_assert_str_eq (md.remote_inst_name, c->remote_name);
724 ck_assert_str_eq (md.secret, c->args.secret);
725 ck_assert_str_eq (md.socket_filename, c->args.socket_filename);
727 ck_assert_uint_eq (md.id, c->args.interface_id);
728 ck_assert_uint_ne (md.role, c->args.is_master);
729 ck_assert_uint_eq (md.mode, c->args.mode);
730 for (i = 0; i < md.rx_queues_num; i++)
732 ck_assert_uint_eq (md.rx_queues[i].qid, i);
733 ck_assert_uint_eq (md.rx_queues[i].ring_size,
734 (1 << c->args.log2_ring_size));
735 ck_assert_uint_eq (md.rx_queues[i].buffer_size, c->args.buffer_size);
737 for (i = 0; i < md.tx_queues_num; i++)
739 ck_assert_uint_eq (md.tx_queues[i].qid, i);
740 ck_assert_uint_eq (md.tx_queues[i].ring_size,
741 (1 << c->args.log2_ring_size));
742 ck_assert_uint_eq (md.tx_queues[i].buffer_size, c->args.buffer_size);
744 ck_assert_uint_eq (md.link_up_down, 0);
750 memif_delete (&conn);
751 ck_assert_ptr_eq (conn, NULL);
755 START_TEST (test_init_regions_and_queues)
759 memif_conn_handle_t conn = NULL;
760 memif_conn_args_t args;
761 memset (&args, 0, sizeof (args));
762 args.num_s2m_rings = 2;
763 args.num_m2s_rings = 2;
765 libmemif_main_t *lm = &libmemif_main;
768 memif_init (control_fd_update, TEST_APP_NAME, NULL,
769 NULL)) != MEMIF_ERR_SUCCESS)
770 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
772 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
774 if ((err = memif_create (&conn, &args, on_connect,
775 on_disconnect, on_interrupt,
776 NULL)) != MEMIF_ERR_SUCCESS)
777 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
779 memif_connection_t *c = (memif_connection_t *) conn;
781 c->run_args.num_s2m_rings = 2;
782 c->run_args.num_m2s_rings = 2;
783 c->run_args.log2_ring_size = 10;
784 c->run_args.buffer_size = 2048;
786 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
787 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
789 ck_assert_ptr_ne (c->regions, NULL);
790 ck_assert_ptr_ne (c->tx_queues, NULL);
791 ck_assert_ptr_ne (c->rx_queues, NULL);
793 ck_assert_ptr_ne (c->regions->shm, NULL);
794 ck_assert_ptr_ne (c->tx_queues->ring, NULL);
795 ck_assert_ptr_ne (c->rx_queues->ring, NULL);
797 ck_assert_int_ne (c->regions->fd, -1);
798 ck_assert_uint_eq (c->tx_queues->ring->cookie, MEMIF_COOKIE);
799 ck_assert_uint_eq (c->rx_queues->ring->cookie, MEMIF_COOKIE);
805 memif_delete (&conn);
806 ck_assert_ptr_eq (conn, NULL);
810 START_TEST (test_connect1)
814 memif_conn_handle_t conn = NULL;
815 memif_conn_args_t args;
816 memset (&args, 0, sizeof (args));
817 args.num_s2m_rings = 2;
818 args.num_m2s_rings = 2;
820 libmemif_main_t *lm = &libmemif_main;
823 memif_init (control_fd_update, TEST_APP_NAME, NULL,
824 NULL)) != MEMIF_ERR_SUCCESS)
825 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
827 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
829 if ((err = memif_create (&conn, &args, on_connect,
830 on_disconnect, on_interrupt,
831 NULL)) != MEMIF_ERR_SUCCESS)
832 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
834 memif_connection_t *c = (memif_connection_t *) conn;
836 c->run_args.num_s2m_rings = 2;
837 c->run_args.num_m2s_rings = 2;
838 c->run_args.log2_ring_size = 10;
839 c->run_args.buffer_size = 2048;
841 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
842 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
844 if ((err = memif_connect1 (c)) != MEMIF_ERR_SUCCESS)
845 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
851 memif_delete (&conn);
852 ck_assert_ptr_eq (conn, NULL);
856 START_TEST (test_disconnect_internal)
860 memif_conn_handle_t conn = NULL;
861 memif_conn_args_t args;
862 memset (&args, 0, sizeof (args));
863 args.num_s2m_rings = 2;
864 args.num_m2s_rings = 2;
866 libmemif_main_t *lm = &libmemif_main;
869 memif_init (control_fd_update, TEST_APP_NAME, NULL,
870 NULL)) != MEMIF_ERR_SUCCESS)
871 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
873 strncpy ((char *) args.interface_name, TEST_IF_NAME, strlen (TEST_IF_NAME));
875 if ((err = memif_create (&conn, &args, on_connect,
876 on_disconnect, on_interrupt,
877 NULL)) != MEMIF_ERR_SUCCESS)
878 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
880 memif_connection_t *c = (memif_connection_t *) conn;
882 c->run_args.num_s2m_rings = 2;
883 c->run_args.num_m2s_rings = 2;
884 c->run_args.log2_ring_size = 10;
885 c->run_args.buffer_size = 2048;
887 if ((err = memif_init_regions_and_queues (c)) != MEMIF_ERR_SUCCESS)
888 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
890 if ((err = memif_disconnect_internal (c)) != MEMIF_ERR_SUCCESS)
891 ck_abort_msg ("err code: %u, err msg: %s", err, memif_strerror (err));
893 ck_assert_int_eq (c->fd, -1);
895 ck_assert_ptr_eq (c->tx_queues, NULL);
896 ck_assert_ptr_eq (c->rx_queues, NULL);
897 ck_assert_ptr_eq (c->regions, NULL);
898 ck_assert_ptr_eq (c->msg_queue, NULL);
900 struct itimerspec timer;
901 timerfd_gettime (lm->timerfd, &timer);
903 ck_assert_msg (timer.it_interval.tv_sec == lm->arm.it_interval.tv_sec,
904 "timerfd not armed!");
910 memif_delete (&conn);
911 ck_assert_ptr_eq (conn, NULL);
922 /* create main test suite */
923 s = suite_create ("Libmemif main");
925 /* create api test case */
926 tc_api = tcase_create ("Api calls");
927 /* add tests to test case */
928 tcase_add_test (tc_api, test_init);
929 tcase_add_test (tc_api, test_init_epoll);
930 tcase_add_test (tc_api, test_create);
931 tcase_add_test (tc_api, test_create_master);
932 tcase_add_test (tc_api, test_create_mult);
933 tcase_add_test (tc_api, test_control_fd_handler);
934 tcase_add_test (tc_api, test_buffer_alloc);
935 tcase_add_test (tc_api, test_tx_burst);
936 tcase_add_test (tc_api, test_rx_burst);
937 tcase_add_test (tc_api, test_get_details);
939 /* create internal test case */
940 tc_internal = tcase_create ("Internal");
941 /* add tests to test case */
942 tcase_add_test (tc_internal, test_init_regions_and_queues);
943 tcase_add_test (tc_internal, test_connect1);
944 tcase_add_test (tc_internal, test_disconnect_internal);
946 /* add test cases to test suite */
947 suite_add_tcase (s, tc_api);
948 suite_add_tcase (s, tc_internal);
950 /* return main test suite to test runner */