trema 0.4.5 → 0.4.6

data/src/lib/openflow_message.c

@@ -1819,7 +1819,10 @@ validate_features_request( const buffer *message ) {
 
 static int
 validate_phy_port_no( const uint16_t port_no ) {
-  if ( ( port_no == 0 ) || ( ( port_no > OFPP_MAX ) && ( port_no < OFPP_IN_PORT ) ) ) {
+  if ( port_no == OFPP_LOCAL ) {
+    return 0;
+  }
+  if ( ( port_no == 0 ) || ( port_no > OFPP_MAX ) ) {
     return ERROR_INVALID_PORT_NO;
   }
 
@@ -1827,6 +1830,26 @@ validate_phy_port_no( const uint16_t port_no ) {
 }
 
 
+static int
+validate_in_port_no( const uint16_t port_no ) {
+  if ( ( port_no == OFPP_CONTROLLER ) || ( port_no == OFPP_NONE ) ) {
+     return 0;
+  }
+
+  return validate_phy_port_no( port_no );
+}
+
+
+static int
+validate_out_port_no( const uint16_t port_no ) {
+  if ( port_no >= OFPP_IN_PORT ) {
+    return 0;
+  }
+
+  return validate_phy_port_no( port_no );
+}
+
+
 static int
 validate_phy_port( struct ofp_phy_port *port ) {
   int ret;
@@ -1990,7 +2013,7 @@ validate_packet_in( const buffer *message ) {
   // packet_in->total_len
   // packet_in->in_port
 
-  ret = validate_phy_port_no( ntohs( packet_in->in_port ) );
+  ret = validate_in_port_no( ntohs( packet_in->in_port ) );
   if ( ret < 0 ) {
     return ret;
   }
@@ -2162,7 +2185,7 @@ validate_packet_out( const buffer *message ) {
 
   packet_out = ( struct ofp_packet_out * ) message->data;
 
-  ret = validate_phy_port_no( ntohs( packet_out->in_port ) );
+  ret = validate_in_port_no( ntohs( packet_out->in_port ) );
   if ( ret < 0 ) {
     return ret;
   }
@@ -2227,11 +2250,9 @@ validate_flow_mod( const buffer *message ) {
 
   if ( ( ntohs( flow_mod->command ) == OFPFC_DELETE )
        || ( ntohs( flow_mod->command ) == OFPFC_DELETE_STRICT ) ) {
-    if ( ntohs( flow_mod->out_port ) != OFPP_NONE ) {
-      ret = validate_phy_port_no( ntohs( flow_mod->out_port ) );
-      if ( ret < 0 ) {
-        return ret;
-      }
+    ret = validate_out_port_no( ntohs( flow_mod->out_port ) );
+    if ( ret < 0 ) {
+      return ret;
     }
   }
 
@@ -2357,7 +2378,7 @@ validate_flow_stats_request( const buffer *message ) {
 
   // flow_stats_request->table_id
 
-  ret = validate_phy_port_no( ntohs( flow_stats_request->out_port ) );
+  ret = validate_out_port_no( ntohs( flow_stats_request->out_port ) );
   if ( ret < 0 ) {
     return ret;
   }
@@ -2403,7 +2424,7 @@ validate_aggregate_stats_request( const buffer *message ) {
 
   // aggregate_stats_request->table_id
 
-  ret = validate_phy_port_no( ntohs( aggregate_stats_request->out_port ) );
+  ret = validate_out_port_no( ntohs( aggregate_stats_request->out_port ) );
   if ( ret < 0 ) {
     return ret;
   }
@@ -3217,7 +3238,7 @@ validate_action_output( const struct ofp_action_output *action ) {
     return ERROR_TOO_LONG_ACTION_OUTPUT;
   }
 
-  ret = validate_phy_port_no( output.port );
+  ret = validate_out_port_no( output.port );
   if ( ret < 0 ) {
     return ret;
   }

data/src/lib/trema.c

@@ -238,11 +238,11 @@ bool mock_init_timer();
 #define finalize_timer mock_finalize_timer
 bool mock_finalize_timer();
 
-#ifdef set_external_callback
-#undef set_external_callback
+#ifdef push_external_callback
+#undef push_external_callback
 #endif
-#define set_external_callback mock_set_external_callback
-bool mock_set_external_callback( void ( *callback )( void ) );
+#define push_external_callback mock_push_external_callback
+bool mock_push_external_callback( void ( *callback )( void ) );
 
 #ifdef dump_stats
 #undef dump_stats
@@ -506,12 +506,18 @@ ignore_sigpipe() {
 }
 
 
+static void
+set_do_stop_trema_as_external_callback() {
+  push_external_callback( stop_trema );
+}
+
+
 static void
 set_exit_handler() {
   struct sigaction signal_exit;
 
   memset( &signal_exit, 0, sizeof( struct sigaction ) );
-  signal_exit.sa_handler = ( void * ) stop_trema;
+  signal_exit.sa_handler = ( void * ) set_do_stop_trema_as_external_callback;
   sigaction( SIGINT, &signal_exit, NULL );
   sigaction( SIGTERM, &signal_exit, NULL );
 }
@@ -525,7 +531,7 @@ do_restart_log() {
 
 static void
 set_do_restart_log_as_external_callback() {
-  set_external_callback( do_restart_log );
+  push_external_callback( do_restart_log );
 }
 
 
@@ -541,7 +547,7 @@ set_hup_handler() {
 
 static void
 set_dump_stats_as_external_callback() {
-  set_external_callback( dump_stats );
+  push_external_callback( dump_stats );
 }
 
 

data/src/lib/trema.h

@@ -30,6 +30,7 @@
 #include "etherip.h"
 #include "event_forward_interface.h"
 #include "event_handler.h"
+#include "external_callback.h"
 #include "hash_table.h"
 #include "linked_list.h"
 #include "log.h"

data/src/lib/utility.c

@@ -68,8 +68,19 @@ hash_core( const void *key, int size ) {
   const uint32_t prime = 0x01000193UL;
   const unsigned char *c = key;
 
-  for ( int i = 0; i < size; i++ ) {
-    hash_value ^= ( unsigned char ) c[ i ];
+  uint32_t value = 0;
+  int i = 0;
+  for ( ; ( i + ( int ) sizeof( uint32_t ) ) <= size; i += ( int ) sizeof( uint32_t ) ) {
+    memcpy( &value, &c[ i ], sizeof( uint32_t ) );
+    hash_value ^= value;
+    hash_value *= prime;
+  }
+  if ( i < size ) {
+    for ( ; i < size; i++ ) {
+      value <<= 8;
+      value |= ( ( uint32_t ) c[ i ] & 0xff );
+    }
+    hash_value ^= value;
     hash_value *= prime;
   }
 

data/src/switch_manager/secure_channel_receiver.c

@@ -53,7 +53,12 @@ recv_from_secure_channel( struct switch_info *sw_info ) {
     if ( errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK ) {
       return 0;
     }
-    error( "Receive error:%s(%d)", strerror( errno ), errno );
+    if ( errno == ECONNRESET ) {
+      debug( "Connection reset by peer." );
+    }
+    else {
+      error( "Receive error: %s(%d)", strerror( errno ), errno );
+    }
     return -1;
   }
   if ( recv_length == 0 ) {

data/src/switch_manager/switch.c

@@ -526,6 +526,8 @@ confirm_self_dpid_is_registered( const list_element *switches, void *user_data )
   if ( found ) {
     sw_info->state = SWITCH_STATE_COMPLETED;
 
+    finalize_openflow_application_interface();
+
     // notify state and datapath_id to controllers
     service_send_state( sw_info, &sw_info->datapath_id, MESSENGER_OPENFLOW_READY );
     debug( "send ready state" );
@@ -540,31 +542,31 @@ confirm_self_dpid_is_registered( const list_element *switches, void *user_data )
 
 
 static void
-stop_switch( struct switch_info *sw_info ) {
-  if ( sw_info->secure_channel_fd >= 0 ) {
-    close( sw_info->secure_channel_fd );
-    sw_info->secure_channel_fd = -1;
+stop_switch() {
+  if ( switch_info.secure_channel_fd >= 0 ) {
+    close( switch_info.secure_channel_fd );
+    switch_info.secure_channel_fd = -1;
   }
   uint8_t state = MESSENGER_OPENFLOW_DISCONNECTED;
-  if ( sw_info->state == SWITCH_STATE_CONNECTION_FAILED ) {
+  if ( switch_info.state == SWITCH_STATE_CONNECTION_FAILED ) {
     state = MESSENGER_OPENFLOW_FAILD_TO_CONNECT;
   }
-  service_send_state( sw_info, &sw_info->datapath_id, state );
+  service_send_state( &switch_info, &switch_info.datapath_id, state );
   flush_messenger();
 
   // free service name list
-  iterate_list( sw_info->vendor_service_name_list, xfree_data, NULL );
-  delete_list( sw_info->vendor_service_name_list );
-  sw_info->vendor_service_name_list = NULL;
-  iterate_list( sw_info->packetin_service_name_list, xfree_data, NULL );
-  delete_list( sw_info->packetin_service_name_list );
-  sw_info->packetin_service_name_list = NULL;
-  iterate_list( sw_info->portstatus_service_name_list, xfree_data, NULL );
-  delete_list( sw_info->portstatus_service_name_list );
-  sw_info->portstatus_service_name_list = NULL;
-  iterate_list( sw_info->state_service_name_list, xfree_data, NULL );
-  delete_list( sw_info->state_service_name_list );
-  sw_info->state_service_name_list = NULL;
+  iterate_list( switch_info.vendor_service_name_list, xfree_data, NULL );
+  delete_list( switch_info.vendor_service_name_list );
+  switch_info.vendor_service_name_list = NULL;
+  iterate_list( switch_info.packetin_service_name_list, xfree_data, NULL );
+  delete_list( switch_info.packetin_service_name_list );
+  switch_info.packetin_service_name_list = NULL;
+  iterate_list( switch_info.portstatus_service_name_list, xfree_data, NULL );
+  delete_list( switch_info.portstatus_service_name_list );
+  switch_info.portstatus_service_name_list = NULL;
+  iterate_list( switch_info.state_service_name_list, xfree_data, NULL );
+  delete_list( switch_info.state_service_name_list );
+  switch_info.state_service_name_list = NULL;
 
   stop_trema();
 }
@@ -578,7 +580,7 @@ unregistration_timeout( void *user_data ) {
 
   warn( "Unregistration timeout ( datapath id %#" PRIx64 " ).", sw_info->datapath_id );
 
-  stop_switch( sw_info );
+  stop_switch();
 }
 
 
@@ -649,7 +651,7 @@ switch_event_disconnected( struct switch_info *sw_info ) {
   }
   else {
     error( "Failed to send switch list request to switch manager." );
-    stop_switch( sw_info );
+    stop_switch();
   }
 
   return 0;
@@ -661,7 +663,7 @@ unregistration_retry( void *user_data ) {
   struct switch_info *sw_info = user_data;
 
   if ( sw_info->retry_count == 0 ) {
-    stop_switch( sw_info );
+    stop_switch();
     return;
   }
   sw_info->retry_count--;
@@ -673,7 +675,7 @@ unregistration_retry( void *user_data ) {
   }
   else {
     error( "Failed to send switch list request to switch manager." );
-    stop_switch( sw_info );
+    stop_switch();
   }
 }
 
@@ -700,7 +702,8 @@ confirm_self_dpid_is_unregistered( const list_element *switches, void *user_data
   }
   else {
     // The switch has been deleted from the switch list
-    stop_switch( sw_info );
+    finalize_openflow_application_interface();
+    push_external_callback( stop_switch );
   }
 }
 
@@ -881,9 +884,7 @@ static void
 handle_sigterm( int signum ) {
   UNUSED( signum );
 
-  if ( !set_external_callback( stop_switch_daemon ) ) {
-    stop_trema();
-  }
+  push_external_callback( stop_switch_daemon );
 }
 
 

data/src/switch_manager/switch_manager.c

@@ -36,6 +36,9 @@
 #include "event_forward_entry_manipulation.h"
 
 
+#define DEFAULT_TCP_PORT 6653
+
+
 #ifdef UNIT_TESTING
 #define static
 
@@ -133,11 +136,11 @@ void mock_start_trema( void );
 #define get_executable_name mock_get_executable_name
 const char *mock_get_executable_name( void );
 
-#ifdef set_external_callback
-#undef set_external_callback
+#ifdef push_external_callback
+#undef push_external_callback
 #endif
-#define set_external_callback mock_set_external_callback
-void mock_set_external_callback( void ( *callback )( void ) );
+#define push_external_callback mock_push_external_callback
+void mock_push_external_callback( void ( *callback )( void ) );
 
 #endif // UNIT_TESTING
 
@@ -168,7 +171,7 @@ usage() {
     "  -g, --syslog                    output log messages to syslog\n"
     "  -f, --logging_facility=FACILITY set syslog facility\n"
     "  -h, --help                      display this help and exit\n"
-    , get_executable_name(), OFP_TCP_PORT
+    , get_executable_name(), DEFAULT_TCP_PORT
   );
 }
 
@@ -203,8 +206,8 @@ handle_sigchld( int signum ) {
   UNUSED( signum );
 
   // because wait_child() is not signal safe, we call it later.
-  if ( set_external_callback != NULL ) {
-    set_external_callback( wait_child );
+  if ( push_external_callback != NULL ) {
+    push_external_callback( wait_child );
   }
 }
 
@@ -254,7 +257,7 @@ static void
 init_listener_info( struct listener_info *listener_info ) {
   memset( listener_info, 0, sizeof( struct listener_info ) );
   listener_info->switch_daemon = xconcatenate_path( get_trema_home(), SWITCH_MANAGER_PATH );
-  listener_info->listen_port = OFP_TCP_PORT;
+  listener_info->listen_port = DEFAULT_TCP_PORT;
   listener_info->listen_fd = -1;
   create_list( &listener_info->vendor_service_name_list );
   create_list( &listener_info->packetin_service_name_list );
@@ -555,7 +558,20 @@ start_switch_management( void ) {
 
 static void
 stop_switch_management( void ) {
-  // do something here.
+  if ( listener_info.listen_fd > -1 ) {
+    set_readable( listener_info.listen_fd, false );
+    delete_fd_handler( listener_info.listen_fd );
+    listener_info.listen_fd = -1;
+  }
+  stop_trema();
+}
+
+
+static void
+handle_sigterm( int signum ) {
+  UNUSED( signum );
+
+  push_external_callback( stop_switch_management );
 }
 
 
@@ -591,6 +607,12 @@ main( int argc, char *argv[] ) {
   // free returned buffer of get_current_dir_name()
   free( startup_dir );
 
+  struct sigaction signal_exit;
+  memset( &signal_exit, 0, sizeof( struct sigaction ) );
+  signal_exit.sa_handler = handle_sigterm;
+  sigaction( SIGINT, &signal_exit, NULL );
+  sigaction( SIGTERM, &signal_exit, NULL );
+
   catch_sigchild();
 
   // listener start (listen socket binding and listen)
@@ -606,7 +628,6 @@ main( int argc, char *argv[] ) {
   start_trema();
 
   finalize_listener_info( &listener_info );
-  stop_switch_management();
   stop_service_management();
   finalize_dpid_table();
 

data/src/tremashark/packet_capture.c

@@ -27,6 +27,7 @@
 #include <pthread.h>
 #include <string.h>
 #include <time.h>
+#include "external_callback.h"
 #include "pcap_private.h"
 #include "queue.h"
 #include "trema.h"
@@ -303,8 +304,8 @@ static void
 start_packet_capture( void ) {
   set_timer_event();
 
-  if ( set_external_callback != NULL ) {
-    set_external_callback( start_capture );
+  if ( push_external_callback != NULL ) {
+    push_external_callback( start_capture );
   }
 }
 

data/src/tremashark/tremashark.c

@@ -350,8 +350,8 @@ write_circular_buffer( void ) {
 
 static void
 set_write_circular_buffer( void ) {
-  if ( set_external_callback != NULL ) {
-    set_external_callback( write_circular_buffer );
+  if ( push_external_callback != NULL ) {
+    push_external_callback( write_circular_buffer );
   }
 }
 

data/trema.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do | gem |
   gem.add_dependency "bundler"
   gem.add_dependency "gli", "~> 2.8.1"
   gem.add_dependency "paper_house", "~> 0.5.0"
-  gem.add_dependency "pio", "~> 0.2.6"
+  gem.add_dependency "pio", "~> 0.3.0"
   gem.add_dependency "rake", "~> 10.1.0"
   gem.add_dependency "rdoc", "~> 4.0.1"
 end

data/unittests/lib/external_callback_test.c

@@ -0,0 +1,282 @@
+/*
+ * Unit tests for external_callback.
+ *
+ * Copyright (C) 2013 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 <limits.h>
+#include <stdio.h>
+#include <string.h>
+#include "checks.h"
+#include "cmockery_trema.h"
+#include "external_callback.h"
+#include "utility.h"
+
+typedef struct {
+  external_callback_t *buffer;
+  unsigned int size;
+  unsigned int write_position;
+  unsigned int read_position;
+} ring_buffer;
+
+#define MAX_EXTERNAL_CALLBACK 16
+extern ring_buffer *external_callbacks;
+
+
+/********************************************************************************
+ * Mock functions.
+ ********************************************************************************/
+
+static ring_buffer ring_buffer0;
+static external_callback_t buffer0[ MAX_EXTERNAL_CALLBACK ];
+
+void *
+mock_xcalloc( size_t nmemb, size_t size ) {
+  check_expected( nmemb );
+  check_expected( size );
+  return ( void * ) ( intptr_t ) mock();
+}
+
+
+void
+mock_xfree( void *ptr ) {
+  check_expected( ptr );
+}
+
+
+void
+mock_debug( const char *format, ... ) {
+  UNUSED( format );
+}
+
+
+static void
+reset() {
+  external_callbacks = NULL;
+}
+
+
+static void
+setup() {
+  memset( &ring_buffer0, 0, sizeof( ring_buffer0 ) );
+  memset( buffer0, 0, sizeof( buffer0 ) );
+  external_callbacks = &ring_buffer0;
+  external_callbacks->buffer = buffer0;
+  external_callbacks->size = MAX_EXTERNAL_CALLBACK;
+  external_callbacks->write_position = 0;
+  external_callbacks->read_position = 0;
+}
+
+
+static void
+teardown() {
+  external_callbacks = NULL;
+}
+
+
+/********************************************************************************
+ * Tests.
+ ********************************************************************************/
+
+static void
+test_init_external_callback() {
+  expect_value( mock_xcalloc, nmemb, 1 );
+  expect_value( mock_xcalloc, size, sizeof( ring_buffer ) );
+  memset( &ring_buffer0, 0, sizeof( ring_buffer0 ) );
+  will_return( mock_xcalloc, &ring_buffer0 );
+  expect_value( mock_xcalloc, nmemb, MAX_EXTERNAL_CALLBACK );
+  expect_value( mock_xcalloc, size, sizeof( external_callback_t ) );
+  memset( buffer0, 0, sizeof( buffer0 ) );
+  will_return( mock_xcalloc, buffer0 );
+
+  init_external_callback();
+
+  assert_true( external_callbacks == &ring_buffer0 );
+  assert_true( external_callbacks->buffer == buffer0 );
+  assert_true( external_callbacks->size == MAX_EXTERNAL_CALLBACK );
+  assert_true( external_callbacks->write_position == 0 );
+  assert_true( external_callbacks->read_position == 0 );
+}
+
+
+static void
+test_init_external_callback_fails_if_already_initialized() {
+  expect_assert_failure( init_external_callback() );
+}
+
+
+static void
+test_finalize_external_callback() {
+  expect_value( mock_xfree, ptr, buffer0 );
+  expect_value( mock_xfree, ptr, &ring_buffer0 );
+
+  finalize_external_callback();
+
+  assert_true( external_callbacks == NULL );
+}
+
+
+static void
+test_finalize_external_callback_fails_if_not_initialized() {
+  expect_assert_failure( finalize_external_callback() );
+}
+
+
+static void
+test_finalize_external_callback_fails_if_already_finalized() {
+  expect_value( mock_xfree, ptr, buffer0 );
+  expect_value( mock_xfree, ptr, &ring_buffer0 );
+  finalize_external_callback();
+
+  expect_assert_failure( finalize_external_callback() );
+}
+
+
+static void
+external_callback_helper() {
+  mock();
+}
+
+
+static void
+test_push_external_callback() {
+  push_external_callback( external_callback_helper );
+
+  assert_true( external_callbacks->write_position == 1 );
+  assert_true( external_callbacks->read_position == 0 );
+  assert_true( external_callbacks->buffer[ 0 ] == external_callback_helper );
+  for ( int i = 1; i < MAX_EXTERNAL_CALLBACK; i++ ) {
+    assert_true( external_callbacks->buffer[ i ] == NULL );
+  }
+}
+
+
+static void
+test_push_external_callback_fails_if_callback_is_NULL() {
+  assert_true( push_external_callback( NULL ) == false );
+}
+
+
+static void
+test_push_external_callback_fails_if_not_initialized() {
+  assert_true( push_external_callback( external_callback_helper ) == false );
+}
+
+
+static void
+test_push_external_callback_succeeds_with_multiple_callbacks() {
+  external_callbacks->write_position = 5;
+  external_callbacks->read_position = 5;
+
+  for ( int i = 0; i < MAX_EXTERNAL_CALLBACK; i++ ) {
+    push_external_callback( external_callback_helper );
+  }
+
+  assert_true( external_callbacks->write_position == 5 + MAX_EXTERNAL_CALLBACK );
+  assert_true( external_callbacks->read_position == 5 );
+  for ( int i = 0; i < MAX_EXTERNAL_CALLBACK; i++ ) {
+    assert_true( external_callbacks->buffer[ i ] == external_callback_helper );
+  }
+}
+
+
+static void
+test_push_external_callback_fails_if_buffer_overflows() {
+  external_callbacks->write_position = 3;
+  external_callbacks->read_position = 3;
+
+  for ( int i = 0; i < MAX_EXTERNAL_CALLBACK; i++ ) {
+    push_external_callback( external_callback_helper );
+  }
+  expect_assert_failure( push_external_callback( external_callback_helper ) );
+}
+
+
+static void
+test_run_external_callback() {
+  external_callbacks->write_position = UINT_MAX;
+  external_callbacks->read_position = UINT_MAX;
+  push_external_callback( external_callback_helper );
+  assert_true( external_callbacks->write_position == UINT_MAX + 1 );
+  assert_true( external_callbacks->read_position == UINT_MAX );
+  will_return( external_callback_helper, 0 );
+
+  run_external_callback();
+
+  assert_true( external_callbacks->write_position == UINT_MAX + 1 );
+  assert_true( external_callbacks->read_position == UINT_MAX + 1 );
+  for ( int i = 0; i < MAX_EXTERNAL_CALLBACK; i++ ) {
+    assert_true( external_callbacks->buffer[ i ] == NULL );
+  }
+}
+
+
+static void
+test_run_external_callback_succeeds_with_multiple_callbacks() {
+  external_callbacks->write_position = UINT_MAX;
+  external_callbacks->read_position = UINT_MAX;
+  for ( int i = 0; i < MAX_EXTERNAL_CALLBACK; i++ ) {
+    push_external_callback( external_callback_helper );
+  }
+  assert_true( external_callbacks->write_position == UINT_MAX + MAX_EXTERNAL_CALLBACK );
+  assert_true( external_callbacks->read_position == UINT_MAX );
+  will_return_count( external_callback_helper, 0, MAX_EXTERNAL_CALLBACK );
+
+  run_external_callback();
+
+  assert_true( external_callbacks->write_position == UINT_MAX + MAX_EXTERNAL_CALLBACK );
+  assert_true( external_callbacks->read_position == UINT_MAX + MAX_EXTERNAL_CALLBACK );
+  for ( int i = 0; i < MAX_EXTERNAL_CALLBACK; i++ ) {
+    assert_true( external_callbacks->buffer[ i ] == NULL );
+  }
+}
+
+/********************************************************************************
+ * Run tests.
+ ********************************************************************************/
+
+int
+main() {
+  const UnitTest tests[] = {
+    unit_test_setup_teardown( test_init_external_callback, reset, teardown ),
+    unit_test_setup_teardown( test_init_external_callback_fails_if_already_initialized, setup, teardown ),
+
+    unit_test_setup_teardown( test_finalize_external_callback, setup, teardown ),
+    unit_test_setup_teardown( test_finalize_external_callback_fails_if_not_initialized, reset, teardown ),
+    unit_test_setup_teardown( test_finalize_external_callback_fails_if_already_finalized, setup, teardown ),
+
+    unit_test_setup_teardown( test_push_external_callback, setup, teardown ),
+    unit_test_setup_teardown( test_push_external_callback_fails_if_callback_is_NULL, setup, teardown ),
+    unit_test_setup_teardown( test_push_external_callback_fails_if_not_initialized, reset, teardown ),
+
+    unit_test_setup_teardown( test_push_external_callback_succeeds_with_multiple_callbacks, setup, teardown ),
+    unit_test_setup_teardown( test_push_external_callback_fails_if_buffer_overflows, setup, teardown ),
+
+    unit_test_setup_teardown( test_run_external_callback, setup, teardown ),
+    unit_test_setup_teardown( test_run_external_callback_succeeds_with_multiple_callbacks, setup, teardown ),
+  };
+
+  return run_tests( tests );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */