trema 0.1.3

data/unittests/lib/message_queue_test.c

@@ -0,0 +1,379 @@
+/*
+ * Unit tests for message queue.
+ *
+ * Author: SUGYO Kazushi
+ *
+ * Copyright (C) 2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "checks.h"
+#include "cmockery_trema.h"
+#include "log.h"
+#include "message_queue.h"
+#include "wrapper.h"
+
+
+/*************************************************************************
+ * Helper.
+ *************************************************************************/
+
+// Setup and teardown function.
+
+static void ( *original_die )( const char *format, ... );
+
+static void
+mock_die( const char *format, ... ) {
+  UNUSED( format );
+  mock_assert( false, "mock_die", __FILE__, __LINE__ ); } // Hoaxes gcov.
+
+
+static void
+setup() {
+  original_die = die;
+  die = mock_die;
+}
+
+
+static void
+teardown() {
+  die = original_die;
+}
+
+
+/*************************************************************************
+ * create and delete tests.
+ *************************************************************************/
+
+static void
+test_create_and_delete_message_queue() {
+  message_queue *queue = create_message_queue();
+  assert_true( queue != NULL );
+  assert_int_equal( queue->length, 0 );
+
+  assert_true( delete_message_queue( queue ) );
+}
+
+
+static void
+test_delete_message_queue_if_queue_is_not_created() {
+  message_queue *queue = NULL;
+  expect_assert_failure( delete_message_queue( queue ) );
+}
+
+
+static void
+test_enqueue_and_delete_message_queue() {
+  message_queue *queue = create_message_queue();
+  assert_true( queue != NULL );
+  assert_int_equal( queue->length, 0 );
+
+  buffer *buf = alloc_buffer();
+  assert_true( enqueue_message( queue, buf ) );
+  assert_int_equal( queue->length, 1 );
+
+  assert_true( delete_message_queue( queue ) );
+}
+
+
+/*************************************************************************
+ * enqeue and dequeue tests.
+ *************************************************************************/
+
+static void
+test_enqueue_and_dequeue_message_queue() {
+  message_queue *queue = create_message_queue();
+  assert_true( queue != NULL );
+
+  buffer *enq_buf = alloc_buffer();
+  assert_true( enqueue_message( queue, enq_buf ) );
+  assert_int_equal( queue->length, 1 );
+
+  buffer *deq_buf = dequeue_message( queue );
+  assert_true( deq_buf == enq_buf );
+  free_buffer( deq_buf );
+  assert_int_equal( queue->length, 0 );
+
+  deq_buf = dequeue_message( queue );
+  assert_true( deq_buf == NULL );
+  assert_int_equal( queue->length, 0 );
+
+  assert_true( delete_message_queue( queue ) );
+}
+
+
+static void
+test_multiple_queueing() {
+  message_queue *queue = create_message_queue();
+  assert_true( queue != NULL );
+
+  buffer *first_buf = alloc_buffer();
+  assert_true( enqueue_message( queue, first_buf ) );
+  assert_int_equal( queue->length, 1 );
+
+  buffer *deq_buf = dequeue_message( queue );
+  assert_true( deq_buf == first_buf );
+  free_buffer( deq_buf );
+  assert_int_equal( queue->length, 0 );
+
+
+  first_buf = alloc_buffer();
+  assert_true( enqueue_message( queue, first_buf ) );
+  assert_int_equal( queue->length, 1 );
+  buffer *second_buf = alloc_buffer();
+  assert_true( enqueue_message( queue, second_buf ) );
+  assert_int_equal( queue->length, 2 );
+
+  deq_buf = dequeue_message( queue );
+  assert_true( deq_buf == first_buf );
+  free_buffer( deq_buf );
+  assert_int_equal( queue->length, 1 );
+
+  buffer *third_buf = alloc_buffer();
+  assert_true( enqueue_message( queue, third_buf ) );
+  assert_int_equal( queue->length, 2 );
+  buffer *fourth_buf = alloc_buffer();
+  assert_true( enqueue_message( queue, fourth_buf ) );
+  assert_int_equal( queue->length, 3 );
+
+  deq_buf = dequeue_message( queue );
+  assert_true( deq_buf == second_buf );
+  free_buffer( deq_buf );
+  assert_int_equal( queue->length, 2 );
+  deq_buf = dequeue_message( queue );
+  assert_true( deq_buf == third_buf );
+  free_buffer( deq_buf );
+  assert_int_equal( queue->length, 1 );
+  deq_buf = dequeue_message( queue );
+  assert_true( deq_buf == fourth_buf );
+  free_buffer( deq_buf );
+  assert_int_equal( queue->length, 0 );
+
+
+  assert_true( delete_message_queue( queue ) );
+}
+
+
+static void
+test_enqueue_message_if_queue_is_not_created() {
+  message_queue *queue = NULL;
+  buffer *enq_buf = alloc_buffer();
+  expect_assert_failure( enqueue_message( queue, enq_buf ) );
+  free_buffer( enq_buf );
+}
+
+
+static void
+test_enqueue_message_if_message_is_NULL() {
+  message_queue *queue = create_message_queue();
+  assert_true( queue != NULL );
+  assert_int_equal( queue->length, 0 );
+
+  expect_assert_failure( enqueue_message( queue, NULL ) );
+
+  assert_true( delete_message_queue( queue ) );
+}
+
+
+static void
+test_dequeue_message_if_queue_is_not_created() {
+  message_queue *queue = NULL;
+  expect_assert_failure( dequeue_message( queue ) );
+}
+
+
+/*************************************************************************
+ * peek tests.
+ *************************************************************************/
+
+static void
+test_peek_message() {
+  message_queue *queue = create_message_queue();
+  assert_true( queue != NULL );
+
+  buffer *peek_buf = peek_message( queue );
+  assert_true( peek_buf == NULL );
+
+  buffer *first_buf = alloc_buffer();
+  assert_true( enqueue_message( queue, first_buf ) );
+  assert_int_equal( queue->length, 1 );
+  buffer *second_buf = alloc_buffer();
+  assert_true( enqueue_message( queue, second_buf ) );
+  assert_int_equal( queue->length, 2 );
+  buffer *third_buf = alloc_buffer();
+  assert_true( enqueue_message( queue, third_buf ) );
+  assert_int_equal( queue->length, 3 );
+
+  peek_buf = peek_message( queue );
+  assert_true( peek_buf == first_buf );
+  buffer *deq_buf = dequeue_message( queue );
+  assert_true( deq_buf == first_buf );
+  free_buffer( deq_buf );
+  assert_int_equal( queue->length, 2 );
+
+  peek_buf = peek_message( queue );
+  assert_true( peek_buf == second_buf );
+  deq_buf = dequeue_message( queue );
+  assert_true( deq_buf == second_buf );
+  free_buffer( deq_buf );
+  assert_int_equal( queue->length, 1 );
+
+  peek_buf = peek_message( queue );
+  assert_true( peek_buf == third_buf );
+  deq_buf = dequeue_message( queue );
+  assert_true( deq_buf == third_buf );
+  free_buffer( deq_buf );
+  assert_int_equal( queue->length, 0 );
+
+  peek_buf = peek_message( queue );
+  assert_true( peek_buf == NULL );
+  deq_buf = dequeue_message( queue );
+  assert_true( deq_buf == NULL );
+  assert_int_equal( queue->length, 0 );
+
+  assert_true( delete_message_queue( queue ) );
+}
+
+
+static void
+test_peek_message_if_queue_is_not_created() {
+  message_queue *queue = NULL;
+  expect_assert_failure( peek_message( queue ) );
+}
+
+
+/*************************************************************************
+ * foreach_message_queue tests.
+ *************************************************************************/
+
+
+static int count = 0;
+
+static void
+test_foreach_message_queue_helper( buffer *message, void *user_data ) {
+  const char *str = message->data;
+  assert_string_equal( ( char * ) user_data, "user_data" );
+  switch ( ++count ) {
+    case 1:
+      assert_string_equal( str, "second_buffer" );
+      break;
+    case 2:
+      assert_string_equal( str, "third_buffer" );
+      break;
+    default:
+      assert_true( false );
+      break;
+  }
+}
+
+
+static void
+append_string( buffer *buf, const char *str ) {
+  char *text = append_back_buffer( buf, strlen( str ) + 1 );
+  strcpy( text, str );
+}
+
+
+static void
+test_foreach_message_queue() {
+  message_queue *queue = create_message_queue();
+  assert_true( queue != NULL );
+
+  buffer *first_buf = alloc_buffer();
+  append_string( first_buf, "first_buffer" );
+  assert_true( enqueue_message( queue, first_buf ) );
+  assert_int_equal( queue->length, 1 );
+  buffer *second_buf = alloc_buffer();
+  append_string( second_buf, "second_buffer" );
+  assert_true( enqueue_message( queue, second_buf ) );
+  assert_int_equal( queue->length, 2 );
+  buffer *third_buf = alloc_buffer();
+  append_string( third_buf, "third_buffer" );
+  assert_true( enqueue_message( queue, third_buf ) );
+  assert_int_equal( queue->length, 3 );
+
+  buffer *deq_buf = dequeue_message( queue );
+  assert_true( deq_buf == first_buf );
+
+  char *user_data = xstrdup( "user_data" );
+  count = 0;
+
+  foreach_message_queue( queue, test_foreach_message_queue_helper, user_data );
+
+  assert_int_equal( count, 2 );
+
+  xfree( user_data );
+  assert_true( delete_message_queue( queue ) );
+}
+
+
+static void
+test_foreach_message_queue_if_queue_is_empty_helper( buffer *message, void *user_data ) {
+  UNUSED( message );
+  UNUSED( user_data );
+  assert_true( false );
+}
+
+
+static void
+test_foreach_message_queue_if_queue_is_empty() {
+  message_queue *queue = create_message_queue();
+  assert_true( queue != NULL );
+
+  char *user_data = xstrdup( "user_data" );
+  foreach_message_queue( queue, test_foreach_message_queue_if_queue_is_empty_helper, user_data );
+
+  assert_int_equal( count, 2 );
+
+  xfree( user_data );
+  assert_true( delete_message_queue( queue ) );
+}
+
+
+/*************************************************************************
+ * Run tests.
+ *************************************************************************/
+
+int
+main() {
+  const UnitTest tests[] = {
+    unit_test_setup_teardown( test_create_and_delete_message_queue, setup, teardown ),
+    unit_test_setup_teardown( test_delete_message_queue_if_queue_is_not_created, setup, teardown ),
+    unit_test_setup_teardown( test_enqueue_and_delete_message_queue, setup, teardown ),
+    unit_test_setup_teardown( test_enqueue_and_dequeue_message_queue, setup, teardown ),
+    unit_test_setup_teardown( test_multiple_queueing, setup, teardown ),
+    unit_test_setup_teardown( test_enqueue_message_if_queue_is_not_created, setup, teardown ),
+    unit_test_setup_teardown( test_enqueue_message_if_message_is_NULL, setup, teardown ),
+    unit_test_setup_teardown( test_dequeue_message_if_queue_is_not_created, setup, teardown ),
+    unit_test_setup_teardown( test_peek_message, setup, teardown ),
+    unit_test_setup_teardown( test_peek_message_if_queue_is_not_created, setup, teardown ),
+    unit_test_setup_teardown( test_foreach_message_queue, setup, teardown ),
+    unit_test_setup_teardown( test_foreach_message_queue_if_queue_is_empty, setup, teardown ),
+  };
+
+  return run_tests( tests );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/unittests/lib/messenger_test.c

@@ -0,0 +1,438 @@
+/*
+ * Unit tests for Trema messenger.
+ *
+ * Author: Toshio Koide
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <linux/limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <time.h>
+#include <unistd.h>
+#include "checks.h"
+#include "cmockery_trema.h"
+#include "doubly_linked_list.h"
+#include "hash_table.h"
+#include "event_handler.h"
+#include "messenger.h"
+#include "timer.h"
+#include "wrapper.h"
+
+
+#define static extern
+
+
+enum {
+  MESSAGE_TYPE_NOTIFY,
+  MESSAGE_TYPE_REQUEST,
+  MESSAGE_TYPE_REPLY,
+};
+
+typedef struct message_buffer {
+  void *buffer;
+  size_t data_length;
+  size_t size;
+} message_buffer;
+
+typedef struct messenger_socket {
+  int fd;
+} messenger_socket;
+
+typedef struct messenger_context {
+  uint32_t transaction_id;
+  int life_count;
+  void *user_data;
+} messenger_context;
+
+typedef struct receive_queue_callback {
+  void  *function;
+  uint8_t message_type;
+} receive_queue_callback;
+
+typedef struct receive_queue {
+  char service_name[ MESSENGER_SERVICE_NAME_LENGTH ];
+  dlist_element *message_callbacks;
+  int listen_socket;
+  struct sockaddr_un listen_addr;
+  dlist_element *client_sockets;
+  message_buffer *buffer;
+} receive_queue;
+
+typedef struct send_queue {
+  char service_name[ MESSENGER_SERVICE_NAME_LENGTH ];
+  int server_socket;
+  int refused_count;
+  struct timespec reconnect_at;
+  struct sockaddr_un server_addr;
+  message_buffer *buffer;
+} send_queue;
+
+
+static void send_dump_message( uint16_t dump_type, const char *service_name, const void *data, uint32_t data_len );
+
+static bool run_once( void );
+
+static void on_accept( int fd, receive_queue *queue );
+static void on_recv( int fd, receive_queue *queue );
+static void on_send( int fd, send_queue *queue );
+
+static receive_queue *create_receive_queue( const char *service_name );
+static void delete_all_receive_queues( void );
+static void delete_receive_queue( void *service_name, void *queue, void *user_data );
+static int pull_from_recv_queue( receive_queue *queue, uint8_t *message_type, uint16_t *tag, void *data, size_t *len, size_t maxlen );
+static void set_recv_queue_fd_set( fd_set *read_set );
+static void check_recv_queue_fd_isset( fd_set *read_set );
+static void add_recv_queue_client_fd( receive_queue *queue, int fd );
+static int del_recv_queue_client_fd( receive_queue *queue, int fd );
+static void call_message_callbacks( receive_queue *rq, const uint8_t message_type, const uint16_t tag, void *data, size_t len );
+
+static send_queue *create_send_queue( const char *service_name );
+static int send_queue_connect( send_queue *queue );
+static void delete_all_send_queues( void );
+static void delete_send_queue( send_queue *sq );
+static void number_of_send_queue( int *connected_count, int *sending_count, int *reconnecting_count, int *closed_count );
+static bool push_message_to_send_queue( const char *service_name, const uint8_t message_type, const uint16_t tag, const void *data, size_t len );
+static void set_send_queue_fd_set( fd_set *read_set, fd_set *write_set );
+static void check_send_queue_fd_isset( fd_set *read_set, fd_set *write_set );
+
+static message_buffer *create_message_buffer( size_t size );
+static bool write_message_buffer( message_buffer *buf, const void *data, size_t len );
+static void truncate_message_buffer( message_buffer *buf, size_t len );
+static void free_message_buffer( message_buffer *buf );
+static size_t message_buffer_remain_bytes( message_buffer *buf );
+
+static void delete_timer_callbacks( void );
+
+static messenger_context* insert_context( void *user_data );
+static messenger_context* get_context( uint32_t transaction_id );
+static void delete_context( messenger_context *context );
+static void delete_context_db( void );
+static void age_context_db( void * );
+
+static const uint32_t messenger_buffer_length;
+
+static char socket_directory[ PATH_MAX ];
+static bool running;
+static bool initialized;
+static bool finalized;
+static hash_table *receive_queues;
+static hash_table *send_queues;
+static hash_table *context_db;
+static dlist_element *timer_callbacks;
+static char *_dump_service_name;
+static char *_dump_app_name;
+static uint32_t last_transaction_id;
+
+
+
+#undef static
+
+
+#define SERVICE_NAME1 "test1"
+#define SERVICE_NAME2 "test2"
+#define MESSAGE1 "message1"
+#define MESSAGE2 "message2"
+#define MESSAGE_TYPE1 1234
+#define DUMP_SERVICE_NAME "dump"
+#define DUMP_APP_NAME "appname"
+#define TAG1 1
+#define TAG2 2
+#define CONTEXT_DATA "context data"
+
+
+/********************************************************************************
+ * Mocks.
+ ********************************************************************************/
+
+void
+mock_execute_timer_events( int *next_timeout_usec ) {
+  UNUSED( next_timeout_usec );
+  // Do nothing.
+}
+
+
+bool
+mock_add_periodic_event_callback( const time_t seconds, void ( *callback )( void *user_data ), void *user_data ) {
+  UNUSED( seconds );
+  UNUSED( callback );
+  UNUSED( user_data );
+  return true;
+}
+
+
+static bool fail_mock_socket = false;
+int
+mock_socket( int domain, int type, int protocol ) {
+  return fail_mock_socket ? -1  : socket( domain, type, protocol );
+}
+
+
+static bool fail_mock_bind = false;
+int
+mock_bind( int sockfd, const struct sockaddr *addr, socklen_t addrlen ) {
+  return fail_mock_bind ? -1 : bind( sockfd, addr, addrlen );
+}
+
+
+static bool fail_mock_listen = false;
+int
+mock_listen( int sockfd, int backlog ) {
+  return fail_mock_listen ? -1 :listen( sockfd, backlog );
+}
+
+
+static bool fail_mock_close = false;
+int
+mock_close( int fd ) {
+  return fail_mock_close ? -1 : close( fd );
+}
+
+
+static bool fail_mock_connect = false;
+int
+mock_connect( int sockfd, const struct sockaddr *addr, socklen_t addrlen ) {
+  return fail_mock_connect ? -1 : connect( sockfd, addr, addrlen );
+}
+
+
+static bool fail_mock_select = false;
+int
+mock_select( int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout ) {
+  return fail_mock_select ? -1 : select( nfds, readfds, writefds, exceptfds, timeout );
+}
+
+
+static bool fail_mock_accept = false;
+int
+mock_accept( int sockfd, struct sockaddr *addr, socklen_t *addrlen ) {
+  return fail_mock_accept ? -1 : accept( sockfd, addr, addrlen );
+}
+
+
+static bool fail_mock_recv = false;
+ssize_t
+mock_recv( int sockfd, void *buf, size_t len, int flags ) {
+  return fail_mock_recv ? -1 : recv( sockfd, buf, len, flags );
+}
+
+
+static bool fail_mock_send = false;
+ssize_t
+mock_send( int sockfd, const void *buf, size_t len, int flags ) {
+  return fail_mock_send ? -1 : send( sockfd, buf, len, flags );
+}
+
+
+int
+mock_setsockopt( int s, int level, int optname, const void *optval, socklen_t optlen ) {
+  UNUSED( s );
+  UNUSED( level );
+  UNUSED( optname );
+  UNUSED( optval );
+  UNUSED( optlen );
+  return 0;
+}
+
+
+int
+mock_clock_gettime( clockid_t clk_id, struct timespec *tp ) {
+  UNUSED( clk_id );
+  UNUSED( tp );
+
+  return ( int ) mock();
+}
+
+
+void
+mock_die( char *format, ... ) {
+  UNUSED( format );
+}
+
+
+void
+mock_error( char *format, ... ) {
+  UNUSED( format );
+}
+
+
+void
+mock_debug( char *format, ... ) {
+  UNUSED( format );
+}
+
+
+void
+mock_warn( char *format, ... ) {
+  UNUSED( format );
+}
+
+
+/********************************************************************************
+ * Callbacks.
+ ********************************************************************************/
+
+void
+message_requested_callback( const messenger_context_handle *handle, uint16_t tag, void *data, size_t len ) {
+  assert_true( handle != NULL );
+  assert_int_equal( tag, TAG1 );
+  assert_string_equal( data, MESSAGE1 );
+  assert_int_equal( ( int ) len, strlen( MESSAGE1 ) + 1 );
+  assert_true( send_reply_message( handle, TAG2, MESSAGE2, strlen( MESSAGE2 ) + 1 ) );
+}
+
+
+void
+message_replied_callback( uint16_t tag, void *data, size_t len, void *user_data ) {
+  assert_int_equal( tag, TAG2 );
+  assert_string_equal( data, MESSAGE2 );
+  assert_int_equal( ( int ) len, strlen( MESSAGE2 ) + 1 );
+  assert_string_equal( user_data, CONTEXT_DATA );
+  xfree( user_data );
+
+  stop_event_handler();
+  assert_true( stop_messenger() );
+}
+
+
+/********************************************************************************
+ * Helpers.
+ ********************************************************************************/
+
+static void
+reset_messenger() {
+  initialized = false;
+  finalized = false;
+
+  execute_timer_events = mock_execute_timer_events;
+}
+
+
+/********************************************************************************
+ * Init and finalize messenger tests.
+ ********************************************************************************/
+
+static void
+test_init_and_finalize() {
+  assert_true( init_messenger( "/tmp" ) );
+  assert_true( finalize_messenger() );
+}
+
+
+static void
+test_init_twice() {
+  assert_true( init_messenger( "/tmp" ) );
+  assert_true( init_messenger( "/tmp" ) );
+
+  finalize_messenger();
+}
+
+
+static void
+test_finalize_twice() {
+  init_messenger( "/tmp" );
+
+  assert_true( finalize_messenger() );
+  assert_false( finalize_messenger() );
+}
+
+
+static void
+test_finalize_without_init() {
+  assert_false( finalize_messenger() );
+}
+
+
+/********************************************************************************
+ * Message callback tests.
+ ********************************************************************************/
+
+static void
+callback_hello( uint16_t tag, void *data, size_t len ) {
+  check_expected( tag );
+  check_expected( data );
+  check_expected( len );
+
+  stop_event_handler();
+  stop_messenger();
+}
+
+
+static void
+test_send_then_message_received_callback_is_called() {
+  init_messenger( "/tmp" );
+
+  const char service_name[] = "Say HELLO";
+
+  expect_value( callback_hello, tag, 43556 );
+  expect_string( callback_hello, data, "HELLO" );
+  expect_value( callback_hello, len, 6 );
+
+  add_message_received_callback( service_name, callback_hello );
+  send_message( service_name, 43556, "HELLO", strlen( "HELLO" ) + 1 );
+  start_messenger();
+  start_event_handler();
+
+  delete_message_received_callback( service_name, callback_hello );
+  delete_send_queue( lookup_hash_entry( send_queues, service_name ) );
+
+  finalize_messenger();
+}
+
+
+/********************************************************************************
+ * Run tests.
+ ********************************************************************************/
+
+int
+main() {
+  const UnitTest tests[] = {
+    // init and finalize messenger tests.
+    unit_test_setup_teardown( test_init_and_finalize,
+                              reset_messenger,
+                              reset_messenger ),
+    unit_test_setup_teardown( test_init_twice,
+                              reset_messenger,
+                              reset_messenger ),
+    unit_test_setup_teardown( test_finalize_twice,
+                              reset_messenger,
+                              reset_messenger ),
+    unit_test_setup_teardown( test_finalize_without_init,
+                              reset_messenger,
+                              reset_messenger ),
+
+    // Message callback tests.
+    unit_test_setup_teardown( test_send_then_message_received_callback_is_called,
+                              reset_messenger,
+                              reset_messenger ),
+  };
+  return run_tests( tests );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */