trema 0.1.3

data/unittests/lib/openflow_application_interface_test.c

@@ -0,0 +1,3488 @@
+/*
+ * Unit tests for OpenFlow Application Interface.
+ *
+ * Author: Yasunobu Chiba
+ *
+ * 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 <openflow.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "bool.h"
+#include "checks.h"
+#include "cmockery_trema.h"
+#include "hash_table.h"
+#include "linked_list.h"
+#include "log.h"
+#include "messenger.h"
+#include "openflow_application_interface.h"
+#include "openflow_message.h"
+#include "stat.h"
+#include "wrapper.h"
+
+
+/********************************************************************************
+ * Helpers.
+ ********************************************************************************/
+
+typedef struct {
+  char key[ STAT_KEY_LENGTH ];
+  uint64_t value;
+} stat_entry;
+
+
+extern bool openflow_application_interface_initialized;
+extern openflow_event_handlers_t event_handlers;
+extern char service_name[ MESSENGER_SERVICE_NAME_LENGTH ];
+extern hash_table *stats;
+
+extern void assert_if_not_initialized();
+extern void handle_error( const uint64_t datapath_id, buffer *data );
+extern void handle_vendor( const uint64_t datapath_id, buffer *data );
+extern void handle_features_reply( const uint64_t datapath_id, buffer *data );
+extern void handle_get_config_reply( const uint64_t datapath_id, buffer *data );
+extern void handle_packet_in( const uint64_t datapath_id, buffer *data );
+extern void handle_flow_removed( const uint64_t datapath_id, buffer *data );
+extern void handle_port_status( const uint64_t datapath_id, buffer *data );
+extern void handle_stats_reply( const uint64_t datapath_id, buffer *data );
+extern void handle_barrier_reply( const uint64_t datapath_id, buffer *data );
+extern void handle_queue_get_config_reply( const uint64_t datapath_id, buffer *data );
+extern void dump_buf( const buffer *data );
+extern void handle_switch_events( uint16_t type, void *data, size_t length );
+extern void handle_openflow_message( void *data, size_t length );
+extern void handle_message( uint16_t type, void *data, size_t length );
+extern void insert_dpid( list_element **head, uint64_t *dpid );
+extern void handle_list_switches_reply( uint16_t message_type, void *data, size_t length, void *user_data );
+
+
+#define SWITCH_READY_HANDLER ( ( void * ) 0x00020001 )
+#define SWITCH_READY_USER_DATA ( ( void * ) 0x00020011 )
+#define SWITCH_DISCONNECTED_HANDLER ( ( void * ) 0x00020002 )
+#define SWITCH_DISCONNECTED_USER_DATA ( ( void * ) 0x00020021 )
+#define ERROR_HANDLER ( ( void * ) 0x00010001 )
+#define ERROR_USER_DATA ( ( void * ) 0x00010011 )
+#define VENDOR_HANDLER ( ( void * ) 0x00010002 )
+#define VENDOR_USER_DATA ( ( void * ) 0x00010021 )
+#define FEATURES_REPLY_HANDLER ( ( void * ) 0x00010003 )
+#define FEATURES_REPLY_USER_DATA ( ( void * ) 0x00010031 )
+#define GET_CONFIG_REPLY_HANDLER ( ( void * ) 0x00010004 )
+#define GET_CONFIG_REPLY_USER_DATA ( ( void * ) 0x00010041 )
+#define PACKET_IN_HANDLER ( ( void * ) 0x00010005 )
+#define PACKET_IN_USER_DATA ( ( void * ) 0x00010051 )
+#define FLOW_REMOVED_HANDLER ( ( void * ) 0x00010006 )
+#define FLOW_REMOVED_USER_DATA ( ( void * ) 0x00010061 )
+#define PORT_STATUS_HANDLER ( ( void * ) 0x00010007 )
+#define PORT_STATUS_USER_DATA ( ( void * ) 0x00010071 )
+#define STATS_REPLY_HANDLER ( ( void * ) 0x00010008 )
+#define STATS_REPLY_USER_DATA ( ( void * ) 0x00010081 )
+#define BARRIER_REPLY_HANDLER ( ( void * ) 0x00010009 )
+#define BARRIER_REPLY_USER_DATA ( ( void * ) 0x00010091 )
+#define QUEUE_GET_CONFIG_REPLY_HANDLER ( ( void * ) 0x0001000a )
+#define QUEUE_GET_CONFIG_REPLY_USER_DATA ( ( void * ) 0x000100a1 )
+#define LIST_SWITCHES_REPLY_HANDLER ( ( void * ) 0x0001000b )
+#define LIST_SWITCHES_REPLY_USER_DATA ( ( void * ) 0x000100b1 )
+
+static const pid_t PID = 12345;
+static char SERVICE_NAME[] = "learning switch application 0";
+static openflow_event_handlers_t NULL_EVENT_HANDLERS = { false, ( void * ) 0, ( void * ) 0,
+                                                         ( void * ) 0, ( void * ) 0,
+                                                         ( void * ) 0, ( void * ) 0,
+                                                         ( void * ) 0, ( void * ) 0,
+                                                         ( void * ) 0, ( void * ) 0,
+                                                         ( void * ) 0, ( void * ) 0,
+                                                         false, ( void * ) 0, ( void * ) 0,
+                                                         false, ( void * ) 0, ( void * ) 0,
+                                                         ( void * ) 0, ( void * ) 0,
+                                                         ( void * ) 0, ( void * ) 0,
+                                                         ( void * ) 0, ( void * ) 0,
+                                                         ( void * ) 0, ( void * ) 0,
+                                                         ( void * ) 0 };
+static openflow_event_handlers_t EVENT_HANDLERS = {
+  false, SWITCH_READY_HANDLER, SWITCH_READY_USER_DATA,
+  SWITCH_DISCONNECTED_HANDLER, SWITCH_DISCONNECTED_USER_DATA,
+  ERROR_HANDLER, ERROR_USER_DATA,
+  VENDOR_HANDLER, VENDOR_USER_DATA,
+  FEATURES_REPLY_HANDLER, FEATURES_REPLY_USER_DATA,
+  GET_CONFIG_REPLY_HANDLER, GET_CONFIG_REPLY_USER_DATA,
+  false, PACKET_IN_HANDLER, PACKET_IN_USER_DATA,
+  false, FLOW_REMOVED_HANDLER, FLOW_REMOVED_USER_DATA,
+  PORT_STATUS_HANDLER, PORT_STATUS_USER_DATA,
+  STATS_REPLY_HANDLER, STATS_REPLY_USER_DATA,
+  BARRIER_REPLY_HANDLER, BARRIER_REPLY_USER_DATA,
+  QUEUE_GET_CONFIG_REPLY_HANDLER, QUEUE_GET_CONFIG_REPLY_USER_DATA,
+  LIST_SWITCHES_REPLY_HANDLER
+};
+static uint64_t DATAPATH_ID = 0x0102030405060708ULL;
+static char REMOTE_SERVICE_NAME[] = "switch.0x102030405060708";
+static const uint32_t TRANSACTION_ID = 0x04030201;
+static const uint32_t VENDOR_ID = 0xccddeeff;
+static const uint8_t MAC_ADDR_X[ OFP_ETH_ALEN ] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x07 };
+static const uint8_t MAC_ADDR_Y[ OFP_ETH_ALEN ] = { 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d };
+static const char *PORT_NAME = "port 1";
+static const uint32_t PORT_FEATURES = ( OFPPF_10MB_HD | OFPPF_10MB_FD | OFPPF_100MB_HD |
+                                        OFPPF_100MB_FD | OFPPF_1GB_HD | OFPPF_1GB_FD |
+                                        OFPPF_COPPER |  OFPPF_AUTONEG | OFPPF_PAUSE );
+static struct ofp_match MATCH = { OFPFW_ALL, 1,
+                                  { 0x01, 0x02, 0x03, 0x04, 0x05, 0x07 },
+                                  { 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d },
+                                  1, 1, { 0 }, 0x800, 0xfc, 0x6, { 0, 0 },
+                                  0x0a090807, 0x0a090807, 1024, 2048 };
+#define USER_DATA_LEN 64
+static uint8_t USER_DATA[ USER_DATA_LEN ];
+
+
+static bool packet_in_handler_called = false;
+
+
+/********************************************************************************
+ * Mocks.
+ ********************************************************************************/
+
+const char*
+mock_get_trema_name() {
+  return "TEST_SERVICE_NAME";
+}
+
+
+pid_t
+mock_getpid() {
+  return PID;
+}
+
+
+bool
+mock_init_openflow_message() {
+  return ( bool ) mock();
+}
+
+
+bool
+mock_add_message_received_callback( char *service_name,
+                                    void ( *callback )( uint16_t tag, void *data, size_t len ) ) {
+  check_expected( service_name );
+  check_expected( callback );
+
+  return ( bool ) mock();
+}
+
+
+bool
+mock_add_message_replied_callback( char *service_name,
+                                   void ( *callback )( uint16_t tag, void *data, size_t len, void *user_data ) ) {
+  check_expected( service_name );
+  check_expected( callback );
+
+  return ( bool ) mock();
+}
+
+
+bool
+mock_send_message( char *service_name, uint16_t tag, void *data, size_t len ) {
+  uint32_t tag32 = tag;
+
+  check_expected( service_name );
+  check_expected( tag32 );
+  check_expected( data );
+  check_expected( len );
+
+  return ( bool ) mock();
+}
+
+
+bool
+mock_send_request_message( char *to_service_name, char *from_service_name, uint16_t tag,
+                           void *data, size_t len, void *user_data ) {
+  uint32_t tag32 = tag;
+
+  check_expected( to_service_name );
+  check_expected( from_service_name );
+  check_expected( tag32 );
+  check_expected( data );
+  check_expected( len );
+  check_expected( user_data );
+
+  return ( bool ) mock();
+}
+
+
+bool
+mock_delete_message_received_callback( char *service_name,
+                                       void ( *callback )( uint16_t tag, void *data, size_t len ) ) {
+  check_expected( service_name );
+  check_expected( callback );
+
+  return ( bool ) mock();
+}
+
+
+bool
+mock_delete_message_replied_callback( char *service_name,
+                                      void ( *callback )( uint16_t tag, void *data, size_t len, void *user_data ) ) {
+  check_expected( service_name );
+  check_expected( callback );
+
+  return ( bool ) mock();
+}
+
+
+bool
+mock_parse_packet( buffer *buf ) {
+  calloc_packet_info( buf );
+  return ( bool ) mock();
+}
+
+
+static void
+mock_switch_disconnected_handler( uint64_t datapath_id, void *user_data ) {
+  check_expected( &datapath_id );
+  check_expected( user_data );
+}
+
+
+static void
+mock_error_handler( uint64_t datapath_id, uint32_t transaction_id, uint16_t type, uint16_t code,
+                    const buffer *data, void *user_data ) {
+  uint32_t type32 = type;
+  uint32_t code32 = code;
+
+  check_expected( &datapath_id );
+  check_expected( transaction_id );
+  check_expected( type32 );
+  check_expected( code32 );
+  check_expected( data->length );
+  check_expected( data->data );
+  check_expected( user_data );
+}
+
+
+static void
+mock_vendor_handler( uint64_t datapath_id, uint32_t transaction_id, uint32_t vendor,
+                     const buffer *data, void *user_data ){
+  void *data_uc;
+
+  check_expected( &datapath_id );
+  check_expected( transaction_id );
+  check_expected( vendor );
+  if( data != NULL ) {
+    check_expected( data->length );
+    check_expected( data->data );
+  }
+  else {
+    data_uc = ( void * ) ( unsigned long ) data;
+    check_expected( data_uc );
+  }
+  check_expected( user_data );
+}
+
+
+static void
+mock_features_reply_handler( uint64_t datapath_id, uint32_t transaction_id,
+                             uint32_t n_buffers, uint8_t n_tables, uint32_t capabilities,
+                             uint32_t actions, const list_element *phy_ports,
+                             void *user_data ) {
+  uint32_t n_tables32 = n_tables;
+
+  check_expected( &datapath_id );
+  check_expected( transaction_id );
+  check_expected( n_buffers );
+  check_expected( n_tables32 );
+  check_expected( capabilities );
+  check_expected( actions );
+  if ( phy_ports != NULL ) {
+    struct ofp_phy_port *port1 = phy_ports->data;
+    struct ofp_phy_port *port2 = phy_ports->next->data;
+    check_expected( port1 );
+    check_expected( port2 );
+  }
+  else {
+    void *phy_ports_uc = ( void * ) ( unsigned long ) phy_ports;
+    check_expected( phy_ports_uc );
+  }
+  check_expected( user_data );
+}
+
+
+static void
+mock_get_config_reply_handler( uint64_t datapath_id, uint32_t transaction_id,
+                               uint16_t flags, uint16_t miss_send_len, void *user_data ) {
+  uint32_t flags32 = flags;
+  uint32_t miss_send_len32 = miss_send_len;
+
+  check_expected( &datapath_id );
+  check_expected( transaction_id );
+  check_expected( flags32 );
+  check_expected( miss_send_len32 );
+  check_expected( user_data );
+}
+
+
+static void
+mock_flow_removed_handler( uint64_t datapath_id, uint32_t transaction_id, struct ofp_match match,
+                           uint64_t cookie, uint16_t priority, uint8_t reason, uint32_t duration_sec,
+                           uint32_t duration_nsec, uint16_t idle_timeout, uint64_t packet_count,
+                           uint64_t byte_count, void *user_data ) {
+  uint32_t priority32 = priority;
+  uint32_t reason32 = reason;
+  uint32_t idle_timeout32 = idle_timeout;
+
+  check_expected( &datapath_id );
+  check_expected( transaction_id );
+  check_expected( &match );
+  check_expected( &cookie );
+  check_expected( priority32 );
+  check_expected( reason32 );
+  check_expected( duration_sec );
+  check_expected( duration_nsec );
+  check_expected( idle_timeout32 );
+  check_expected( &packet_count );
+  check_expected( &byte_count );
+  check_expected( user_data );
+}
+
+
+static void
+mock_port_status_handler( uint64_t datapath_id, uint32_t transaction_id, uint8_t reason,
+                          struct ofp_phy_port phy_port, void *user_data ) {
+  uint32_t reason32 = reason;
+
+  check_expected( &datapath_id );
+  check_expected( transaction_id );
+  check_expected( reason32 );
+  check_expected( &phy_port );
+  check_expected( user_data );
+}
+
+
+static void
+mock_stats_reply_handler( uint64_t datapath_id, uint32_t transaction_id, uint16_t type,
+                          uint16_t flags, const buffer *data, void *user_data ) {
+  uint32_t type32 = type;
+  uint32_t flags32 = flags;
+
+  check_expected( &datapath_id );
+  check_expected( transaction_id );
+  check_expected( type32 );
+  check_expected( flags32 );
+  check_expected( data->length );
+  check_expected( data->data );
+  check_expected( user_data );
+}
+
+
+static void
+mock_barrier_reply_handler( uint64_t datapath_id, uint32_t transaction_id, void *user_data ) {
+  check_expected( &datapath_id );
+  check_expected( transaction_id );
+  check_expected( user_data );
+}
+
+
+static void
+mock_queue_get_config_reply_handler( uint64_t datapath_id, uint32_t transaction_id,
+                                     uint16_t port, const list_element *queues, void *user_data ) {
+  uint32_t port32 = port;
+  struct ofp_packet_queue *queue1, *queue2;
+
+  queue1 = queues->data;
+  queue2 = queues->next->data;
+
+  check_expected( &datapath_id );
+  check_expected( transaction_id );
+  check_expected( port32 );
+  check_expected( queue1 );
+  check_expected( queue2 );
+  check_expected( user_data );
+}
+
+
+static void
+mock_handle_list_switches_reply( const list_element *switches, void *user_data ) {
+  uint64_t *dpid1, *dpid2, *dpid3;
+
+  if ( switches != NULL ) {
+    dpid1 = switches->data;
+    check_expected( *dpid1 );
+    if ( switches->next != NULL ) {
+      dpid2 = switches->next->data;
+      check_expected( *dpid2 );
+      if ( switches->next->next != NULL ) {
+        dpid3 = switches->next->next->data;
+        check_expected( *dpid3 );
+      }
+    }
+  }
+  check_expected( user_data );
+}
+
+
+void
+mock_die( char *format, ... ) {
+  check_expected( format );
+  mock_assert( false, "die", __FILE__, __LINE__ );
+}
+
+
+void
+mock_debug( char *format, ... ) {
+  UNUSED( format );
+}
+
+
+void
+mock_info( char *format, ... ) {
+  UNUSED( format );
+}
+
+
+void
+mock_warn( char *format, ... ) {
+  UNUSED( format );
+}
+
+
+void
+mock_error( char *format, ... ) {
+  UNUSED( format );
+}
+
+
+void
+mock_critical( char *format, ... ) {
+  UNUSED( format );
+}
+
+
+static logging_level
+mock_get_logging_level() {
+  return LOG_DEBUG;
+}
+
+
+/********************************************************************************
+ * Setup and teardown function.
+ ********************************************************************************/
+
+static void
+cleanup() {
+  openflow_application_interface_initialized = false;
+  packet_in_handler_called = false;
+
+  memset( service_name, 0, sizeof( service_name ) );
+  memset( &event_handlers, 0, sizeof( event_handlers ) );
+  memset( USER_DATA, 'Z', sizeof( USER_DATA ) );
+  if ( stats != NULL ) {
+    delete_hash( stats );
+    stats = NULL;
+  }
+}
+
+
+static void
+init() {
+  bool ret;
+
+  get_logging_level = mock_get_logging_level;
+
+  cleanup();
+
+  will_return( mock_init_openflow_message, true );
+
+  expect_string( mock_add_message_received_callback, service_name, SERVICE_NAME );
+  expect_value( mock_add_message_received_callback, callback, handle_message );
+  will_return( mock_add_message_received_callback, true );
+
+  expect_string( mock_add_message_replied_callback, service_name, SERVICE_NAME );
+  expect_value( mock_add_message_replied_callback, callback, handle_list_switches_reply );
+  will_return( mock_add_message_replied_callback, true );
+
+  init_stat();
+
+  ret = init_openflow_application_interface( SERVICE_NAME );
+
+  assert_true( ret );
+  assert_true( openflow_application_interface_initialized );
+  assert_string_equal( service_name, SERVICE_NAME );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * init_openflow_application_interface() tests.
+ ********************************************************************************/
+
+static void
+test_init_openflow_application_interface_with_valid_custom_service_name() {
+  bool ret;
+
+  will_return( mock_init_openflow_message, true );
+
+  expect_string( mock_add_message_received_callback, service_name, SERVICE_NAME );
+  expect_value( mock_add_message_received_callback, callback, handle_message );
+  will_return( mock_add_message_received_callback, true );
+
+  expect_string( mock_add_message_replied_callback, service_name, SERVICE_NAME );
+  expect_value( mock_add_message_replied_callback, callback, handle_list_switches_reply );
+  will_return( mock_add_message_replied_callback, true );
+
+  ret = init_openflow_application_interface( SERVICE_NAME );
+
+  assert_true( ret );
+  assert_true( openflow_application_interface_initialized );
+  assert_string_equal( service_name, SERVICE_NAME );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+static void
+test_init_openflow_application_interface_with_too_long_custom_service_name() {
+  bool ret;
+  char too_long_service_name[ MESSENGER_SERVICE_NAME_LENGTH + 1 ];
+  char expected_service_name[ MESSENGER_SERVICE_NAME_LENGTH ];
+
+  memset( too_long_service_name, 'a', sizeof( too_long_service_name ) );
+  too_long_service_name[ MESSENGER_SERVICE_NAME_LENGTH ] = '\0';
+
+  memset( expected_service_name, '\0', sizeof( expected_service_name ) );
+
+  ret = init_openflow_application_interface( too_long_service_name );
+
+  assert_true( ret == false );
+  assert_true( openflow_application_interface_initialized == false );
+  assert_string_equal( service_name, expected_service_name );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+static void
+test_init_openflow_application_interface_if_already_initialized() {
+  bool ret;
+
+  ret = set_openflow_event_handlers( EVENT_HANDLERS );
+
+  assert_true( ret );
+  assert_memory_equal( &event_handlers, &EVENT_HANDLERS, sizeof( event_handlers ) );
+
+  ret = init_openflow_application_interface( SERVICE_NAME );
+
+  assert_true( ret == false );
+  assert_true( openflow_application_interface_initialized == true );
+  assert_string_equal( service_name, SERVICE_NAME );
+  assert_memory_equal( &event_handlers, &EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * init_openflow_application_interface() tests.
+ ********************************************************************************/
+
+static void
+test_finalize_openflow_application_interface() {
+  bool ret;
+  char expected_service_name[ MESSENGER_SERVICE_NAME_LENGTH ];
+
+  memset( expected_service_name, '\0', sizeof( expected_service_name ) );
+
+  expect_string( mock_delete_message_received_callback, service_name, SERVICE_NAME );
+  expect_value( mock_delete_message_received_callback, callback, handle_message );
+  will_return( mock_delete_message_received_callback, true );
+
+  expect_string( mock_delete_message_replied_callback, service_name, SERVICE_NAME );
+  expect_value( mock_delete_message_replied_callback, callback, handle_list_switches_reply );
+  will_return( mock_delete_message_replied_callback, true );
+
+  ret = finalize_openflow_application_interface();
+
+  assert_true( ret );
+  assert_true( openflow_application_interface_initialized == false );
+  assert_string_equal( service_name, expected_service_name );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+static void
+test_finalize_openflow_application_interface_if_not_initialized() {
+  char expected_service_name[ MESSENGER_SERVICE_NAME_LENGTH ];
+
+  memset( expected_service_name, '\0', sizeof( expected_service_name ) );
+
+  expect_assert_failure( finalize_openflow_application_interface() );
+
+  assert_true( openflow_application_interface_initialized == false );
+  assert_string_equal( service_name, expected_service_name );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * set_openflow_event_handlers() tests.
+ ********************************************************************************/
+
+static void
+test_set_openflow_event_handlers() {
+  bool ret;
+
+  ret = set_openflow_event_handlers( EVENT_HANDLERS );
+
+  assert_true( ret );
+  assert_memory_equal( &event_handlers, &EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * Switch ready handler tests.
+ ********************************************************************************/
+
+static void
+mock_switch_ready_handler( uint64_t datapath_id, void *user_data ) {
+  check_expected( &datapath_id );
+  check_expected( user_data );
+}
+
+
+static void
+mock_simple_switch_ready_handler( switch_ready event ) {
+  uint64_t datapath_id = event.datapath_id;
+  void *user_data = event.user_data;
+
+  check_expected( &datapath_id );
+  check_expected( user_data );
+}
+
+
+static void
+test_set_switch_ready_handler() {
+  char user_data[] = "Ready!";
+  set_switch_ready_handler( mock_switch_ready_handler, user_data );
+  assert_true( event_handlers.switch_ready_callback == mock_switch_ready_handler );
+  assert_string_equal( event_handlers.switch_ready_user_data, user_data );
+}
+
+
+static void
+test_set_simple_switch_ready_handler() {
+  char user_data[] = "Ready!";
+  set_switch_ready_handler( mock_simple_switch_ready_handler, user_data );
+  assert_true( event_handlers.switch_ready_callback == mock_simple_switch_ready_handler );
+  assert_string_equal( event_handlers.switch_ready_user_data, user_data );
+}
+
+
+static void
+test_set_switch_ready_handler_should_die_if_handler_is_NULL() {
+  char user_data[] = "Ready!";
+  expect_string( mock_die, format, "Invalid callback function for switch_ready event." );
+  expect_assert_failure( set_switch_ready_handler( NULL, user_data ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+static void
+test_handle_switch_ready() {
+  char user_data[] = "Ready!";
+  buffer *data = alloc_buffer_with_length( sizeof( openflow_service_header_t ) );
+  uint64_t *datapath_id = append_back_buffer( data, sizeof( openflow_service_header_t ) );
+  *datapath_id = htonll( DATAPATH_ID );
+
+  expect_memory( mock_switch_ready_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_string( mock_switch_ready_handler, user_data, user_data );
+
+  set_switch_ready_handler( mock_switch_ready_handler, user_data );
+  handle_message( MESSENGER_OPENFLOW_READY, data->data, data->length );
+
+  stat_entry *stat = lookup_hash_entry( stats, "openflow_application_interface.switch_ready_receive_succeeded" );
+  assert_int_equal( ( int ) stat->value, 1 );
+
+  free_buffer( data );
+  xfree( delete_hash_entry( stats, "openflow_application_interface.switch_ready_receive_succeeded" ) );
+}
+
+
+static void
+test_handle_switch_ready_with_simple_handler() {
+  char user_data[] = "Ready!";
+  buffer *data = alloc_buffer_with_length( sizeof( openflow_service_header_t ) );
+  uint64_t *datapath_id = append_back_buffer( data, sizeof( openflow_service_header_t ) );
+  *datapath_id = htonll( DATAPATH_ID );
+
+  expect_memory( mock_simple_switch_ready_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_string( mock_simple_switch_ready_handler, user_data, user_data );
+
+  set_switch_ready_handler( mock_simple_switch_ready_handler, user_data );
+  handle_message( MESSENGER_OPENFLOW_READY, data->data, data->length );
+
+  stat_entry *stat = lookup_hash_entry( stats, "openflow_application_interface.switch_ready_receive_succeeded" );
+  assert_int_equal( ( int ) stat->value, 1 );
+
+  free_buffer( data );
+  xfree( delete_hash_entry( stats, "openflow_application_interface.switch_ready_receive_succeeded" ) );
+}
+
+
+/********************************************************************************
+ * set_switch_disconnected_handler() tests.
+ ********************************************************************************/
+
+static void
+test_set_switch_disconnected_handler() {
+  assert_true( set_switch_disconnected_handler( SWITCH_DISCONNECTED_HANDLER, SWITCH_DISCONNECTED_USER_DATA ) );
+  assert_int_equal( event_handlers.switch_disconnected_callback, SWITCH_DISCONNECTED_HANDLER );
+  assert_int_equal( event_handlers.switch_disconnected_user_data, SWITCH_DISCONNECTED_USER_DATA );
+}
+
+
+static void
+test_set_switch_disconnected_handler_if_handler_is_NULL() {
+  expect_string( mock_die, format, "Callback function ( switch_disconnected_handler ) must not be NULL." );
+  expect_assert_failure( set_switch_disconnected_handler( NULL, NULL ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * set_error_handler() tests.
+ ********************************************************************************/
+
+static void
+test_set_error_handler() {
+  assert_true( set_error_handler( ERROR_HANDLER, ERROR_USER_DATA ) );
+  assert_int_equal( event_handlers.error_callback, ERROR_HANDLER );
+  assert_int_equal( event_handlers.error_user_data, ERROR_USER_DATA );
+}
+
+
+static void
+test_set_error_handler_if_handler_is_NULL() {
+  expect_string( mock_die, format, "Callback function ( error_handler ) must not be NULL." );
+  expect_assert_failure( set_error_handler( NULL, NULL ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * set_vendor_handler() tests.
+ ********************************************************************************/
+
+static void
+test_set_vendor_handler() {
+  assert_true( set_vendor_handler( VENDOR_HANDLER, VENDOR_USER_DATA ) );
+  assert_int_equal( event_handlers.vendor_callback, VENDOR_HANDLER );
+  assert_int_equal( event_handlers.vendor_user_data, VENDOR_USER_DATA );
+}
+
+
+static void
+test_set_vendor_handler_if_handler_is_NULL() {
+  expect_string( mock_die, format, "Callback function ( vendor_handler ) must not be NULL." );
+  expect_assert_failure( set_vendor_handler( NULL, NULL ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * set_features_reply_handler() tests.
+ ********************************************************************************/
+
+static void
+test_set_features_reply_handler() {
+  assert_true( set_features_reply_handler( FEATURES_REPLY_HANDLER, FEATURES_REPLY_USER_DATA ) );
+  assert_int_equal( event_handlers.features_reply_callback, FEATURES_REPLY_HANDLER );
+  assert_int_equal( event_handlers.features_reply_user_data, FEATURES_REPLY_USER_DATA );
+}
+
+
+static void
+test_set_features_reply_handler_if_handler_is_NULL() {
+  expect_string( mock_die, format, "Callback function ( features_reply_handler ) must not be NULL." );
+  expect_assert_failure( set_features_reply_handler( NULL, NULL ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * set_get_config_reply_handler() tests.
+ ********************************************************************************/
+
+static void
+test_set_get_config_reply_handler() {
+  assert_true( set_get_config_reply_handler( GET_CONFIG_REPLY_HANDLER, GET_CONFIG_REPLY_USER_DATA ) );
+  assert_int_equal( event_handlers.get_config_reply_callback, GET_CONFIG_REPLY_HANDLER );
+  assert_int_equal( event_handlers.get_config_reply_user_data, GET_CONFIG_REPLY_USER_DATA );
+}
+
+
+static void
+test_set_get_config_reply_handler_if_handler_is_NULL() {
+  expect_string( mock_die, format, "Callback function ( get_config_reply_handler ) must not be NULL." );
+  expect_assert_failure( set_get_config_reply_handler( NULL, NULL ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * Packet in handler tests.
+ ********************************************************************************/
+
+static void
+mock_packet_in_handler(
+  uint64_t datapath_id,
+  uint32_t transaction_id,
+  uint32_t buffer_id,
+  uint16_t total_len,
+  uint16_t in_port,
+  uint8_t reason,
+  const buffer *data,
+  void *user_data
+) {
+  uint32_t total_len32 = total_len;
+  uint32_t in_port32 = in_port;
+  uint32_t reason32 = reason;
+
+  check_expected( &datapath_id );
+  check_expected( transaction_id );
+  check_expected( buffer_id );
+  check_expected( total_len32 );
+  check_expected( in_port32 );
+  check_expected( reason32 );
+  if ( data != NULL ) {
+    check_expected( data->length );
+    check_expected( data->data );
+  }
+  else {
+    void *data_uc = ( void * ) ( unsigned long ) data;
+    check_expected( data_uc );
+  }
+  check_expected( user_data );
+
+  packet_in_handler_called = true;
+}
+
+
+static void
+mock_simple_packet_in_handler( uint64_t dpid, packet_in event ) {
+  uint64_t datapath_id = dpid;
+  uint32_t transaction_id = event.transaction_id;
+  uint32_t buffer_id = event.buffer_id;
+  uint32_t total_len32 = event.total_len;
+  uint32_t in_port32 = event.in_port;
+  uint32_t reason32 = event.reason;
+  const buffer *data = event.data;
+  void *user_data = event.user_data;
+
+  check_expected( &datapath_id );
+  check_expected( transaction_id );
+  check_expected( buffer_id );
+  check_expected( total_len32 );
+  check_expected( in_port32 );
+  check_expected( reason32 );
+  check_expected( data->length );
+  check_expected( user_data );
+
+  packet_in_handler_called = true;
+}
+
+
+static void
+test_set_packet_in_handler() {
+  set_packet_in_handler( mock_packet_in_handler, PACKET_IN_USER_DATA );
+  assert_true( event_handlers.packet_in_callback == mock_packet_in_handler );
+  assert_true( event_handlers.packet_in_user_data == PACKET_IN_USER_DATA );
+}
+
+
+static void
+test_set_simple_packet_in_handler() {
+  set_packet_in_handler( mock_simple_packet_in_handler, PACKET_IN_USER_DATA );
+  assert_true( event_handlers.packet_in_callback == mock_simple_packet_in_handler );
+  assert_true( event_handlers.packet_in_user_data == PACKET_IN_USER_DATA );
+}
+
+
+static void
+test_set_packet_in_handler_should_die_if_handler_is_NULL() {
+  expect_string( mock_die, format, "Callback function (packet_in_handler) must not be NULL." );
+  expect_assert_failure( set_packet_in_handler( NULL, PACKET_IN_USER_DATA ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+static void
+test_handle_packet_in() {
+  uint8_t reason = OFPR_NO_MATCH;
+  uint16_t in_port = 1;
+  uint32_t buffer_id = 0x01020304;
+  buffer *data = alloc_buffer_with_length( 64 );
+  calloc_packet_info( data );
+  append_back_buffer( data, 64 );
+  memset( data->data, 0x01, 64 );
+  uint16_t total_len = ( uint16_t ) data->length;
+
+  will_return( mock_parse_packet, true );
+  expect_memory( mock_packet_in_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_packet_in_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_packet_in_handler, buffer_id, buffer_id );
+  expect_value( mock_packet_in_handler, total_len32, ( uint32_t ) total_len );
+  expect_value( mock_packet_in_handler, in_port32, ( uint32_t ) in_port );
+  expect_value( mock_packet_in_handler, reason32, ( uint32_t ) reason );
+  expect_value( mock_packet_in_handler, data->length, data->length );
+  expect_memory( mock_packet_in_handler, data->data, data->data, data->length );
+  expect_memory( mock_packet_in_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_packet_in_handler( mock_packet_in_handler, USER_DATA );
+
+  buffer *buffer = create_packet_in( TRANSACTION_ID, buffer_id, total_len, in_port, reason, data );
+  handle_packet_in( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_packet_in_with_simple_handler() {
+  uint8_t reason = OFPR_NO_MATCH;
+  uint16_t in_port = 1;
+  uint32_t buffer_id = 0x01020304;
+  buffer *data = alloc_buffer_with_length( 64 );
+  calloc_packet_info( data );
+  append_back_buffer( data, 64 );
+  memset( data->data, 0x01, 64 );
+  uint16_t total_len = ( uint16_t ) data->length;
+
+  will_return( mock_parse_packet, true );
+  expect_memory( mock_simple_packet_in_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_simple_packet_in_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_simple_packet_in_handler, buffer_id, buffer_id );
+  expect_value( mock_simple_packet_in_handler, total_len32, ( uint32_t ) total_len );
+  expect_value( mock_simple_packet_in_handler, in_port32, ( uint32_t ) in_port );
+  expect_value( mock_simple_packet_in_handler, reason32, ( uint32_t ) reason );
+  expect_value( mock_simple_packet_in_handler, data->length, data->length );
+  expect_memory( mock_simple_packet_in_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_packet_in_handler( mock_simple_packet_in_handler, USER_DATA );
+
+  buffer *buffer = create_packet_in( TRANSACTION_ID, buffer_id, total_len, in_port, reason, data );
+  handle_packet_in( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_packet_in_with_malformed_packet() {
+  uint8_t reason = OFPR_NO_MATCH;
+  uint16_t in_port = 1;
+  uint32_t buffer_id = 0x01020304;
+  buffer *data = alloc_buffer_with_length( 64 );
+  calloc_packet_info( data );
+  append_back_buffer( data, 64 );
+  memset( data->data, 0x01, 64 );
+  uint16_t total_len = ( uint16_t ) data->length;
+  buffer *buffer = create_packet_in( TRANSACTION_ID, buffer_id, total_len, in_port, reason, data );
+
+  will_return( mock_parse_packet, false );
+
+  set_packet_in_handler( mock_packet_in_handler, USER_DATA );
+  handle_packet_in( DATAPATH_ID, buffer );
+
+  assert_false( packet_in_handler_called );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_packet_in_without_data() {
+  uint8_t reason = OFPR_NO_MATCH;
+  uint16_t in_port = 1;
+  uint32_t buffer_id = 0x01020304;
+  buffer *data = alloc_buffer_with_length( 64 );
+  append_back_buffer( data, 64 );
+  memset( data->data, 0x01, 64 );
+  uint16_t total_len = ( uint16_t ) data->length;
+
+  expect_memory( mock_packet_in_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_packet_in_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_packet_in_handler, buffer_id, buffer_id );
+  expect_value( mock_packet_in_handler, total_len32, ( uint32_t ) total_len );
+  expect_value( mock_packet_in_handler, in_port32, ( uint32_t ) in_port );
+  expect_value( mock_packet_in_handler, reason32, ( uint32_t ) reason );
+  expect_value( mock_packet_in_handler, data_uc, NULL );
+  expect_memory( mock_packet_in_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_packet_in_handler( mock_packet_in_handler, USER_DATA );
+
+  buffer *buffer = create_packet_in( TRANSACTION_ID, buffer_id, total_len, in_port, reason, NULL );
+  handle_packet_in( DATAPATH_ID, buffer );
+
+  free_buffer( data );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_packet_in_without_handler() {
+  uint8_t reason = OFPR_NO_MATCH;
+  uint16_t in_port = 1;
+  uint32_t buffer_id = 0x01020304;
+  buffer *data = alloc_buffer_with_length( 64 );
+  append_back_buffer( data, 64 );
+  memset( data->data, 0x01, 64 );
+  uint16_t total_len = ( uint16_t ) data->length;
+  buffer *buffer = create_packet_in( TRANSACTION_ID, buffer_id, total_len, in_port, reason, data );
+
+  handle_packet_in( DATAPATH_ID, buffer );
+  assert_false( packet_in_handler_called );
+
+  free_buffer( data );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_packet_in_should_die_if_message_is_NULL() {
+  expect_string( mock_die, format, "handle_packet_in(): packet_in message should not be empty." );
+  set_packet_in_handler( mock_packet_in_handler, USER_DATA );
+  expect_assert_failure( handle_packet_in( DATAPATH_ID, NULL ) );
+}
+
+
+static void
+test_handle_packet_in_should_die_if_message_length_is_zero() {
+  buffer *buffer = alloc_buffer_with_length( 32 );
+
+  expect_string( mock_die, format, "handle_packet_in(): packet_in message should not be empty." );
+  set_packet_in_handler( mock_packet_in_handler, USER_DATA );
+  expect_assert_failure( handle_packet_in( DATAPATH_ID, buffer ) );
+
+  free_buffer( buffer );
+}
+
+
+/********************************************************************************
+ * set_flow_removed_handler() tests.
+ ********************************************************************************/
+
+static void
+mock_simple_flow_removed_handler( uint64_t datapath_id, flow_removed message ) {
+  uint32_t transaction_id = message.transaction_id;
+  struct ofp_match match = message.match;
+  uint64_t cookie = message.cookie;
+  uint32_t priority32 = message.priority;
+  uint32_t reason32 = message.reason;
+  uint32_t duration_sec = message.duration_sec;
+  uint32_t duration_nsec = message.duration_nsec;
+  uint32_t idle_timeout32 = message.idle_timeout;
+  uint64_t packet_count = message.packet_count;
+  uint64_t byte_count = message.byte_count;
+  void *user_data = message.user_data;
+
+  check_expected( &datapath_id );
+  check_expected( transaction_id );
+  check_expected( &match );
+  check_expected( &cookie );
+  check_expected( priority32 );
+  check_expected( reason32 );
+  check_expected( duration_sec );
+  check_expected( duration_nsec );
+  check_expected( idle_timeout32 );
+  check_expected( &packet_count );
+  check_expected( &byte_count );
+  check_expected( user_data );
+}
+
+
+static void
+test_set_flow_removed_handler() {
+  set_flow_removed_handler( mock_flow_removed_handler, FLOW_REMOVED_USER_DATA );
+  assert_true( event_handlers.flow_removed_callback == mock_flow_removed_handler );
+  assert_true( event_handlers.flow_removed_user_data == FLOW_REMOVED_USER_DATA );
+}
+
+
+static void
+test_set_simple_flow_removed_handler() {
+  set_flow_removed_handler( mock_simple_flow_removed_handler, FLOW_REMOVED_USER_DATA );
+  assert_true( event_handlers.flow_removed_callback == mock_simple_flow_removed_handler );
+  assert_true( event_handlers.flow_removed_user_data == FLOW_REMOVED_USER_DATA );
+}
+
+
+static void
+test_set_flow_removed_handler_if_handler_is_NULL() {
+  expect_string( mock_die, format, "Callback function (flow_removed_handler) must not be NULL." );
+  expect_assert_failure( set_flow_removed_handler( NULL, NULL ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * set_port_status_handler() tests.
+ ********************************************************************************/
+
+static void
+test_set_port_status_handler() {
+  assert_true( set_port_status_handler( PORT_STATUS_HANDLER, PORT_STATUS_USER_DATA ) );
+  assert_int_equal( event_handlers.port_status_callback, PORT_STATUS_HANDLER );
+  assert_int_equal( event_handlers.port_status_user_data, PORT_STATUS_USER_DATA );
+}
+
+
+static void
+test_set_port_status_handler_if_handler_is_NULL() {
+  expect_string( mock_die, format, "Callback function ( port_status_handler ) must not be NULL." );
+  expect_assert_failure( set_port_status_handler( NULL, NULL ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * set_stats_reply_handler() tests.
+ ********************************************************************************/
+
+static void
+test_set_stats_reply_handler() {
+  assert_true( set_stats_reply_handler( STATS_REPLY_HANDLER, STATS_REPLY_USER_DATA ) );
+  assert_int_equal( event_handlers.stats_reply_callback, STATS_REPLY_HANDLER );
+  assert_int_equal( event_handlers.stats_reply_user_data, STATS_REPLY_USER_DATA );
+}
+
+
+static void
+test_set_stats_reply_handler_if_handler_is_NULL() {
+  expect_string( mock_die, format, "Callback function ( stats_reply_handler ) must not be NULL." );
+  expect_assert_failure( set_stats_reply_handler( NULL, NULL ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * set_barrier_reply_handler() tests.
+ ********************************************************************************/
+
+static void
+test_set_barrier_reply_handler() {
+  assert_true( set_barrier_reply_handler( BARRIER_REPLY_HANDLER, BARRIER_REPLY_USER_DATA ) );
+  assert_int_equal( event_handlers.barrier_reply_callback, BARRIER_REPLY_HANDLER );
+  assert_int_equal( event_handlers.barrier_reply_user_data, BARRIER_REPLY_USER_DATA );
+}
+
+
+static void
+test_set_barrier_reply_handler_if_handler_is_NULL() {
+  expect_string( mock_die, format, "Callback function ( barrier_reply_handler ) must not be NULL." );
+  expect_assert_failure( set_barrier_reply_handler( NULL, NULL ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * set_queue_get_config_reply_handler() tests.
+ ********************************************************************************/
+
+static void
+test_set_queue_get_config_reply_handler() {
+  assert_true( set_queue_get_config_reply_handler( QUEUE_GET_CONFIG_REPLY_HANDLER, QUEUE_GET_CONFIG_REPLY_USER_DATA ) );
+  assert_int_equal( event_handlers.queue_get_config_reply_callback, QUEUE_GET_CONFIG_REPLY_HANDLER );
+  assert_int_equal( event_handlers.queue_get_config_reply_user_data, QUEUE_GET_CONFIG_REPLY_USER_DATA );
+}
+
+
+static void
+test_set_queue_get_config_reply_handler_if_handler_is_NULL() {
+  expect_string( mock_die, format, "Callback function ( queue_get_config_reply_handler ) must not be NULL." );
+  expect_assert_failure( set_queue_get_config_reply_handler( NULL, NULL ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * set_list_switches_reply_handler() tests.
+ ********************************************************************************/
+
+
+static void
+test_set_list_switches_reply_handler() {
+  assert_true( set_list_switches_reply_handler( LIST_SWITCHES_REPLY_HANDLER ) );
+  assert_int_equal( event_handlers.list_switches_reply_callback, LIST_SWITCHES_REPLY_HANDLER );
+}
+
+
+static void
+test_set_list_switches_reply_handler_if_handler_is_NULL() {
+  expect_string( mock_die, format, "Callback function ( list_switches_reply_handler ) must not be NULL." );
+  expect_assert_failure( set_list_switches_reply_handler( NULL ) );
+  assert_memory_equal( &event_handlers, &NULL_EVENT_HANDLERS, sizeof( event_handlers ) );
+}
+
+
+/********************************************************************************
+ * send_openflow_message() tests.
+ ********************************************************************************/
+
+static void
+test_send_openflow_message() {
+  void *expected_data;
+  bool ret;
+  size_t expected_length, header_length;
+  buffer *buffer;
+  openflow_service_header_t *header;
+
+  buffer = create_hello( TRANSACTION_ID );
+
+  assert_true( buffer != NULL );
+
+  header_length = ( size_t ) ( sizeof( openflow_service_header_t ) +
+                               strlen( SERVICE_NAME ) + 1 );
+  expected_length = ( size_t ) ( header_length + sizeof( struct ofp_header ) );
+
+  expected_data = xcalloc( 1, expected_length );
+
+  header = expected_data;
+  header->datapath_id = htonll( DATAPATH_ID );
+  header->service_name_length = htons( ( uint16_t ) ( strlen( SERVICE_NAME ) + 1 ) );
+
+  memcpy( ( char * ) expected_data + sizeof( openflow_service_header_t ),
+          SERVICE_NAME, strlen( SERVICE_NAME ) + 1 );
+  memcpy( ( char * ) expected_data + header_length, buffer->data, buffer->length );
+
+  expect_string( mock_send_message, service_name, REMOTE_SERVICE_NAME );
+  expect_value( mock_send_message, tag32, MESSENGER_OPENFLOW_MESSAGE );
+  expect_value( mock_send_message, len, expected_length );
+  expect_memory( mock_send_message, data, expected_data, expected_length );
+  will_return( mock_send_message, true );
+
+  ret = send_openflow_message( DATAPATH_ID, buffer );
+  
+  assert_true( ret );
+  stat_entry *stat = lookup_hash_entry( stats, "openflow_application_interface.hello_send_succeeded" );
+  assert_int_equal( ( int ) stat->value, 1 );
+
+  free_buffer( buffer );
+  xfree( expected_data );
+  xfree( delete_hash_entry( stats, "openflow_application_interface.hello_send_succeeded" ) );
+}
+
+
+static void
+test_send_openflow_message_if_message_is_NULL() {
+  expect_assert_failure( send_openflow_message( DATAPATH_ID, NULL ) );
+}
+
+
+static void
+test_send_openflow_message_if_message_length_is_zero() {
+  buffer *buffer;
+
+  buffer = alloc_buffer_with_length( 128 );
+
+  assert_true( buffer != NULL );
+
+  expect_assert_failure( send_openflow_message( DATAPATH_ID, NULL ) );
+
+  free_buffer( buffer );
+}
+
+
+/********************************************************************************
+ * handle_error() tests.
+ ********************************************************************************/
+
+static void
+test_handle_error() {
+  buffer *buffer, *data;
+
+  data = alloc_buffer_with_length( 16 );
+  append_back_buffer( data, 16 );
+  memset( data->data, 'a', 16 );
+
+  buffer = create_error( TRANSACTION_ID, OFPET_HELLO_FAILED, OFPHFC_INCOMPATIBLE, data );
+
+  expect_memory( mock_error_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_error_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_error_handler, type32, OFPET_HELLO_FAILED );
+  expect_value( mock_error_handler, code32, OFPHFC_INCOMPATIBLE );
+  expect_value( mock_error_handler, data->length, data->length );
+  expect_memory( mock_error_handler, data->data, data->data, data->length );
+  expect_memory( mock_error_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_error_handler( mock_error_handler, USER_DATA );
+  handle_error( DATAPATH_ID, buffer );
+
+  free_buffer( data );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_error_if_handler_is_not_registered() {
+  buffer *buffer, *data;
+
+  data = alloc_buffer_with_length( 16 );
+  append_back_buffer( data, 16 );
+  memset( data->data, 'a', 16 );
+
+  buffer = create_error( TRANSACTION_ID, OFPET_HELLO_FAILED, OFPHFC_INCOMPATIBLE, data );
+
+  // FIXME
+
+  handle_error( DATAPATH_ID, buffer );
+
+  free_buffer( data );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_error_if_message_is_NULL() {
+  set_error_handler( mock_error_handler, USER_DATA );
+  expect_assert_failure( handle_error( DATAPATH_ID, NULL ) );
+}
+
+
+static void
+test_handle_error_if_message_length_is_zero() {
+  buffer *buffer;
+
+  buffer = alloc_buffer_with_length( 32 );
+
+  set_error_handler( mock_error_handler, USER_DATA );
+  expect_assert_failure( handle_error( DATAPATH_ID, buffer ) );
+
+  free_buffer( buffer );
+}
+
+
+/********************************************************************************
+ * handle_vendor() tests.
+ ********************************************************************************/
+
+static void
+test_handle_vendor() {
+  buffer *buffer, *data;
+
+  data = alloc_buffer_with_length( 16 );
+  append_back_buffer( data, 16 );
+  memset( data->data, 'a', 16 );
+
+  buffer = create_vendor( TRANSACTION_ID, VENDOR_ID, data );
+
+  expect_memory( mock_vendor_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_vendor_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_vendor_handler, vendor, VENDOR_ID );
+  expect_value( mock_vendor_handler, data->length, data->length );
+  expect_memory( mock_vendor_handler, data->data, data->data, data->length );
+  expect_memory( mock_vendor_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_vendor_handler( mock_vendor_handler, USER_DATA );
+  handle_vendor( DATAPATH_ID, buffer );
+
+  free_buffer( data );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_vendor_without_data() {
+  buffer *buffer;
+
+  buffer = create_vendor( TRANSACTION_ID, VENDOR_ID, NULL );
+
+  expect_memory( mock_vendor_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_vendor_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_vendor_handler, vendor, VENDOR_ID );
+  expect_value( mock_vendor_handler, data_uc, NULL );
+  expect_memory( mock_vendor_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_vendor_handler( mock_vendor_handler, USER_DATA );
+  handle_vendor( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_vendor_if_handler_is_not_registered() {
+  buffer *buffer, *data;
+
+  data = alloc_buffer_with_length( 16 );
+  append_back_buffer( data, 16 );
+  memset( data->data, 'a', 16 );
+
+  buffer = create_vendor( TRANSACTION_ID, VENDOR_ID, data );
+
+  // FIXME
+
+  handle_vendor( DATAPATH_ID, buffer );
+
+  free_buffer( data );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_vendor_if_message_is_NULL() {
+  set_vendor_handler( mock_vendor_handler, USER_DATA );
+  expect_assert_failure( handle_vendor( DATAPATH_ID, NULL ) );
+}
+
+
+static void
+test_handle_vendor_if_message_length_is_zero() {
+  buffer *buffer;
+
+  buffer = alloc_buffer_with_length( 32 );
+
+  set_vendor_handler( mock_vendor_handler, USER_DATA );
+  expect_assert_failure( handle_vendor( DATAPATH_ID, buffer ) );
+
+  free_buffer( buffer );
+}
+
+
+/********************************************************************************
+ * handle_features_reply() tests.
+ ********************************************************************************/
+
+static void
+test_handle_features_reply() {
+  uint8_t n_tables = 2;
+  uint32_t n_buffers = 1024;
+  uint32_t capabilities;
+  uint32_t actions;
+  struct ofp_phy_port *phy_port[ 2 ];
+  buffer *buffer;
+  list_element *ports;
+
+  capabilities = ( OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS |
+                   OFPC_QUEUE_STATS | OFPC_ARP_MATCH_IP );
+  actions = ( ( 1 << OFPAT_OUTPUT ) | ( 1 << OFPAT_SET_VLAN_VID ) |
+              ( 1 << OFPAT_SET_TP_SRC ) | ( 1 << OFPAT_SET_TP_DST ) );
+
+  phy_port[ 0 ] = xcalloc( 1, sizeof( struct ofp_phy_port ) );
+  phy_port[ 1 ] = xcalloc( 1, sizeof( struct ofp_phy_port ) );
+
+  phy_port[ 0 ]->port_no = 1;
+  memcpy( phy_port[ 0 ]->hw_addr, MAC_ADDR_X, sizeof( phy_port[ 0 ]->hw_addr ) );
+  memset( phy_port[ 0 ]->name, '\0', OFP_MAX_PORT_NAME_LEN );
+  memcpy( phy_port[ 0 ]->name, PORT_NAME, strlen( PORT_NAME ) );
+  phy_port[ 0 ]->config = OFPPC_PORT_DOWN;
+  phy_port[ 0 ]->state = OFPPS_LINK_DOWN;
+  phy_port[ 0 ]->curr = ( OFPPF_1GB_FD | OFPPF_COPPER | OFPPF_PAUSE );
+  phy_port[ 0 ]->advertised = PORT_FEATURES;
+  phy_port[ 0 ]->supported = PORT_FEATURES;
+  phy_port[ 0 ]->peer = PORT_FEATURES;
+
+  memcpy( phy_port[ 1 ], phy_port [ 0 ], sizeof( struct ofp_phy_port ) );
+
+  phy_port[ 1 ]->port_no = 2;
+  memcpy( phy_port[ 1 ]->hw_addr, MAC_ADDR_Y, sizeof( phy_port[ 1 ]->hw_addr ) );
+
+  create_list( &ports );
+  append_to_tail( &ports, phy_port[ 0 ] );
+  append_to_tail( &ports, phy_port[ 1 ] );
+
+  buffer = create_features_reply( TRANSACTION_ID, DATAPATH_ID, n_buffers, n_tables,
+                                  capabilities, actions, ports );
+
+  expect_memory( mock_features_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_features_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_features_reply_handler, n_buffers, n_buffers );
+  expect_value( mock_features_reply_handler, n_tables32, ( uint32_t ) n_tables );
+  expect_value( mock_features_reply_handler, capabilities, capabilities );
+  expect_value( mock_features_reply_handler, actions, actions );
+  expect_memory( mock_features_reply_handler, port1, ports->data, sizeof( struct ofp_phy_port ) );
+  expect_memory( mock_features_reply_handler, port2, ports->next->data, sizeof( struct ofp_phy_port ) );
+  expect_memory( mock_features_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_features_reply_handler( mock_features_reply_handler, USER_DATA );
+  handle_features_reply( DATAPATH_ID, buffer );
+
+  xfree( phy_port[0] );
+  xfree( phy_port[1] );
+  delete_list( ports );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_features_reply_without_phy_port() {
+  uint8_t n_tables = 2;
+  uint32_t n_buffers = 1024;
+  uint32_t capabilities;
+  uint32_t actions;
+  buffer *buffer;
+
+  capabilities = ( OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS |
+                   OFPC_QUEUE_STATS | OFPC_ARP_MATCH_IP );
+  actions = ( ( 1 << OFPAT_OUTPUT ) | ( 1 << OFPAT_SET_VLAN_VID ) |
+              ( 1 << OFPAT_SET_TP_SRC ) | ( 1 << OFPAT_SET_TP_DST ) );
+
+  buffer = create_features_reply( TRANSACTION_ID, DATAPATH_ID, n_buffers, n_tables,
+                                  capabilities, actions, NULL );
+
+  expect_memory( mock_features_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_features_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_features_reply_handler, n_buffers, n_buffers );
+  expect_value( mock_features_reply_handler, n_tables32, ( uint32_t ) n_tables );
+  expect_value( mock_features_reply_handler, capabilities, capabilities );
+  expect_value( mock_features_reply_handler, actions, actions );
+  expect_value( mock_features_reply_handler, phy_ports_uc, NULL );
+  expect_memory( mock_features_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_features_reply_handler( mock_features_reply_handler, USER_DATA );
+  handle_features_reply( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_features_reply_if_handler_is_not_registered() {
+  uint8_t n_tables = 2;
+  uint32_t n_buffers = 1024;
+  uint32_t capabilities;
+  uint32_t actions;
+  struct ofp_phy_port *phy_port[ 2 ];
+  buffer *buffer;
+  list_element *ports;
+
+  capabilities = ( OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS |
+                   OFPC_QUEUE_STATS | OFPC_ARP_MATCH_IP );
+  actions = ( ( 1 << OFPAT_OUTPUT ) | ( 1 << OFPAT_SET_VLAN_VID ) |
+              ( 1 << OFPAT_SET_TP_SRC ) | ( 1 << OFPAT_SET_TP_DST ) );
+
+  phy_port[ 0 ] = xcalloc( 1, sizeof( struct ofp_phy_port ) );
+  phy_port[ 1 ] = xcalloc( 1, sizeof( struct ofp_phy_port ) );
+
+  phy_port[ 0 ]->port_no = 1;
+  memcpy( phy_port[ 0 ]->hw_addr, MAC_ADDR_X, sizeof( phy_port[ 0 ]->hw_addr ) );
+  memset( phy_port[ 0 ]->name, '\0', OFP_MAX_PORT_NAME_LEN );
+  memcpy( phy_port[ 0 ]->name, PORT_NAME, strlen( PORT_NAME ) );
+  phy_port[ 0 ]->config = OFPPC_PORT_DOWN;
+  phy_port[ 0 ]->state = OFPPS_LINK_DOWN;
+  phy_port[ 0 ]->curr = ( OFPPF_1GB_FD | OFPPF_COPPER | OFPPF_PAUSE );
+  phy_port[ 0 ]->advertised = PORT_FEATURES;
+  phy_port[ 0 ]->supported = PORT_FEATURES;
+  phy_port[ 0 ]->peer = PORT_FEATURES;
+
+  memcpy( phy_port[ 1 ], phy_port [ 0 ], sizeof( struct ofp_phy_port ) );
+
+  phy_port[ 1 ]->port_no = 2;
+  memcpy( phy_port[ 1 ]->hw_addr, MAC_ADDR_Y, sizeof( phy_port[ 1 ]->hw_addr ) );
+
+  create_list( &ports );
+  append_to_tail( &ports, phy_port[ 0 ] );
+  append_to_tail( &ports, phy_port[ 1 ] );
+
+  buffer = create_features_reply( TRANSACTION_ID, DATAPATH_ID, n_buffers, n_tables,
+                                  capabilities, actions, ports );
+
+  // FIXME
+
+  handle_features_reply( DATAPATH_ID, buffer );
+
+  xfree( phy_port[0] );
+  xfree( phy_port[1] );
+  delete_list( ports );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_features_reply_if_message_is_NULL() {
+  set_features_reply_handler( mock_features_reply_handler, USER_DATA );
+  expect_assert_failure( handle_features_reply( DATAPATH_ID, NULL ) );
+}
+
+
+static void
+test_handle_features_reply_if_message_length_is_zero() {
+  buffer *buffer;
+
+  buffer = alloc_buffer_with_length( 32 );
+
+  set_features_reply_handler( mock_features_reply_handler, USER_DATA );
+  expect_assert_failure( handle_features_reply( DATAPATH_ID, buffer ) );
+
+  free_buffer( buffer );
+}
+
+
+/********************************************************************************
+ * handle_get_config_reply() tests.
+ ********************************************************************************/
+
+static void
+test_handle_get_config_reply() {
+  uint16_t flags = OFPC_FRAG_NORMAL;
+  uint16_t miss_send_len = 128;
+  buffer *buffer;
+
+  buffer = create_get_config_reply( TRANSACTION_ID, flags, miss_send_len );
+
+  expect_memory( mock_get_config_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_get_config_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_get_config_reply_handler, flags32, ( uint32_t ) flags );
+  expect_value( mock_get_config_reply_handler, miss_send_len32, ( uint32_t ) miss_send_len );
+  expect_memory( mock_get_config_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_get_config_reply_handler( mock_get_config_reply_handler, USER_DATA );
+  handle_get_config_reply( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_get_config_reply_if_handler_is_not_registered() {
+  uint16_t flags = OFPC_FRAG_NORMAL;
+  uint16_t miss_send_len = 128;
+  buffer *buffer;
+
+  buffer = create_get_config_reply( TRANSACTION_ID, flags, miss_send_len );
+
+  // FIXME
+
+  handle_get_config_reply( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_get_config_reply_if_message_is_NULL() {
+  set_get_config_reply_handler( mock_get_config_reply_handler, USER_DATA );
+  expect_assert_failure( handle_get_config_reply( DATAPATH_ID, NULL ) );
+}
+
+
+static void
+test_handle_get_config_reply_if_message_length_is_zero() {
+  buffer *buffer;
+
+  buffer = alloc_buffer_with_length( 32 );
+
+  set_get_config_reply_handler( mock_get_config_reply_handler, USER_DATA );
+  expect_assert_failure( handle_get_config_reply( DATAPATH_ID, buffer ) );
+
+  free_buffer( buffer );
+}
+
+
+/********************************************************************************
+ * handle_flow_removed() tests.
+ ********************************************************************************/
+
+static void
+test_handle_flow_removed() {
+  uint8_t reason =  OFPRR_IDLE_TIMEOUT;
+  uint16_t idle_timeout = 60;
+  uint16_t priority = UINT16_MAX;
+  uint32_t duration_sec = 180;
+  uint32_t duration_nsec = 10000;
+  uint64_t cookie = 0x0102030405060708ULL;
+  uint64_t packet_count = 1000;
+  uint64_t byte_count = 100000;
+  buffer *buffer = create_flow_removed(
+    TRANSACTION_ID,
+    MATCH,
+    cookie,
+    priority,
+    reason,
+    duration_sec,
+    duration_nsec,
+    idle_timeout,
+    packet_count,
+    byte_count
+  );
+
+  expect_memory( mock_flow_removed_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_flow_removed_handler, transaction_id, TRANSACTION_ID );
+  expect_memory( mock_flow_removed_handler, &match, &MATCH, sizeof( struct ofp_match ) );
+  expect_memory( mock_flow_removed_handler, &cookie, &cookie, sizeof( uint64_t ) );
+  expect_value( mock_flow_removed_handler, priority32, ( uint32_t ) priority );
+  expect_value( mock_flow_removed_handler, reason32, ( uint32_t ) reason );
+  expect_value( mock_flow_removed_handler, duration_sec, duration_sec );
+  expect_value( mock_flow_removed_handler, duration_nsec, duration_nsec );
+  expect_value( mock_flow_removed_handler, idle_timeout32, ( uint32_t ) idle_timeout );
+  expect_memory( mock_flow_removed_handler, &packet_count, &packet_count, sizeof( uint64_t ) );
+  expect_memory( mock_flow_removed_handler, &byte_count, &byte_count, sizeof( uint64_t ) );
+  expect_memory( mock_flow_removed_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_flow_removed_handler( mock_flow_removed_handler, USER_DATA );
+  handle_flow_removed( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_flow_removed_with_simple_handler() {
+  uint8_t reason = OFPRR_IDLE_TIMEOUT;
+  uint16_t idle_timeout = 60;
+  uint16_t priority = UINT16_MAX;
+  uint32_t duration_sec = 180;
+  uint32_t duration_nsec = 10000;
+  uint64_t cookie = 0x0102030405060708ULL;
+  uint64_t packet_count = 1000;
+  uint64_t byte_count = 100000;
+  buffer *buffer = create_flow_removed(
+    TRANSACTION_ID,
+    MATCH,
+    cookie,
+    priority,
+    reason,
+    duration_sec,
+    duration_nsec,
+    idle_timeout,
+    packet_count,
+    byte_count
+  );
+
+  expect_memory( mock_simple_flow_removed_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_simple_flow_removed_handler, transaction_id, TRANSACTION_ID );
+  expect_memory( mock_simple_flow_removed_handler, &match, &MATCH, sizeof( struct ofp_match ) );
+  expect_memory( mock_simple_flow_removed_handler, &cookie, &cookie, sizeof( uint64_t ) );
+  expect_value( mock_simple_flow_removed_handler, priority32, ( uint32_t ) priority );
+  expect_value( mock_simple_flow_removed_handler, reason32, ( uint32_t ) reason );
+  expect_value( mock_simple_flow_removed_handler, duration_sec, duration_sec );
+  expect_value( mock_simple_flow_removed_handler, duration_nsec, duration_nsec );
+  expect_value( mock_simple_flow_removed_handler, idle_timeout32, ( uint32_t ) idle_timeout );
+  expect_memory( mock_simple_flow_removed_handler, &packet_count, &packet_count, sizeof( uint64_t ) );
+  expect_memory( mock_simple_flow_removed_handler, &byte_count, &byte_count, sizeof( uint64_t ) );
+  expect_memory( mock_simple_flow_removed_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_flow_removed_handler( mock_simple_flow_removed_handler, USER_DATA );
+  handle_flow_removed( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_flow_removed_if_handler_is_not_registered() {
+  uint8_t reason =  OFPRR_IDLE_TIMEOUT;
+  uint16_t idle_timeout = 60;
+  uint16_t priority = UINT16_MAX;
+  uint32_t duration_sec = 180;
+  uint32_t duration_nsec = 10000;
+  uint64_t cookie = 0x0102030405060708ULL;
+  uint64_t packet_count = 1000;
+  uint64_t byte_count = 100000;
+  buffer *buffer;
+
+  buffer = create_flow_removed( TRANSACTION_ID, MATCH, cookie, priority,
+                                reason, duration_sec, duration_nsec,
+                                idle_timeout, packet_count, byte_count );
+
+  // FIXME
+  handle_flow_removed( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_flow_removed_if_message_is_NULL() {
+  set_flow_removed_handler( mock_flow_removed_handler, USER_DATA );
+  expect_assert_failure( handle_flow_removed( DATAPATH_ID, NULL ) );
+}
+
+
+static void
+test_handle_flow_removed_if_message_length_is_zero() {
+  buffer *buffer;
+
+  buffer = alloc_buffer_with_length( 32 );
+
+  set_flow_removed_handler( mock_flow_removed_handler, USER_DATA );
+  expect_assert_failure( handle_flow_removed( DATAPATH_ID, buffer ) );
+
+  free_buffer( buffer );
+}
+
+
+/********************************************************************************
+ * handle_port_status() tests.
+ ********************************************************************************/
+
+static void
+test_handle_port_status() {
+  uint8_t reason = OFPPR_MODIFY;
+  buffer *buffer;
+  struct ofp_phy_port desc;
+
+  desc.port_no = 1;
+  memcpy( desc.hw_addr, MAC_ADDR_X, sizeof( desc.hw_addr ) );
+  memset( desc.name, '\0', OFP_MAX_PORT_NAME_LEN );
+  memcpy( desc.name, PORT_NAME, strlen( PORT_NAME ) );
+  desc.config = OFPPC_PORT_DOWN;
+  desc.state = OFPPS_LINK_DOWN;
+  desc.curr = ( OFPPF_1GB_FD | OFPPF_COPPER | OFPPF_PAUSE );
+  desc.advertised = PORT_FEATURES;
+  desc.supported = PORT_FEATURES;
+  desc.peer = PORT_FEATURES;
+
+  buffer = create_port_status( TRANSACTION_ID, reason, desc );
+
+  expect_memory( mock_port_status_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_port_status_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_port_status_handler, reason32, ( uint32_t ) reason );
+  expect_memory( mock_port_status_handler, &phy_port, &desc, sizeof( struct ofp_phy_port ) );
+  expect_memory( mock_port_status_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_port_status_handler( mock_port_status_handler, USER_DATA );
+  handle_port_status( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_port_status_if_handler_is_not_registered() {
+  uint8_t reason = OFPPR_MODIFY;
+  buffer *buffer;
+  struct ofp_phy_port desc;
+
+  desc.port_no = 1;
+  memcpy( desc.hw_addr, MAC_ADDR_X, sizeof( desc.hw_addr ) );
+  memset( desc.name, '\0', OFP_MAX_PORT_NAME_LEN );
+  memcpy( desc.name, PORT_NAME, strlen( PORT_NAME ) );
+  desc.config = OFPPC_PORT_DOWN;
+  desc.state = OFPPS_LINK_DOWN;
+  desc.curr = ( OFPPF_1GB_FD | OFPPF_COPPER | OFPPF_PAUSE );
+  desc.advertised = PORT_FEATURES;
+  desc.supported = PORT_FEATURES;
+  desc.peer = PORT_FEATURES;
+
+  buffer = create_port_status( TRANSACTION_ID, reason, desc );
+
+  // FIXME
+  handle_port_status( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_port_status_if_message_is_NULL() {
+  set_port_status_handler( mock_port_status_handler, USER_DATA );
+  expect_assert_failure( handle_port_status( DATAPATH_ID, NULL ) );
+}
+
+
+static void
+test_handle_port_status_if_message_length_is_zero() {
+  buffer *buffer;
+
+  buffer = alloc_buffer_with_length( 32 );
+
+  set_port_status_handler( mock_port_status_handler, USER_DATA );
+  expect_assert_failure( handle_port_status( DATAPATH_ID, buffer ) );
+
+  free_buffer( buffer );
+}
+
+
+/********************************************************************************
+ * handle_stats_reply() tests.
+ ********************************************************************************/
+
+static void
+test_handle_stats_reply_if_type_is_OFPST_DESC() {
+  char mfr_desc[ DESC_STR_LEN ];
+  char hw_desc[ DESC_STR_LEN ];
+  char sw_desc[ DESC_STR_LEN ];
+  char serial_num[ SERIAL_NUM_LEN ];
+  char dp_desc[ DESC_STR_LEN ];
+  uint16_t flags = 0;
+  uint32_t body_len;
+  buffer *buffer;
+  struct ofp_stats_reply *stats_reply;
+
+  memset( mfr_desc, '\0', DESC_STR_LEN );
+  memset( hw_desc, '\0', DESC_STR_LEN );
+  memset( sw_desc, '\0', DESC_STR_LEN );
+  memset( serial_num, '\0', SERIAL_NUM_LEN );
+  memset( dp_desc, '\0', DESC_STR_LEN );
+  sprintf( mfr_desc, "NEC Coporation" );
+  sprintf( hw_desc, "OpenFlow Switch Hardware" );
+  sprintf( sw_desc, "OpenFlow Switch Software" );
+  sprintf( serial_num, "123456" );
+  sprintf( dp_desc, "Datapath 0" );
+
+  buffer = create_desc_stats_reply( TRANSACTION_ID, flags, mfr_desc, hw_desc,
+                                    sw_desc, serial_num, dp_desc );
+
+  stats_reply = buffer->data;
+  body_len = ( uint32_t ) ( ntohs( stats_reply->header.length ) -
+                            offsetof( struct ofp_stats_reply, body ) );
+
+  expect_memory( mock_stats_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_stats_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_stats_reply_handler, type32, OFPST_DESC );
+  expect_value( mock_stats_reply_handler, flags32, ( uint32_t ) flags );
+  expect_value( mock_stats_reply_handler, data->length, body_len );
+  expect_memory( mock_stats_reply_handler, data->data, stats_reply->body, body_len );
+  expect_memory( mock_stats_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_stats_reply_handler( mock_stats_reply_handler, USER_DATA );
+  handle_stats_reply( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_stats_reply_if_type_is_OFPST_FLOW() {
+  void *expected_data;
+  uint16_t flags = OFPSF_REPLY_MORE;
+  uint16_t stats_len;
+  uint32_t body_len;
+  buffer *buffer;
+  list_element *flow_stats;
+  struct ofp_stats_reply *stats_reply;
+  struct ofp_flow_stats *stats[ 2 ];
+  struct ofp_action_output *action;
+
+  stats_len = offsetof( struct ofp_flow_stats, actions ) + sizeof( struct ofp_action_output );
+
+  stats[ 0 ] = xcalloc( 1, stats_len );
+  stats[ 1 ] = xcalloc( 1, stats_len );
+
+  stats[ 0 ]->length = stats_len;
+  stats[ 0 ]->table_id = 1;
+  stats[ 0 ]->pad = 0;
+  stats[ 0 ]->match = MATCH;
+  stats[ 0 ]->duration_sec = 60;
+  stats[ 0 ]->duration_nsec = 10000;
+  stats[ 0 ]->priority = 1024;
+  stats[ 0 ]->idle_timeout = 60;
+  stats[ 0 ]->hard_timeout = 3600;
+  stats[ 0 ]->cookie = 0x0102030405060708ULL;
+  stats[ 0 ]->packet_count = 1000;
+  stats[ 0 ]->byte_count = 100000;
+  action = ( struct ofp_action_output * ) stats[ 0 ]->actions;
+  action->type = OFPAT_OUTPUT;
+  action->len = 8;
+  action->port = 1;
+  action->max_len = 2048;
+
+  memcpy( stats[ 1 ], stats[ 0 ], stats_len );
+  stats[ 1 ]->cookie = 0x0203040506070809ULL;
+  action = ( struct ofp_action_output * ) stats[ 1 ]->actions;
+  action->port = 2;
+
+  create_list( &flow_stats );
+  append_to_tail( &flow_stats, stats[ 0 ] );
+  append_to_tail( &flow_stats, stats[ 1 ] );
+
+  expected_data = xcalloc( 1, ( size_t ) ( stats_len * 2 ) );
+  memcpy( expected_data, stats[ 0 ], stats_len );
+  memcpy( ( char * ) expected_data + stats_len, stats[ 1 ], stats_len );
+
+  buffer = create_flow_stats_reply( TRANSACTION_ID, flags, flow_stats );
+
+  stats_reply = buffer->data;
+  body_len = ( uint32_t ) ( ntohs( stats_reply->header.length ) -
+                            offsetof( struct ofp_stats_reply, body ) );
+
+  expect_memory( mock_stats_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_stats_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_stats_reply_handler, type32, OFPST_FLOW );
+  expect_value( mock_stats_reply_handler, flags32, ( uint32_t ) flags );
+  expect_value( mock_stats_reply_handler, data->length, body_len );
+  expect_memory( mock_stats_reply_handler, data->data, expected_data, stats_len );
+  expect_memory( mock_stats_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_stats_reply_handler( mock_stats_reply_handler, USER_DATA );
+  handle_stats_reply( DATAPATH_ID, buffer );
+
+  xfree( stats[ 0 ] );
+  xfree( stats[ 1 ] );
+  delete_list( flow_stats );
+  xfree( expected_data );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_stats_reply_if_type_is_OFPST_AGGREGATE() {
+  uint16_t flags = 0;
+  uint32_t body_len;
+  uint32_t flow_count = 1000;
+  uint64_t packet_count = 1000;
+  uint64_t byte_count = 10000;
+  buffer *buffer;
+  struct ofp_stats_reply *stats_reply;
+  struct ofp_aggregate_stats_reply aggregate_stats_reply;
+
+  buffer = create_aggregate_stats_reply( TRANSACTION_ID, flags, packet_count,
+                                         byte_count, flow_count );
+
+  stats_reply = buffer->data;
+  body_len = ( uint32_t ) ( ntohs( stats_reply->header.length ) -
+                            offsetof( struct ofp_stats_reply, body ) );
+
+  expect_memory( mock_stats_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_stats_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_stats_reply_handler, type32, OFPST_AGGREGATE );
+  expect_value( mock_stats_reply_handler, flags32, ( uint32_t ) flags );
+  expect_value( mock_stats_reply_handler, data->length, body_len );
+  ntoh_aggregate_stats( &aggregate_stats_reply,
+                        ( struct ofp_aggregate_stats_reply * ) stats_reply->body );
+  expect_memory( mock_stats_reply_handler, data->data, &aggregate_stats_reply, body_len );
+  expect_memory( mock_stats_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_stats_reply_handler( mock_stats_reply_handler, USER_DATA );
+  handle_stats_reply( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_stats_reply_if_type_is_OFPST_TABLE() {
+  void *expected_data;
+  uint16_t flags = OFPSF_REPLY_MORE;
+  uint16_t stats_len;
+  uint32_t body_len;
+  buffer *buffer;
+  list_element *table_stats;
+  struct ofp_stats_reply *stats_reply;
+  struct ofp_table_stats *stats[ 2 ];
+
+  stats_len = sizeof( struct ofp_table_stats );
+
+  stats[ 0 ] = xcalloc( 1, stats_len );
+  stats[ 1 ] = xcalloc( 1, stats_len );
+
+  stats[ 0 ]->table_id = 1;
+  sprintf( stats[ 0 ]->name, "Table 1" );
+  stats[ 0 ]->wildcards =  OFPFW_ALL;
+  stats[ 0 ]->max_entries = 10000;
+  stats[ 0 ]->active_count = 1000;
+  stats[ 0 ]->lookup_count = 100000;
+  stats[ 0 ]->matched_count = 10000;
+
+  memcpy( stats[ 1 ], stats[ 0 ], stats_len );
+  stats[ 1 ]->table_id = 2;
+  sprintf( stats[ 1 ]->name, "Table 2" );
+
+  create_list( &table_stats );
+  append_to_tail( &table_stats, stats[ 0 ] );
+  append_to_tail( &table_stats, stats[ 1 ] );
+
+  expected_data = xcalloc( 1, ( size_t ) ( stats_len * 2 ) );
+  memcpy( expected_data, stats[ 0 ], stats_len );
+  memcpy( ( char * ) expected_data + stats_len, stats[ 1 ], stats_len );
+
+  buffer = create_table_stats_reply( TRANSACTION_ID, flags, table_stats );
+
+  stats_reply = buffer->data;
+  body_len = ( uint32_t ) ( ntohs( stats_reply->header.length ) -
+                            offsetof( struct ofp_stats_reply, body ) );
+
+  expect_memory( mock_stats_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_stats_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_stats_reply_handler, type32, OFPST_TABLE );
+  expect_value( mock_stats_reply_handler, flags32, ( uint32_t ) flags );
+  expect_value( mock_stats_reply_handler, data->length, body_len );
+  expect_memory( mock_stats_reply_handler, data->data, expected_data, stats_len );
+  expect_memory( mock_stats_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_stats_reply_handler( mock_stats_reply_handler, USER_DATA );
+  handle_stats_reply( DATAPATH_ID, buffer );
+
+  xfree( stats[ 0 ] );
+  xfree( stats[ 1 ] );
+  delete_list( table_stats );
+  xfree( expected_data );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_stats_reply_if_type_is_OFPST_PORT() {
+  void *expected_data;
+  uint16_t flags = OFPSF_REPLY_MORE;
+  uint16_t stats_len;
+  uint32_t body_len;
+  buffer *buffer;
+  list_element *port_stats;
+  struct ofp_stats_reply *stats_reply;
+  struct ofp_port_stats *stats[ 2 ];
+
+  stats_len = sizeof( struct ofp_port_stats );
+
+  stats[ 0 ] = xcalloc( 1, stats_len );
+  stats[ 1 ] = xcalloc( 1, stats_len );
+
+  stats[ 0 ]->port_no = 1;
+  stats[ 0 ]->rx_packets = 10000;
+  stats[ 0 ]->tx_packets = 20000;
+  stats[ 0 ]->rx_bytes = 30000;
+  stats[ 0 ]->tx_bytes = 40000;
+  stats[ 0 ]->rx_dropped = 50000;
+  stats[ 0 ]->tx_dropped = 60000;
+  stats[ 0 ]->rx_errors = 70000;
+  stats[ 0 ]->tx_errors = 80000;
+  stats[ 0 ]->rx_frame_err = 1;
+  stats[ 0 ]->rx_over_err = 2;
+  stats[ 0 ]->rx_crc_err = 1;
+  stats[ 0 ]->collisions = 3;
+
+  memcpy( stats[ 1 ], stats[ 0 ], stats_len );
+  stats[ 1 ]->port_no = 2;
+
+  create_list( &port_stats );
+  append_to_tail( &port_stats, stats[ 0 ] );
+  append_to_tail( &port_stats, stats[ 1 ] );
+
+  expected_data = xcalloc( 1, ( size_t ) ( stats_len * 2 ) );
+  memcpy( expected_data, stats[ 0 ], stats_len );
+  memcpy( ( char * ) expected_data + stats_len, stats[ 1 ], stats_len );
+
+  buffer = create_port_stats_reply( TRANSACTION_ID, flags, port_stats );
+
+  stats_reply = buffer->data;
+  body_len = ( uint32_t ) ( ntohs( stats_reply->header.length ) -
+                            offsetof( struct ofp_stats_reply, body ) );
+
+  expect_memory( mock_stats_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_stats_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_stats_reply_handler, type32, OFPST_PORT );
+  expect_value( mock_stats_reply_handler, flags32, ( uint32_t ) flags );
+  expect_value( mock_stats_reply_handler, data->length, body_len );
+  expect_memory( mock_stats_reply_handler, data->data, expected_data, stats_len );
+  expect_memory( mock_stats_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_stats_reply_handler( mock_stats_reply_handler, USER_DATA );
+  handle_stats_reply( DATAPATH_ID, buffer );
+
+  xfree( stats[ 0 ] );
+  xfree( stats[ 1 ] );
+  delete_list( port_stats );
+  xfree( expected_data );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_stats_reply_if_type_is_OFPST_QUEUE() {
+  void *expected_data;
+  uint16_t flags = OFPSF_REPLY_MORE;
+  uint16_t stats_len;
+  uint32_t body_len;
+  buffer *buffer;
+  list_element *queue_stats;
+  struct ofp_stats_reply *stats_reply;
+  struct ofp_queue_stats *stats[ 2 ];
+
+  stats_len = sizeof( struct ofp_queue_stats );
+
+  stats[ 0 ] = xcalloc( 1, stats_len );
+  stats[ 1 ] = xcalloc( 1, stats_len );
+
+  stats[ 0 ]->port_no = 1;
+  stats[ 0 ]->queue_id = 2;
+  stats[ 0 ]->tx_bytes = 100000;
+  stats[ 0 ]->tx_packets = 60000;
+  stats[ 0 ]->tx_errors = 80;
+
+  memcpy( stats[ 1 ], stats[ 0 ], stats_len );
+  stats[ 1 ]->queue_id = 3;
+
+  create_list( &queue_stats );
+  append_to_tail( &queue_stats, stats[ 0 ] );
+  append_to_tail( &queue_stats, stats[ 1 ] );
+
+  expected_data = xcalloc( 1, ( size_t ) ( stats_len * 2 ) );
+  memcpy( expected_data, stats[ 0 ], stats_len );
+  memcpy( ( char * ) expected_data + stats_len, stats[ 1 ], stats_len );
+
+  buffer = create_queue_stats_reply( TRANSACTION_ID, flags, queue_stats );
+
+  stats_reply = buffer->data;
+  body_len = ( uint32_t ) ( ntohs( stats_reply->header.length ) -
+                            offsetof( struct ofp_stats_reply, body ) );
+
+  expect_memory( mock_stats_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_stats_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_stats_reply_handler, type32, OFPST_QUEUE );
+  expect_value( mock_stats_reply_handler, flags32, ( uint32_t ) flags );
+  expect_value( mock_stats_reply_handler, data->length, body_len );
+  expect_memory( mock_stats_reply_handler, data->data, expected_data, stats_len );
+  expect_memory( mock_stats_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_stats_reply_handler( mock_stats_reply_handler, USER_DATA );
+  handle_stats_reply( DATAPATH_ID, buffer );
+
+  xfree( stats[ 0 ] );
+  xfree( stats[ 1 ] );
+  delete_list( queue_stats );
+  xfree( expected_data );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_stats_reply_if_type_is_OFPST_VENDOR() {
+  void *expected_data;
+  uint16_t flags = 0;
+  uint32_t body_len;
+  uint32_t vendor = VENDOR_ID;
+  buffer *buffer, *body;
+  struct ofp_stats_reply *stats_reply;
+
+  body = alloc_buffer_with_length( 128 );
+  append_back_buffer( body, 128 );
+  memset( body->data, 0xa1, body->length );
+
+  expected_data = xcalloc( 1, ( size_t ) ( body->length + sizeof( uint32_t ) ) );
+  memcpy( expected_data, &vendor, sizeof( uint32_t ) );
+  memcpy( ( char * ) expected_data + sizeof( uint32_t ), body->data, body->length );
+
+  buffer = create_vendor_stats_reply( TRANSACTION_ID, flags, vendor, body );
+
+  stats_reply = buffer->data;
+  body_len = ( uint32_t ) ( ntohs( stats_reply->header.length ) -
+                            offsetof( struct ofp_stats_reply, body ) );
+
+  expect_memory( mock_stats_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_stats_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_stats_reply_handler, type32, OFPST_VENDOR );
+  expect_value( mock_stats_reply_handler, flags32, ( uint32_t ) flags );
+  expect_value( mock_stats_reply_handler, data->length, body_len );
+  expect_memory( mock_stats_reply_handler, data->data, expected_data, body_len );
+  expect_memory( mock_stats_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_stats_reply_handler( mock_stats_reply_handler, USER_DATA );
+  handle_stats_reply( DATAPATH_ID, buffer );
+
+  xfree( expected_data );
+  free_buffer( body );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_stats_reply_with_undefined_type() {
+  uint16_t flags = 0;
+  uint32_t vendor = VENDOR_ID;
+  buffer *buffer;
+  struct ofp_stats_reply *stats_reply;
+
+  buffer = create_vendor_stats_reply( TRANSACTION_ID, flags, vendor, NULL );
+
+  stats_reply = buffer->data;
+  stats_reply->type = htons( 0xfffe );
+
+  set_stats_reply_handler( mock_stats_reply_handler, USER_DATA );
+  expect_assert_failure( handle_stats_reply( DATAPATH_ID, buffer ) );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_stats_reply_if_handler_is_not_registered() {
+  char mfr_desc[ DESC_STR_LEN ];
+  char hw_desc[ DESC_STR_LEN ];
+  char sw_desc[ DESC_STR_LEN ];
+  char serial_num[ SERIAL_NUM_LEN ];
+  char dp_desc[ DESC_STR_LEN ];
+  uint16_t flags = 0;
+  buffer *buffer;
+
+  memset( mfr_desc, '\0', DESC_STR_LEN );
+  memset( hw_desc, '\0', DESC_STR_LEN );
+  memset( sw_desc, '\0', DESC_STR_LEN );
+  memset( serial_num, '\0', SERIAL_NUM_LEN );
+  memset( dp_desc, '\0', DESC_STR_LEN );
+  sprintf( mfr_desc, "NEC Coporation" );
+  sprintf( hw_desc, "OpenFlow Switch Hardware" );
+  sprintf( sw_desc, "OpenFlow Switch Software" );
+  sprintf( serial_num, "123456" );
+  sprintf( dp_desc, "Datapath 0" );
+
+  buffer = create_desc_stats_reply( TRANSACTION_ID, flags, mfr_desc, hw_desc,
+                                    sw_desc, serial_num, dp_desc );
+
+  // FIXME
+  handle_stats_reply( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_stats_reply_if_message_is_NULL() {
+  set_stats_reply_handler( mock_stats_reply_handler, USER_DATA );
+  expect_assert_failure( handle_stats_reply( DATAPATH_ID, NULL ) );
+}
+
+
+static void
+test_handle_stats_reply_if_message_length_is_zero() {
+  buffer *buffer;
+
+  buffer = alloc_buffer_with_length( 32 );
+
+  set_stats_reply_handler( mock_stats_reply_handler, USER_DATA );
+  expect_assert_failure( handle_stats_reply( DATAPATH_ID, buffer ) );
+
+  free_buffer( buffer );
+}
+
+
+/********************************************************************************
+ * handle_barrier_reply() tests.
+ ********************************************************************************/
+
+static void
+test_handle_barrier_reply() {
+  buffer *buffer;
+
+  buffer = create_barrier_reply( TRANSACTION_ID );
+
+  expect_memory( mock_barrier_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_barrier_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_memory( mock_barrier_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_barrier_reply_handler( mock_barrier_reply_handler, USER_DATA );
+  handle_barrier_reply( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_barrier_reply_if_handler_is_not_registered() {
+  buffer *buffer;
+
+  buffer = create_barrier_reply( TRANSACTION_ID );
+
+  // FIXME
+  handle_barrier_reply( DATAPATH_ID, buffer );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_barrier_reply_if_message_is_NULL() {
+  set_barrier_reply_handler( mock_barrier_reply_handler, USER_DATA );
+  expect_assert_failure( handle_barrier_reply( DATAPATH_ID, NULL ) );
+}
+
+
+static void
+test_handle_barrier_reply_if_message_length_is_zero() {
+  buffer *buffer;
+
+  buffer = alloc_buffer_with_length( 32 );
+
+  set_barrier_reply_handler( mock_barrier_reply_handler, USER_DATA );
+  expect_assert_failure( handle_barrier_reply( DATAPATH_ID, buffer ) );
+
+  free_buffer( buffer );
+}
+
+
+/********************************************************************************
+ * handle_queue_get_config_reply() tests.
+ ********************************************************************************/
+
+static void
+test_handle_queue_get_config_reply() {
+  size_t queue_len;
+  uint16_t port = 1;
+  list_element *queues;
+  buffer *buffer;
+  struct ofp_packet_queue *queue[ 2 ];
+  struct ofp_queue_prop_header *prop_header;
+
+  queue_len = offsetof( struct ofp_packet_queue, properties ) + sizeof( struct ofp_queue_prop_header );
+  queue[ 0 ] = xcalloc( 1, queue_len );
+  queue[ 1 ] = xcalloc( 1, queue_len );
+
+  queue[ 0 ]->queue_id = 1;
+  queue[ 0 ]->len = 16;
+  prop_header = queue[ 0 ]->properties;
+  prop_header->property = OFPQT_NONE;
+  prop_header->len = 8;
+
+  queue[ 1 ]->queue_id = 2;
+  queue[ 1 ]->len = 16;
+  prop_header = queue[ 1 ]->properties;
+  prop_header->property = OFPQT_NONE;
+  prop_header->len = 8;
+
+  create_list( &queues );
+  append_to_tail( &queues, queue[ 0 ] );
+  append_to_tail( &queues, queue[ 1 ] );
+
+  buffer = create_queue_get_config_reply( TRANSACTION_ID, port, queues );
+
+  expect_memory( mock_queue_get_config_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_queue_get_config_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_queue_get_config_reply_handler, port32, ( uint32_t ) port );
+  expect_memory( mock_queue_get_config_reply_handler, queue1, queue[ 0 ], queue_len );
+  expect_memory( mock_queue_get_config_reply_handler, queue2, queue[ 1 ], queue_len );
+  expect_memory( mock_queue_get_config_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+  set_queue_get_config_reply_handler( mock_queue_get_config_reply_handler, USER_DATA );
+  handle_queue_get_config_reply( DATAPATH_ID, buffer );
+
+  xfree( queue[ 0 ] );
+  xfree( queue[ 1 ] );
+  delete_list( queues );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_queue_get_config_reply_without_queues() {
+  uint16_t port = 1;
+  buffer *buffer;
+
+  buffer = create_queue_get_config_reply( TRANSACTION_ID, port, NULL );
+
+  set_queue_get_config_reply_handler( mock_queue_get_config_reply_handler, USER_DATA );
+  expect_assert_failure( handle_queue_get_config_reply( DATAPATH_ID, buffer ) );
+
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_queue_get_config_reply_if_handler_is_not_registered() {
+  size_t queue_len;
+  uint16_t port = 1;
+  list_element *queues;
+  buffer *buffer;
+  struct ofp_packet_queue *queue[ 2 ];
+  struct ofp_queue_prop_header *prop_header;
+
+  queue_len = offsetof( struct ofp_packet_queue, properties ) + sizeof( struct ofp_queue_prop_header );
+  queue[ 0 ] = xcalloc( 1, queue_len );
+  queue[ 1 ] = xcalloc( 1, queue_len );
+
+  queue[ 0 ]->queue_id = 1;
+  queue[ 0 ]->len = 16;
+  prop_header = queue[ 0 ]->properties;
+  prop_header->property = OFPQT_NONE;
+  prop_header->len = 8;
+
+  queue[ 1 ]->queue_id = 2;
+  queue[ 1 ]->len = 16;
+  prop_header = queue[ 1 ]->properties;
+  prop_header->property = OFPQT_NONE;
+  prop_header->len = 8;
+
+  create_list( &queues );
+  append_to_tail( &queues, queue[ 0 ] );
+  append_to_tail( &queues, queue[ 1 ] );
+
+  buffer = create_queue_get_config_reply( TRANSACTION_ID, port, queues );
+
+  // FIXME
+  handle_queue_get_config_reply( DATAPATH_ID, buffer );
+
+  xfree( queue[ 0 ] );
+  xfree( queue[ 1 ] );
+  delete_list( queues );
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_queue_get_config_reply_if_message_is_NULL() {
+  set_queue_get_config_reply_handler( mock_queue_get_config_reply_handler, USER_DATA );
+  expect_assert_failure( handle_queue_get_config_reply( DATAPATH_ID, NULL ) );
+}
+
+
+static void
+test_handle_queue_get_config_reply_if_message_length_is_zero() {
+  buffer *buffer;
+
+  buffer = alloc_buffer_with_length( 32 );
+
+  set_queue_get_config_reply_handler( mock_queue_get_config_reply_handler, USER_DATA );
+  expect_assert_failure( handle_queue_get_config_reply( DATAPATH_ID, buffer ) );
+
+  free_buffer( buffer );
+}
+
+
+/********************************************************************************
+ * handle_list_switches_reply() tests.
+ ********************************************************************************/
+
+static void
+test_insert_dpid() {
+  list_element *head;
+  create_list( &head );
+  uint64_t alice = 0x1;
+  uint64_t bob = 0x2;
+  uint64_t carol = 0x3;
+
+  insert_dpid( &head, &carol );
+  insert_dpid( &head, &alice );
+  insert_dpid( &head, &bob );
+
+  list_element *element = head;
+  assert_true( element != NULL );
+  assert_true( element->data != NULL );
+  assert_true( alice == *( uint64_t * ) element->data );
+
+  element = element->next;
+  assert_true( element != NULL );
+  assert_true( element->data != NULL );
+  assert_true( bob == *( uint64_t * ) element->data );
+
+  element = element->next;
+  assert_true( element != NULL );
+  assert_true( element->data != NULL );
+  assert_true( carol == *( uint64_t * ) element->data );
+
+  element = element->next;
+  assert_true( element == NULL );
+
+  delete_list( head );
+}
+
+
+static void
+test_insert_dpid_if_head_is_NULL() {
+  uint64_t dpid = 0x1;
+
+  expect_assert_failure( insert_dpid( NULL, &dpid ) );
+}
+
+
+static void
+test_insert_dpid_if_dpid_is_NULL() {
+  list_element *head;
+  create_list( &head );
+
+  expect_assert_failure( insert_dpid( &head, NULL ) );
+
+  delete_list( head );
+}
+
+
+static void
+test_handle_list_switches_reply() {
+  uint16_t message_type = 0;
+  uint64_t alice = 0x1;
+  uint64_t bob = 0x2;
+  uint64_t carol = 0x3;
+  uint64_t dpid[] = { htonll( bob ), htonll( carol ), htonll( alice ) };
+  size_t length = sizeof( dpid );
+  void *user_data = LIST_SWITCHES_REPLY_USER_DATA;
+
+  expect_value( mock_handle_list_switches_reply, *dpid1, alice );
+  expect_value( mock_handle_list_switches_reply, *dpid2, bob );
+  expect_value( mock_handle_list_switches_reply, *dpid3, carol );
+  expect_value( mock_handle_list_switches_reply, user_data, LIST_SWITCHES_REPLY_USER_DATA );
+
+  set_list_switches_reply_handler( mock_handle_list_switches_reply );
+  handle_list_switches_reply( message_type, dpid, length, user_data );
+}
+
+
+static void
+test_handle_list_switches_reply_if_data_is_NULL() {
+  uint16_t message_type = 0;
+  size_t length = 64;
+  void *user_data = LIST_SWITCHES_REPLY_USER_DATA;
+
+  set_list_switches_reply_handler( mock_handle_list_switches_reply );
+  expect_assert_failure( handle_list_switches_reply( message_type, NULL, length, user_data ) );
+}
+
+
+static void
+test_handle_list_switches_reply_if_length_is_zero() {
+  uint16_t message_type = 0;
+  uint64_t dpid[] = { 0 };
+  void *user_data = LIST_SWITCHES_REPLY_USER_DATA;
+
+  expect_value( mock_handle_list_switches_reply, user_data, LIST_SWITCHES_REPLY_USER_DATA );
+
+  set_list_switches_reply_handler( mock_handle_list_switches_reply );
+  handle_list_switches_reply( message_type, dpid, 0, user_data );
+}
+
+
+/********************************************************************************
+ * handle_switch_events() tests.
+ ********************************************************************************/
+
+static void
+test_handle_switch_events_if_type_is_MESSENGER_OPENFLOW_CONNECTED() {
+  buffer *data = alloc_buffer_with_length( sizeof( openflow_service_header_t ) );
+  append_back_buffer( data, sizeof( openflow_service_header_t ) );
+
+  handle_switch_events( MESSENGER_OPENFLOW_CONNECTED, data->data, data->length );
+
+  stat_entry *stat = lookup_hash_entry( stats, "openflow_application_interface.switch_connected_receive_succeeded" );
+  assert_int_equal( ( int ) stat->value, 1 );
+
+  free_buffer( data );
+  xfree( delete_hash_entry( stats, "openflow_application_interface.switch_connected_receive_succeeded" ) );
+}
+
+
+static void
+test_handle_switch_events_if_type_is_MESSENGER_OPENFLOW_DISCONNECTED() {
+  uint64_t *datapath_id;
+  buffer *data;
+
+  data = alloc_buffer_with_length( sizeof( openflow_service_header_t ) );
+  datapath_id = append_back_buffer( data, sizeof( openflow_service_header_t ) );
+
+  *datapath_id = htonll( DATAPATH_ID );
+
+  expect_memory( mock_switch_disconnected_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_switch_disconnected_handler, user_data, SWITCH_DISCONNECTED_USER_DATA );
+
+  set_switch_disconnected_handler( mock_switch_disconnected_handler, SWITCH_DISCONNECTED_USER_DATA );
+  handle_switch_events( MESSENGER_OPENFLOW_DISCONNECTED, data->data, data->length );
+
+  stat_entry *stat = lookup_hash_entry( stats, "openflow_application_interface.switch_disconnected_receive_succeeded" );
+  assert_int_equal( ( int ) stat->value, 1 );
+
+  free_buffer( data );
+  xfree( delete_hash_entry( stats, "openflow_application_interface.switch_disconnected_receive_succeeded" ) );
+}
+
+
+static void
+test_handle_switch_events_if_message_is_NULL() {
+  expect_assert_failure( handle_switch_events( MESSENGER_OPENFLOW_READY, NULL, 1 ) );
+}
+
+
+static void
+test_handle_switch_events_if_message_length_is_zero() {
+  buffer *data;
+
+  data = alloc_buffer_with_length( sizeof( openflow_service_header_t ) );
+
+  expect_assert_failure( handle_switch_events( MESSENGER_OPENFLOW_READY, data->data, 0 ) );
+
+  free_buffer( data );
+}
+
+
+static void
+test_handle_switch_events_if_message_length_is_too_big() {
+  buffer *data;
+
+  data = alloc_buffer_with_length( sizeof( openflow_service_header_t ) );
+
+  expect_assert_failure( handle_switch_events( MESSENGER_OPENFLOW_READY, data->data,
+                                               data->length + 1 ) );
+
+  free_buffer( data );
+}
+
+
+static void
+test_handle_switch_events_if_unhandled_message_type() {
+  buffer *data;
+
+  data = alloc_buffer_with_length( sizeof( openflow_service_header_t ) );
+  append_back_buffer( data, sizeof( openflow_service_header_t ) );
+
+  // FIXME
+  handle_switch_events( MESSENGER_OPENFLOW_MESSAGE, data->data, data->length );
+
+  stat_entry *stat = lookup_hash_entry( stats, "openflow_application_interface.undefined_switch_event_receive_succeeded" );
+  assert_int_equal( ( int ) stat->value, 1 );
+
+  free_buffer( data );
+  xfree( delete_hash_entry( stats, "openflow_application_interface.undefined_switch_event_receive_succeeded" ) );
+}
+
+
+/********************************************************************************
+ * handle_openflow_message() tests.
+ ********************************************************************************/
+
+static void
+test_handle_openflow_message() {
+  openflow_service_header_t messenger_header;
+  stat_entry *stat;
+
+  messenger_header.datapath_id = htonll( DATAPATH_ID );
+  messenger_header.service_name_length = 0;
+
+  // error
+  {
+    buffer *buffer, *data;
+
+    data = alloc_buffer_with_length( 16 );
+    append_back_buffer( data, 16 );
+    memset( data->data, 'a', 16 );
+    
+    buffer = create_error( TRANSACTION_ID, OFPET_HELLO_FAILED, OFPHFC_INCOMPATIBLE, data );
+    append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
+    memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
+    expect_memory( mock_error_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+    expect_value( mock_error_handler, transaction_id, TRANSACTION_ID );
+    expect_value( mock_error_handler, type32, OFPET_HELLO_FAILED );
+    expect_value( mock_error_handler, code32, OFPHFC_INCOMPATIBLE );
+    expect_value( mock_error_handler, data->length, data->length );
+    expect_memory( mock_error_handler, data->data, data->data, data->length );
+    expect_memory( mock_error_handler, user_data, USER_DATA, USER_DATA_LEN );
+    
+    set_error_handler( mock_error_handler, USER_DATA );
+    handle_openflow_message( buffer->data, buffer->length );
+
+    stat = lookup_hash_entry( stats, "openflow_application_interface.error_receive_succeeded" );
+    assert_int_equal( ( int ) stat->value, 1 );
+
+    free_buffer( data );
+    free_buffer( buffer );
+    xfree( delete_hash_entry( stats, "openflow_application_interface.error_receive_succeeded" ) );
+  }
+
+  // vendor
+  {
+    buffer *buffer, *data;
+
+    data = alloc_buffer_with_length( 16 );
+    append_back_buffer( data, 16 );
+    memset( data->data, 'a', 16 );
+
+    buffer = create_vendor( TRANSACTION_ID, VENDOR_ID, data );
+    append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
+    memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
+
+    expect_memory( mock_vendor_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+    expect_value( mock_vendor_handler, transaction_id, TRANSACTION_ID );
+    expect_value( mock_vendor_handler, vendor, VENDOR_ID );
+    expect_value( mock_vendor_handler, data->length, data->length );
+    expect_memory( mock_vendor_handler, data->data, data->data, data->length );
+    expect_memory( mock_vendor_handler, user_data, USER_DATA, USER_DATA_LEN );
+    
+    set_vendor_handler( mock_vendor_handler, USER_DATA );
+    handle_openflow_message( buffer->data, buffer->length );
+
+    stat = lookup_hash_entry( stats, "openflow_application_interface.vendor_receive_succeeded" );
+    assert_int_equal( ( int ) stat->value, 1 );
+
+    free_buffer( data );
+    free_buffer( buffer );
+    xfree( delete_hash_entry( stats, "openflow_application_interface.vendor_receive_succeeded" ) );
+  }
+
+  // features_reply
+  {
+    uint8_t n_tables = 2;
+    uint32_t n_buffers = 1024;
+    uint32_t capabilities;
+    uint32_t actions;
+    struct ofp_phy_port *phy_port[ 2 ];
+    buffer *buffer;
+    list_element *ports;
+
+    capabilities = ( OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS |
+                     OFPC_QUEUE_STATS | OFPC_ARP_MATCH_IP );
+    actions = ( ( 1 << OFPAT_OUTPUT ) | ( 1 << OFPAT_SET_VLAN_VID ) |
+                ( 1 << OFPAT_SET_TP_SRC ) | ( 1 << OFPAT_SET_TP_DST ) );
+
+    phy_port[ 0 ] = xcalloc( 1, sizeof( struct ofp_phy_port ) );
+    phy_port[ 1 ] = xcalloc( 1, sizeof( struct ofp_phy_port ) );
+
+    phy_port[ 0 ]->port_no = 1;
+    memcpy( phy_port[ 0 ]->hw_addr, MAC_ADDR_X, sizeof( phy_port[ 0 ]->hw_addr ) );
+    memset( phy_port[ 0 ]->name, '\0', OFP_MAX_PORT_NAME_LEN );
+    memcpy( phy_port[ 0 ]->name, PORT_NAME, strlen( PORT_NAME ) );
+    phy_port[ 0 ]->config = OFPPC_PORT_DOWN;
+    phy_port[ 0 ]->state = OFPPS_LINK_DOWN;
+    phy_port[ 0 ]->curr = ( OFPPF_1GB_FD | OFPPF_COPPER | OFPPF_PAUSE );
+    phy_port[ 0 ]->advertised = PORT_FEATURES;
+    phy_port[ 0 ]->supported = PORT_FEATURES;
+    phy_port[ 0 ]->peer = PORT_FEATURES;
+
+    memcpy( phy_port[ 1 ], phy_port [ 0 ], sizeof( struct ofp_phy_port ) );
+
+    phy_port[ 1 ]->port_no = 2;
+    memcpy( phy_port[ 1 ]->hw_addr, MAC_ADDR_Y, sizeof( phy_port[ 1 ]->hw_addr ) );
+
+    create_list( &ports );
+    append_to_tail( &ports, phy_port[ 0 ] );
+    append_to_tail( &ports, phy_port[ 1 ] );
+
+    buffer = create_features_reply( TRANSACTION_ID, DATAPATH_ID, n_buffers, n_tables,
+                                    capabilities, actions, ports );
+    append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
+    memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
+
+    expect_memory( mock_features_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+    expect_value( mock_features_reply_handler, transaction_id, TRANSACTION_ID );
+    expect_value( mock_features_reply_handler, n_buffers, n_buffers );
+    expect_value( mock_features_reply_handler, n_tables32, ( uint32_t ) n_tables );
+    expect_value( mock_features_reply_handler, capabilities, capabilities );
+    expect_value( mock_features_reply_handler, actions, actions );
+    expect_memory( mock_features_reply_handler, port1, ports->data, sizeof( struct ofp_phy_port ) );
+    expect_memory( mock_features_reply_handler, port2, ports->next->data, sizeof( struct ofp_phy_port ) );
+    expect_memory( mock_features_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+    set_features_reply_handler( mock_features_reply_handler, USER_DATA );
+    handle_openflow_message( buffer->data, buffer->length );
+
+    stat = lookup_hash_entry( stats, "openflow_application_interface.features_reply_receive_succeeded" );
+    assert_int_equal( ( int ) stat->value, 1 );
+
+    xfree( phy_port[0] );
+    xfree( phy_port[1] );
+    delete_list( ports );
+    free_buffer( buffer );
+    xfree( delete_hash_entry( stats, "openflow_application_interface.features_reply_receive_succeeded" ) );
+  }
+
+  // get_config_reply
+  {
+    uint16_t flags = OFPC_FRAG_NORMAL;
+    uint16_t miss_send_len = 128;
+    buffer *buffer;
+
+    buffer = create_get_config_reply( TRANSACTION_ID, flags, miss_send_len );
+    append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
+    memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
+
+    expect_memory( mock_get_config_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+    expect_value( mock_get_config_reply_handler, transaction_id, TRANSACTION_ID );
+    expect_value( mock_get_config_reply_handler, flags32, ( uint32_t ) flags );
+    expect_value( mock_get_config_reply_handler, miss_send_len32, ( uint32_t ) miss_send_len );
+    expect_memory( mock_get_config_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+    set_get_config_reply_handler( mock_get_config_reply_handler, USER_DATA );
+    handle_openflow_message( buffer->data, buffer->length );
+
+    stat = lookup_hash_entry( stats, "openflow_application_interface.get_config_reply_receive_succeeded" );
+    assert_int_equal( ( int ) stat->value, 1 );
+
+    free_buffer( buffer );
+    xfree( delete_hash_entry( stats, "openflow_application_interface.get_config_reply_receive_succeeded" ) );
+  }
+
+  // packet_in
+  {
+    uint8_t reason =  OFPR_NO_MATCH;
+    uint16_t total_len;
+    uint16_t in_port = 1;
+    uint32_t buffer_id = 0x01020304;
+    buffer *buffer, *data;
+
+    data = alloc_buffer_with_length( 64 );
+    append_back_buffer( data, 64 );
+    memset( data->data, 0x01, 64 );
+
+    total_len = ( uint16_t ) data->length;
+
+    buffer = create_packet_in( TRANSACTION_ID, buffer_id, total_len, in_port,
+                               reason, data );
+    append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
+    memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
+
+    will_return( mock_parse_packet, true );
+
+    expect_memory( mock_packet_in_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+    expect_value( mock_packet_in_handler, transaction_id, TRANSACTION_ID );
+    expect_value( mock_packet_in_handler, buffer_id, buffer_id );
+    expect_value( mock_packet_in_handler, total_len32, ( uint32_t ) total_len );
+    expect_value( mock_packet_in_handler, in_port32, ( uint32_t ) in_port );
+    expect_value( mock_packet_in_handler, reason32, ( uint32_t ) reason );
+    expect_value( mock_packet_in_handler, data->length, data->length );
+    expect_memory( mock_packet_in_handler, data->data, data->data, data->length );
+    expect_memory( mock_packet_in_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+    set_packet_in_handler( mock_packet_in_handler, USER_DATA );
+    handle_openflow_message( buffer->data, buffer->length );
+
+    stat = lookup_hash_entry( stats, "openflow_application_interface.packet_in_receive_succeeded" );
+    assert_int_equal( ( int ) stat->value, 1 );
+
+    free_buffer( data );
+    free_buffer( buffer );
+    xfree( delete_hash_entry( stats, "openflow_application_interface.packet_in_receive_succeeded" ) );
+  }
+
+  // flow_removed
+  {
+    uint8_t reason =  OFPRR_IDLE_TIMEOUT;
+    uint16_t idle_timeout = 60;
+    uint16_t priority = UINT16_MAX;
+    uint32_t duration_sec = 180;
+    uint32_t duration_nsec = 10000;
+    uint64_t cookie = 0x0102030405060708ULL;
+    uint64_t packet_count = 1000;
+    uint64_t byte_count = 100000;
+    buffer *buffer;
+
+    buffer = create_flow_removed( TRANSACTION_ID, MATCH, cookie, priority,
+                                  reason, duration_sec, duration_nsec,
+                                  idle_timeout, packet_count, byte_count );
+    append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
+    memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
+
+    expect_memory( mock_flow_removed_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+    expect_value( mock_flow_removed_handler, transaction_id, TRANSACTION_ID );
+    expect_memory( mock_flow_removed_handler, &match, &MATCH, sizeof( struct ofp_match ) );
+    expect_memory( mock_flow_removed_handler, &cookie, &cookie, sizeof( uint64_t ) );
+    expect_value( mock_flow_removed_handler, priority32, ( uint32_t ) priority );
+    expect_value( mock_flow_removed_handler, reason32, ( uint32_t ) reason );
+    expect_value( mock_flow_removed_handler, duration_sec, duration_sec );
+    expect_value( mock_flow_removed_handler, duration_nsec, duration_nsec );
+    expect_value( mock_flow_removed_handler, idle_timeout32, ( uint32_t ) idle_timeout );
+    expect_memory( mock_flow_removed_handler, &packet_count, &packet_count, sizeof( uint64_t ) );
+    expect_memory( mock_flow_removed_handler, &byte_count, &byte_count, sizeof( uint64_t ) );
+    expect_memory( mock_flow_removed_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+    set_flow_removed_handler( mock_flow_removed_handler, USER_DATA );
+    handle_openflow_message( buffer->data, buffer->length );
+
+    stat = lookup_hash_entry( stats, "openflow_application_interface.flow_removed_receive_succeeded" );
+    assert_int_equal( ( int ) stat->value, 1 );
+
+    free_buffer( buffer );
+    xfree( delete_hash_entry( stats, "openflow_application_interface.flow_removed_receive_succeeded" ) );
+  }
+
+  // port_status
+  {
+    uint8_t reason = OFPPR_MODIFY;
+    buffer *buffer;
+    struct ofp_phy_port desc;
+
+    desc.port_no = 1;
+    memcpy( desc.hw_addr, MAC_ADDR_X, sizeof( desc.hw_addr ) );
+    memset( desc.name, '\0', OFP_MAX_PORT_NAME_LEN );
+    memcpy( desc.name, PORT_NAME, strlen( PORT_NAME ) );
+    desc.config = OFPPC_PORT_DOWN;
+    desc.state = OFPPS_LINK_DOWN;
+    desc.curr = ( OFPPF_1GB_FD | OFPPF_COPPER | OFPPF_PAUSE );
+    desc.advertised = PORT_FEATURES;
+    desc.supported = PORT_FEATURES;
+    desc.peer = PORT_FEATURES;
+
+    buffer = create_port_status( TRANSACTION_ID, reason, desc );
+    append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
+    memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
+
+    expect_memory( mock_port_status_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+    expect_value( mock_port_status_handler, transaction_id, TRANSACTION_ID );
+    expect_value( mock_port_status_handler, reason32, ( uint32_t ) reason );
+    expect_memory( mock_port_status_handler, &phy_port, &desc, sizeof( struct ofp_phy_port ) );
+    expect_memory( mock_port_status_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+    set_port_status_handler( mock_port_status_handler, USER_DATA );
+    handle_openflow_message( buffer->data, buffer->length );
+
+    stat = lookup_hash_entry( stats, "openflow_application_interface.port_status_receive_succeeded" );
+    assert_int_equal( ( int ) stat->value, 1 );
+
+    free_buffer( buffer );
+    xfree( delete_hash_entry( stats, "openflow_application_interface.port_status_receive_succeeded" ) );
+  }
+
+  // stats_reply
+  {
+    char mfr_desc[ DESC_STR_LEN ];
+    char hw_desc[ DESC_STR_LEN ];
+    char sw_desc[ DESC_STR_LEN ];
+    char serial_num[ SERIAL_NUM_LEN ];
+    char dp_desc[ DESC_STR_LEN ];
+    uint16_t flags = 0;
+    uint32_t body_len;
+    buffer *buffer;
+    struct ofp_stats_reply *stats_reply;
+
+    memset( mfr_desc, '\0', DESC_STR_LEN );
+    memset( hw_desc, '\0', DESC_STR_LEN );
+    memset( sw_desc, '\0', DESC_STR_LEN );
+    memset( serial_num, '\0', SERIAL_NUM_LEN );
+    memset( dp_desc, '\0', DESC_STR_LEN );
+    sprintf( mfr_desc, "NEC Coporation" );
+    sprintf( hw_desc, "OpenFlow Switch Hardware" );
+    sprintf( sw_desc, "OpenFlow Switch Software" );
+    sprintf( serial_num, "123456" );
+    sprintf( dp_desc, "Datapath 0" );
+
+    buffer = create_desc_stats_reply( TRANSACTION_ID, flags, mfr_desc, hw_desc,
+                                      sw_desc, serial_num, dp_desc );
+
+    append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
+    memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
+
+    stats_reply = ( struct ofp_stats_reply * ) ( ( char * ) buffer->data +
+                                                 sizeof( openflow_service_header_t ) );
+    body_len = ( uint32_t ) ( ntohs( stats_reply->header.length ) -
+                              offsetof( struct ofp_stats_reply, body ) );
+
+
+    expect_memory( mock_stats_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+    expect_value( mock_stats_reply_handler, transaction_id, TRANSACTION_ID );
+    expect_value( mock_stats_reply_handler, type32, OFPST_DESC );
+    expect_value( mock_stats_reply_handler, flags32, ( uint32_t ) flags );
+    expect_value( mock_stats_reply_handler, data->length, body_len );
+    expect_memory( mock_stats_reply_handler, data->data, stats_reply->body, body_len );
+    expect_memory( mock_stats_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+    set_stats_reply_handler( mock_stats_reply_handler, USER_DATA );
+    handle_openflow_message( buffer->data, buffer->length );
+
+    stat = lookup_hash_entry( stats, "openflow_application_interface.stats_reply_receive_succeeded" );
+    assert_int_equal( ( int ) stat->value, 1 );
+
+    free_buffer( buffer );
+    xfree( delete_hash_entry( stats, "openflow_application_interface.stats_reply_receive_succeeded" ) );
+  }
+
+  // barrier_reply
+  {
+    buffer *buffer;
+
+    buffer = create_barrier_reply( TRANSACTION_ID );
+    append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
+    memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
+
+    expect_memory( mock_barrier_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+    expect_value( mock_barrier_reply_handler, transaction_id, TRANSACTION_ID );
+    expect_memory( mock_barrier_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+    set_barrier_reply_handler( mock_barrier_reply_handler, USER_DATA );
+    handle_openflow_message( buffer->data, buffer->length );
+
+    stat = lookup_hash_entry( stats, "openflow_application_interface.barrier_reply_receive_succeeded" );
+    assert_int_equal( ( int ) stat->value, 1 );
+
+    free_buffer( buffer );
+    xfree( delete_hash_entry( stats, "openflow_application_interface.barrier_reply_receive_succeeded" ) );
+  }
+
+  // queue_get_config_reply
+  {
+    size_t queue_len;
+    uint16_t port = 1;
+    list_element *queues;
+    buffer *buffer;
+    struct ofp_packet_queue *queue[ 2 ];
+    struct ofp_queue_prop_header *prop_header;
+
+    queue_len = offsetof( struct ofp_packet_queue, properties ) + sizeof( struct ofp_queue_prop_header );
+    queue[ 0 ] = xcalloc( 1, queue_len );
+    queue[ 1 ] = xcalloc( 1, queue_len );
+
+    queue[ 0 ]->queue_id = 1;
+    queue[ 0 ]->len = 16;
+    prop_header = queue[ 0 ]->properties;
+    prop_header->property = OFPQT_NONE;
+    prop_header->len = 8;
+
+    queue[ 1 ]->queue_id = 2;
+    queue[ 1 ]->len = 16;
+    prop_header = queue[ 1 ]->properties;
+    prop_header->property = OFPQT_NONE;
+    prop_header->len = 8;
+
+    create_list( &queues );
+    append_to_tail( &queues, queue[ 0 ] );
+    append_to_tail( &queues, queue[ 1 ] );
+
+    buffer = create_queue_get_config_reply( TRANSACTION_ID, port, queues );
+
+    append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
+    memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
+
+    expect_memory( mock_queue_get_config_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+    expect_value( mock_queue_get_config_reply_handler, transaction_id, TRANSACTION_ID );
+    expect_value( mock_queue_get_config_reply_handler, port32, ( uint32_t ) port );
+    expect_memory( mock_queue_get_config_reply_handler, queue1, queue[ 0 ], queue_len );
+    expect_memory( mock_queue_get_config_reply_handler, queue2, queue[ 1 ], queue_len );
+    expect_memory( mock_queue_get_config_reply_handler, user_data, USER_DATA, USER_DATA_LEN );
+
+    set_queue_get_config_reply_handler( mock_queue_get_config_reply_handler, USER_DATA );
+    handle_openflow_message( buffer->data, buffer->length );
+
+    stat = lookup_hash_entry( stats, "openflow_application_interface.queue_get_config_reply_receive_succeeded" );
+    assert_int_equal( ( int ) stat->value, 1 );
+
+    xfree( queue[ 0 ] );
+    xfree( queue[ 1 ] );
+    delete_list( queues );
+    free_buffer( buffer );
+    xfree( delete_hash_entry( stats, "openflow_application_interface.queue_get_config_reply_receive_succeeded" ) );
+  }
+
+  // unhandled message
+  {
+    buffer *buffer;
+
+    buffer = create_hello( TRANSACTION_ID );
+    struct ofp_header *header = buffer->data;
+    header->type = OFPT_QUEUE_GET_CONFIG_REPLY + 1;
+    append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
+    memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
+
+    // FIXME
+    handle_openflow_message( buffer->data, buffer->length );
+
+    free_buffer( buffer );
+  }
+}
+
+
+static void
+test_handle_openflow_message_with_malformed_message() {
+  buffer *buffer;
+  openflow_service_header_t messenger_header;
+  struct ofp_header *header;
+
+  messenger_header.datapath_id = htonll( DATAPATH_ID );
+  messenger_header.service_name_length = 0;
+
+  buffer = create_hello( TRANSACTION_ID );
+  header = buffer->data;
+  header->length = htons( UINT16_MAX );
+  append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
+  memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
+
+  handle_openflow_message( buffer->data, buffer->length );
+    
+  free_buffer( buffer );
+}
+
+
+static void
+test_handle_openflow_message_if_message_is_NULL() {
+  expect_assert_failure( handle_openflow_message( NULL, 1 ) );
+}
+
+
+static void
+test_handle_openflow_message_if_message_length_is_zero() {
+  buffer *data;
+
+  data = alloc_buffer_with_length( 32 );
+
+  expect_assert_failure( handle_openflow_message( data, 0 ) );
+
+  free_buffer( data );
+}
+
+
+static void
+test_handle_openflow_message_if_unhandled_message_type() {
+  buffer *data;
+
+  data = alloc_buffer_with_length( 32 );
+  append_back_buffer( data, 32 );
+
+  // FIXME
+  handle_openflow_message( data, data->length );
+
+  free_buffer( data );
+}
+
+
+/********************************************************************************
+ * handle_message() tests.
+ ********************************************************************************/
+
+static void
+test_handle_message_if_type_is_MESSENGER_OPENFLOW_MESSAGE() {
+  buffer *data;
+  openflow_service_header_t *header;
+
+  data = create_barrier_reply( TRANSACTION_ID );
+
+  assert_true( data != NULL );
+
+  append_front_buffer( data, sizeof( openflow_service_header_t ) );
+
+  header = data->data;
+  header->datapath_id = htonll( DATAPATH_ID );
+  header->service_name_length = 0;
+
+  expect_memory( mock_barrier_reply_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_barrier_reply_handler, transaction_id, TRANSACTION_ID );
+  expect_value( mock_barrier_reply_handler, user_data, BARRIER_REPLY_USER_DATA );
+
+  set_barrier_reply_handler( mock_barrier_reply_handler, BARRIER_REPLY_USER_DATA );
+  handle_message( MESSENGER_OPENFLOW_MESSAGE, data->data, data->length );
+
+  stat_entry *stat = lookup_hash_entry( stats, "openflow_application_interface.barrier_reply_receive_succeeded" );
+  assert_int_equal( ( int ) stat->value, 1 );
+
+
+  free_buffer( data );
+  xfree( delete_hash_entry( stats, "openflow_application_interface.barrier_reply_receive_succeeded" ) );
+}
+
+
+static void
+test_handle_message_if_type_is_MESSENGER_OPENFLOW_CONNECTED() {
+  buffer *data = alloc_buffer_with_length( sizeof( openflow_service_header_t ) );
+  append_back_buffer( data, sizeof( openflow_service_header_t ) );
+
+  handle_message( MESSENGER_OPENFLOW_CONNECTED, data->data, data->length );
+
+  stat_entry *stat = lookup_hash_entry( stats, "openflow_application_interface.switch_connected_receive_succeeded" );
+  assert_int_equal( ( int ) stat->value, 1 );
+
+  free_buffer( data );
+  xfree( delete_hash_entry( stats, "openflow_application_interface.switch_connected_receive_succeeded" ) );
+}
+
+
+static void
+test_handle_message_if_type_is_MESSENGER_OPENFLOW_DISCONNECTED() {
+  uint64_t *datapath_id;
+  buffer *data;
+
+  data = alloc_buffer_with_length( sizeof( openflow_service_header_t ) );
+  datapath_id = append_back_buffer( data, sizeof( openflow_service_header_t ) );
+
+  *datapath_id = htonll( DATAPATH_ID );
+
+  expect_memory( mock_switch_disconnected_handler, &datapath_id, &DATAPATH_ID, sizeof( uint64_t ) );
+  expect_value( mock_switch_disconnected_handler, user_data, SWITCH_DISCONNECTED_USER_DATA );
+
+  set_switch_disconnected_handler( mock_switch_disconnected_handler, SWITCH_DISCONNECTED_USER_DATA );
+  handle_message( MESSENGER_OPENFLOW_DISCONNECTED, data->data, data->length );
+
+  stat_entry *stat = lookup_hash_entry( stats, "openflow_application_interface.switch_disconnected_receive_succeeded" );
+  assert_int_equal( ( int ) stat->value, 1 );
+
+  free_buffer( data );
+  xfree( delete_hash_entry( stats, "openflow_application_interface.switch_disconnected_receive_succeeded" ) );
+}
+
+
+static void
+test_handle_message_if_message_is_NULL() {
+  expect_assert_failure( handle_message( MESSENGER_OPENFLOW_MESSAGE, NULL, 1 ) );
+}
+
+
+static void
+test_handle_message_if_message_length_is_zero() {
+  buffer *data;
+
+  data = alloc_buffer_with_length( sizeof( openflow_service_header_t ) );
+
+  expect_assert_failure( handle_message( MESSENGER_OPENFLOW_MESSAGE, data->data, 0 ) );
+
+  free_buffer( data );
+}
+
+
+static void
+test_handle_message_if_unhandled_message_type() {
+  buffer *data;
+
+  data = alloc_buffer_with_length( sizeof( openflow_service_header_t ) );
+  append_back_buffer( data, sizeof( openflow_service_header_t ) );
+
+  // FIXME
+  handle_message( MESSENGER_OPENFLOW_DISCONNECTED + 1, data->data, data->length );
+
+  stat_entry *stat = lookup_hash_entry( stats, "openflow_application_interface.undefined_switch_event_receive_succeeded" );
+  assert_int_equal( ( int ) stat->value, 1 );
+
+  free_buffer( data );
+  xfree( delete_hash_entry( stats, "openflow_application_interface.undefined_switch_event_receive_succeeded" ) );
+}
+
+
+/********************************************************************************
+ * Run tests.
+ ********************************************************************************/
+
+int
+main() {
+  const UnitTest tests[] = {
+    unit_test_setup_teardown( test_init_openflow_application_interface_with_valid_custom_service_name, cleanup, cleanup ),
+    unit_test_setup_teardown( test_init_openflow_application_interface_with_too_long_custom_service_name, cleanup, cleanup ),
+    unit_test_setup_teardown( test_init_openflow_application_interface_if_already_initialized, init, cleanup ),
+
+    unit_test_setup_teardown( test_finalize_openflow_application_interface, init, cleanup ),
+    unit_test_setup_teardown( test_finalize_openflow_application_interface_if_not_initialized, cleanup, cleanup ),
+
+    unit_test_setup_teardown( test_set_openflow_event_handlers, init, cleanup ),
+
+    // switch ready handler tests.
+    unit_test_setup_teardown( test_set_switch_ready_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_simple_switch_ready_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_switch_ready_handler_should_die_if_handler_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_switch_ready, init, cleanup ),
+    unit_test_setup_teardown( test_handle_switch_ready_with_simple_handler, init, cleanup ),
+
+    unit_test_setup_teardown( test_set_switch_disconnected_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_switch_disconnected_handler_if_handler_is_NULL, init, cleanup ),
+
+    unit_test_setup_teardown( test_set_error_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_error_handler_if_handler_is_NULL, init, cleanup ),
+
+    unit_test_setup_teardown( test_set_vendor_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_vendor_handler_if_handler_is_NULL, init, cleanup ),
+
+    unit_test_setup_teardown( test_set_features_reply_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_features_reply_handler_if_handler_is_NULL, init, cleanup ),
+
+    unit_test_setup_teardown( test_set_get_config_reply_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_get_config_reply_handler_if_handler_is_NULL, init, cleanup ),
+
+    unit_test_setup_teardown( test_set_flow_removed_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_flow_removed_handler_if_handler_is_NULL, init, cleanup ),
+
+    unit_test_setup_teardown( test_set_port_status_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_port_status_handler_if_handler_is_NULL, init, cleanup ),
+
+    unit_test_setup_teardown( test_set_stats_reply_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_stats_reply_handler_if_handler_is_NULL, init, cleanup ),
+
+    unit_test_setup_teardown( test_set_barrier_reply_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_barrier_reply_handler_if_handler_is_NULL, init, cleanup ),
+
+    unit_test_setup_teardown( test_set_queue_get_config_reply_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_queue_get_config_reply_handler_if_handler_is_NULL, init, cleanup ),
+
+    unit_test_setup_teardown( test_set_list_switches_reply_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_list_switches_reply_handler_if_handler_is_NULL, init, cleanup ),
+
+    unit_test_setup_teardown( test_send_openflow_message, init, cleanup ),
+    unit_test_setup_teardown( test_send_openflow_message_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_send_openflow_message_if_message_length_is_zero, init, cleanup ),
+
+    unit_test_setup_teardown( test_handle_error, init, cleanup ),
+    unit_test_setup_teardown( test_handle_error_if_handler_is_not_registered, init, cleanup ),
+    unit_test_setup_teardown( test_handle_error_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_error_if_message_length_is_zero, init, cleanup ),
+
+    unit_test_setup_teardown( test_handle_vendor, init, cleanup ),
+    unit_test_setup_teardown( test_handle_vendor_without_data, init, cleanup ),
+    unit_test_setup_teardown( test_handle_vendor_if_handler_is_not_registered, init, cleanup ),
+    unit_test_setup_teardown( test_handle_vendor_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_vendor_if_message_length_is_zero, init, cleanup ),
+
+    unit_test_setup_teardown( test_handle_features_reply, init, cleanup ),
+    unit_test_setup_teardown( test_handle_features_reply_without_phy_port, init, cleanup ),
+    unit_test_setup_teardown( test_handle_features_reply_if_handler_is_not_registered, init, cleanup ),
+    unit_test_setup_teardown( test_handle_features_reply_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_features_reply_if_message_length_is_zero, init, cleanup ),
+
+    unit_test_setup_teardown( test_handle_get_config_reply, init, cleanup ),
+    unit_test_setup_teardown( test_handle_get_config_reply_if_handler_is_not_registered, init, cleanup ),
+    unit_test_setup_teardown( test_handle_get_config_reply_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_get_config_reply_if_message_length_is_zero, init, cleanup ),
+
+    // Packet in handler tests.
+    unit_test_setup_teardown( test_set_packet_in_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_simple_packet_in_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_packet_in_handler_should_die_if_handler_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_packet_in, init, cleanup ),
+    unit_test_setup_teardown( test_handle_packet_in_with_simple_handler, init, cleanup ),
+    unit_test_setup_teardown( test_handle_packet_in_with_malformed_packet, init, cleanup ),
+    unit_test_setup_teardown( test_handle_packet_in_without_data, init, cleanup ),
+    unit_test_setup_teardown( test_handle_packet_in_without_handler, init, cleanup ),
+    unit_test_setup_teardown( test_handle_packet_in_should_die_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_packet_in_should_die_if_message_length_is_zero, init, cleanup ),
+
+    // Flow removed handler tests.
+    unit_test_setup_teardown( test_handle_flow_removed, init, cleanup ),
+    unit_test_setup_teardown( test_handle_flow_removed_with_simple_handler, init, cleanup ),
+    unit_test_setup_teardown( test_set_simple_flow_removed_handler, init, cleanup ),
+    unit_test_setup_teardown( test_handle_flow_removed_if_handler_is_not_registered, init, cleanup ),
+    unit_test_setup_teardown( test_handle_flow_removed_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_flow_removed_if_message_length_is_zero, init, cleanup ),
+
+    unit_test_setup_teardown( test_handle_port_status, init, cleanup ),
+    unit_test_setup_teardown( test_handle_port_status_if_handler_is_not_registered, init, cleanup ),
+    unit_test_setup_teardown( test_handle_port_status_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_port_status_if_message_length_is_zero, init, cleanup ),
+
+    unit_test_setup_teardown( test_handle_stats_reply_if_type_is_OFPST_DESC, init, cleanup ),
+    unit_test_setup_teardown( test_handle_stats_reply_if_type_is_OFPST_FLOW, init, cleanup ),
+    unit_test_setup_teardown( test_handle_stats_reply_if_type_is_OFPST_AGGREGATE, init, cleanup ),
+    unit_test_setup_teardown( test_handle_stats_reply_if_type_is_OFPST_TABLE, init, cleanup ),
+    unit_test_setup_teardown( test_handle_stats_reply_if_type_is_OFPST_PORT, init, cleanup ),
+    unit_test_setup_teardown( test_handle_stats_reply_if_type_is_OFPST_QUEUE, init, cleanup ),
+    unit_test_setup_teardown( test_handle_stats_reply_if_type_is_OFPST_VENDOR, init, cleanup ),
+    unit_test_setup_teardown( test_handle_stats_reply_with_undefined_type, init, cleanup ),
+    unit_test_setup_teardown( test_handle_stats_reply_if_handler_is_not_registered, init, cleanup ),
+    unit_test_setup_teardown( test_handle_stats_reply_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_stats_reply_if_message_length_is_zero, init, cleanup ),
+
+    unit_test_setup_teardown( test_handle_barrier_reply, init, cleanup ),
+    unit_test_setup_teardown( test_handle_barrier_reply_if_handler_is_not_registered, init, cleanup ),
+    unit_test_setup_teardown( test_handle_barrier_reply_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_barrier_reply_if_message_length_is_zero, init, cleanup ),
+
+    unit_test_setup_teardown( test_handle_queue_get_config_reply, init, cleanup ),
+    unit_test_setup_teardown( test_handle_queue_get_config_reply_without_queues, init, cleanup ),
+    unit_test_setup_teardown( test_handle_queue_get_config_reply_if_handler_is_not_registered, init, cleanup ),
+    unit_test_setup_teardown( test_handle_queue_get_config_reply_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_queue_get_config_reply_if_message_length_is_zero, init, cleanup ),
+
+    unit_test_setup_teardown( test_insert_dpid, init, cleanup ),
+    unit_test_setup_teardown( test_insert_dpid_if_head_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_insert_dpid_if_dpid_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_list_switches_reply, init, cleanup ),
+    unit_test_setup_teardown( test_handle_list_switches_reply_if_data_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_list_switches_reply_if_length_is_zero, init, cleanup ),
+
+    unit_test_setup_teardown( test_handle_switch_events_if_type_is_MESSENGER_OPENFLOW_CONNECTED, init, cleanup ),
+    unit_test_setup_teardown( test_handle_switch_events_if_type_is_MESSENGER_OPENFLOW_DISCONNECTED, init, cleanup ),
+    unit_test_setup_teardown( test_handle_switch_events_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_switch_events_if_message_length_is_zero, init, cleanup ),
+    unit_test_setup_teardown( test_handle_switch_events_if_message_length_is_too_big, init, cleanup ),
+    unit_test_setup_teardown( test_handle_switch_events_if_unhandled_message_type, init, cleanup ),
+
+    unit_test_setup_teardown( test_handle_openflow_message, init, cleanup ),
+    unit_test_setup_teardown( test_handle_openflow_message_with_malformed_message, init, cleanup ),
+    unit_test_setup_teardown( test_handle_openflow_message_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_openflow_message_if_message_length_is_zero, init, cleanup ),
+    unit_test_setup_teardown( test_handle_openflow_message_if_unhandled_message_type, init, cleanup ),
+
+    unit_test_setup_teardown( test_handle_message_if_type_is_MESSENGER_OPENFLOW_MESSAGE, init, cleanup ),
+    unit_test_setup_teardown( test_handle_message_if_type_is_MESSENGER_OPENFLOW_CONNECTED, init, cleanup ),
+    unit_test_setup_teardown( test_handle_message_if_type_is_MESSENGER_OPENFLOW_DISCONNECTED, init, cleanup ),
+    unit_test_setup_teardown( test_handle_message_if_message_is_NULL, init, cleanup ),
+    unit_test_setup_teardown( test_handle_message_if_message_length_is_zero, init, cleanup ),
+    unit_test_setup_teardown( test_handle_message_if_unhandled_message_type, init, cleanup ),
+  };
+  return run_tests( tests );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */