trema 0.1.3

data/unittests/lib/buffer_test.c

@@ -0,0 +1,370 @@
+/*
+ * Unit tests for buf functions and macros.
+ *
+ * Author: Shin-ya Zenke
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "buffer.h"
+#include "checks.h"
+#include "cmockery_trema.h"
+#include "openflow.h"
+#include "packet_info.h"
+
+
+typedef struct tea {
+  const char *name;
+  const char *origin;
+} tea;
+
+static tea CEYLON = { "Ceylon", "Sri Lanka" };
+static tea DARJEELING = { "Darjeeling", "India" };
+
+
+typedef struct private_buffer {
+  buffer public;
+  size_t real_length;
+  void *top;
+  pthread_mutex_t *mutex;
+} private_buffer;
+
+
+/********************************************************************************
+ * Tests.
+ ********************************************************************************/
+
+static void
+test_alloc_buffer_succeeds() {
+  buffer *buf = alloc_buffer();
+
+  assert_true( buf != NULL );
+
+  free_buffer( buf );
+}
+
+
+static void
+test_alloc_buffer_with_length_succeeds() {
+  buffer *buf = alloc_buffer_with_length( sizeof( tea ) );
+  assert_true( buf != NULL );
+  free_buffer( buf );
+}
+
+
+static void
+test_free_buffer_succeeds() {
+  buffer *buf = alloc_buffer();
+  assert_true( buf != NULL );
+  free_buffer( buf );
+}
+
+
+static void
+test_append_front_buffer_new_alloc_succeeds() {
+  buffer *buf = alloc_buffer();
+  assert_true( buf != NULL );
+  void *data_pointer = append_front_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) );
+  free_buffer( buf );
+}
+
+
+static void
+test_append_front_twice_suceeds() {
+  buffer *buf = alloc_buffer_with_length( sizeof( tea ) * 2 );
+  assert_true( buf != NULL );
+
+  void *data_pointer = append_front_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) );
+
+  memcpy( data_pointer, &CEYLON, sizeof( tea ) );
+
+  data_pointer = append_front_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) * 2 );
+
+  tea *tea_data = ( tea * ) ( ( char * ) data_pointer + sizeof( tea ) );
+  assert_true( 0 == strcmp( tea_data->name, CEYLON.name ) );
+
+  free_buffer( buf );
+}
+
+
+static void
+test_append_front_buffer_succeeds() {
+  buffer *buf = alloc_buffer_with_length( sizeof( tea ) * 2 );
+  assert_true( buf != NULL );
+
+  void *data_pointer = append_front_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) );
+
+  data_pointer = append_front_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) * 2 );
+
+  free_buffer( buf );
+}
+
+
+static void
+test_append_front_buffer_resize_succeeds() {
+  buffer *buf = alloc_buffer_with_length( sizeof( tea ) );
+  assert_true( buf != NULL );
+
+  void *data_pointer = append_front_buffer( buf, sizeof( tea ) * 2 );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) * 2 );
+
+  free_buffer( buf );
+}
+
+
+static void
+test_remove_front_buffer_succeeds() {
+  buffer *buf = alloc_buffer_with_length( sizeof( tea ) * 2 );
+  assert_true( buf != NULL );
+
+  void *data_pointer = append_front_buffer( buf, sizeof( tea ) * 2 );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) * 2 );
+
+  data_pointer = remove_front_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) );
+
+  free_buffer( buf );
+}
+
+
+static void
+test_remove_front_buffer_text_insert_succeeds() {
+  buffer *buf = alloc_buffer_with_length( sizeof( tea ) * 2 );
+  assert_true( buf != NULL );
+
+  void *data_pointer = append_front_buffer( buf, sizeof( tea ) * 2 );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) * 2 );
+
+  memcpy( ( char * ) data_pointer + sizeof( tea ), &CEYLON, sizeof( tea ) );
+
+  data_pointer = remove_front_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) );
+  tea *tea_data = ( tea * ) ( ( char * ) buf->data );
+  assert_true( 0 == strcmp( tea_data->name, CEYLON.name ) );
+
+  free_buffer( buf );
+}
+
+
+static void
+test_remove_front_buffer_all_removed() {
+  buffer *buf = alloc_buffer_with_length( sizeof( tea ) );
+  assert_true( buf != NULL );
+
+  void *data_pointer = append_front_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( data_pointer == buf->data );
+
+  data_pointer = remove_front_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == 0 );
+
+  free_buffer( buf );
+}
+
+
+static void
+test_append_back_buffer_succeeds() {
+  buffer *buf = alloc_buffer_with_length( sizeof( tea ) * 2 );
+  assert_true( buf != NULL );
+
+  void *data_pointer = append_back_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) );
+
+  free_buffer( buf );
+}
+
+
+static void
+test_append_back_twice_succeeds() {
+  buffer *buf = alloc_buffer_with_length( sizeof( tea ) * 3 );
+  assert_true( buf != NULL );
+
+  void *data_pointer = append_back_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) );
+
+  memcpy( data_pointer, &CEYLON, sizeof( tea ) );
+
+  data_pointer = append_back_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) * 2 );
+
+  memcpy( data_pointer, &DARJEELING, sizeof( tea ) );
+
+  tea *tea_data = ( tea * ) ( ( char * ) buf->data );
+  assert_true( 0 == strcmp( tea_data->name, CEYLON.name ) );
+  tea_data = ( tea * ) ( ( char * ) buf->data + sizeof( tea ) );
+  assert_true( 0 == strcmp( tea_data->name, DARJEELING.name ) );
+
+  free_buffer( buf );
+}
+
+
+static void
+test_append_back_buffer_resize_succeeds() {
+  buffer *buf = alloc_buffer_with_length( sizeof( tea ) );
+  assert_true( buf != NULL );
+
+  void *data_pointer = append_back_buffer( buf, sizeof( tea ) * 2 );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) * 2 );
+
+  free_buffer( buf );
+}
+
+
+static void
+test_append_back_buffer_succeeds_if_initialize_length_is_0() {
+  buffer *buf = alloc_buffer();
+  assert_true( buf != NULL );
+
+  void *data_pointer = append_back_buffer( buf, sizeof( tea ) );
+  assert_true( data_pointer != NULL );
+  assert_true( buf->length == sizeof( tea ) );
+
+  free_buffer( buf );
+}
+
+
+static void
+test_duplicate_buffer_succeeds() {
+  buffer *buf = alloc_buffer_with_length( 1024 );
+  assert_true( buf != NULL );
+  unsigned char *data = append_back_buffer( buf, 1024 );
+  int i;
+  for ( i = 0; i < 1024; i++ ) {
+    data[ i ] = ( unsigned char ) ( i % 0xff ) ;
+  }
+
+  buffer *duplicate = duplicate_buffer( buf );
+  assert_true( duplicate != NULL );
+  assert_true( duplicate->user_data == buf->user_data );
+  assert_true( duplicate->length == buf->length );
+  assert_memory_equal( duplicate->data, buf->data, 1024 );
+
+  free_buffer( buf );
+  free_buffer( duplicate );
+}
+
+
+static void
+test_duplicate_buffer_succeeds_if_initialize_length_is_0() {
+  buffer *buf = alloc_buffer();
+  assert_true( buf != NULL );
+  assert_true( buf->data == NULL );
+
+  buffer *duplicate = duplicate_buffer( buf );
+  assert_true( duplicate != NULL );
+  assert_true( duplicate->data == NULL );
+  assert_true( duplicate->user_data == NULL );
+  assert_true( duplicate->length == 0 );
+
+  free_buffer( buf );
+  free_buffer( duplicate );
+}
+
+
+static void
+dump_function( const char *format, ... ) {
+  char hex[ 1000 ];
+
+  va_list args;
+  va_start( args, format );
+  vsnprintf( hex, sizeof( hex ), format, args );
+  va_end( args );
+
+  check_expected( hex );
+}
+
+
+static void
+test_dump_buffer() {
+  buffer *buf = alloc_buffer();
+
+  void *datap = append_back_buffer( buf, ( size_t ) 1 );
+  int data255 = 255;
+  memcpy( datap, &data255, ( size_t ) 1 );
+
+  expect_string( dump_function, hex, "ff" );
+  dump_buffer( buf, dump_function );
+
+  free_buffer( buf );
+}
+
+
+/********************************************************************************
+ * Run tests.
+ ********************************************************************************/
+
+int
+main() {
+  const UnitTest tests[] = {
+    unit_test( test_alloc_buffer_succeeds ),
+    unit_test( test_alloc_buffer_with_length_succeeds ),
+
+    unit_test( test_free_buffer_succeeds ),
+
+    unit_test( test_append_front_twice_suceeds ),
+    unit_test( test_append_front_buffer_succeeds ),
+    unit_test( test_append_front_buffer_resize_succeeds ),
+    unit_test( test_append_front_buffer_new_alloc_succeeds ),
+
+    unit_test( test_remove_front_buffer_succeeds ),
+    unit_test( test_remove_front_buffer_text_insert_succeeds ),
+    unit_test( test_remove_front_buffer_all_removed ),
+
+    unit_test( test_append_back_buffer_succeeds ),
+    unit_test( test_append_back_buffer_resize_succeeds ),
+    unit_test( test_append_back_buffer_succeeds_if_initialize_length_is_0 ),
+    unit_test( test_append_back_twice_succeeds ),
+
+    unit_test( test_duplicate_buffer_succeeds ),
+    unit_test( test_duplicate_buffer_succeeds_if_initialize_length_is_0 ),
+
+    unit_test( test_dump_buffer ),
+  };
+  setup_leak_detector();
+  return run_tests( tests );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/unittests/lib/byteorder_test.c

@@ -0,0 +1,1717 @@
+/*
+ * Unit tests for byteorder converters.
+ *
+ * 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 <arpa/inet.h>
+#include <openflow.h>
+#include <stdlib.h>
+#include <string.h>
+#include "byteorder.h"
+#include "checks.h"
+#include "cmockery_trema.h"
+#include "log.h"
+#include "utility.h"
+#include "wrapper.h"
+
+
+void
+mock_die( const char *format, ... ) {
+  UNUSED( format );
+
+  mock_assert( false, "mock_die", __FILE__, __LINE__ );
+}
+
+
+/********************************************************************************
+ * Helpers.
+ ********************************************************************************/
+
+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 uint32_t IP_ADDR_X = 0x01020304;
+static const uint32_t IP_ADDR_Y = 0x0a090807;
+static const uint16_t TP_PORT_X = 1024;
+static const uint16_t TP_PORT_Y = 2048;
+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 const struct ofp_match MATCH = { OFPFW_ALL, 1,
+                                        { 0x01, 0x02, 0x03, 0x04, 0x05, 0x07 },
+                                        { 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d },
+                                        1, 1, { 0 }, 0x800, 1, 0x6, { 0, 0 },
+                                        0x0a090807, 0x0a090807, 1024, 2048 };
+static const uint64_t COOKIE = 0x0102030405060708ULL;
+static const uint64_t PACKET_COUNT = 10000;
+static const uint64_t BYTE_COUNT = 10000000;
+static const char *TABLE_NAME = "flow table 1";
+
+
+static struct ofp_action_output *
+create_action_output() {
+  struct ofp_action_output *action = xmalloc( sizeof( struct ofp_action_output ) );
+  memset( action, 0, sizeof( struct ofp_action_output ) );
+
+  action->type = htons( OFPAT_OUTPUT );
+  action->len = htons( 8 );
+  action->port = htons( 1 );
+  action->max_len = htons( 2048 );
+
+  return action;
+}
+
+
+static struct ofp_action_vlan_vid *
+create_action_vlan_vid() {
+  struct ofp_action_vlan_vid *action = xmalloc( sizeof( struct ofp_action_vlan_vid ) );
+  memset( action, 0, sizeof( struct ofp_action_vlan_vid ) );
+
+  action->type = htons( OFPAT_SET_VLAN_VID );
+  action->len = htons( 8 );
+  action->vlan_vid = htons( 256 );
+
+  return action;
+}
+
+
+static struct ofp_action_vlan_pcp *
+create_action_vlan_pcp() {
+  struct ofp_action_vlan_pcp *action = xmalloc( sizeof( struct ofp_action_vlan_pcp ) );
+  memset( action, 0, sizeof( struct ofp_action_vlan_pcp ) );
+
+  action->type = htons( OFPAT_SET_VLAN_PCP );
+  action->len = htons( 8 );
+  action->vlan_pcp = 3;
+
+  return action;
+}
+
+
+static struct ofp_action_header *
+create_action_strip_vlan() {
+  struct ofp_action_header *action = xmalloc( sizeof( struct ofp_action_header ) );
+  memset( action, 0, sizeof( struct ofp_action_header ) );
+
+  action->type = htons( OFPAT_STRIP_VLAN );
+  action->len = htons( 8 );
+
+  return action;
+}
+
+
+static struct ofp_action_dl_addr *
+create_action_dl_addr() {
+  struct ofp_action_dl_addr *action = xmalloc( sizeof( struct ofp_action_dl_addr ) );
+  memset( action, 0, sizeof( struct ofp_action_dl_addr ) );
+
+  action->type = htons( OFPAT_SET_DL_SRC );
+  action->len = htons( 16 );
+  memcpy( action->dl_addr, MAC_ADDR_X, sizeof( action->dl_addr ) );
+
+  return action;
+}
+
+
+static struct ofp_action_nw_addr *
+create_action_nw_addr() {
+  struct ofp_action_nw_addr *action = xmalloc( sizeof( struct ofp_action_nw_addr ) );
+  memset( action, 0, sizeof( struct ofp_action_nw_addr ) );
+
+  action->type = htons( OFPAT_SET_NW_SRC );
+  action->len = htons( 8 );
+  action->nw_addr = htonl( IP_ADDR_X );
+
+  return action;
+}
+
+
+static struct ofp_action_nw_tos *
+create_action_nw_tos() {
+  struct ofp_action_nw_tos *action = xmalloc( sizeof( struct ofp_action_nw_tos ) );
+  memset( action, 0, sizeof( struct ofp_action_nw_tos ) );
+
+  action->type = htons( OFPAT_SET_NW_TOS );
+  action->len = htons( 8 );
+  action->nw_tos = 3;
+
+  return action;
+}
+
+
+static struct ofp_action_tp_port *
+create_action_tp_port() {
+  struct ofp_action_tp_port *action = xmalloc( sizeof( struct ofp_action_tp_port ) );
+  memset( action, 0, sizeof( struct ofp_action_tp_port ) );
+
+  action->type = htons( OFPAT_SET_TP_SRC );
+  action->len = htons( 8 );
+  action->tp_port = htons( TP_PORT_X );
+
+  return action;
+}
+
+
+static struct ofp_action_enqueue *
+create_action_enqueue() {
+  struct ofp_action_enqueue *action = xmalloc( sizeof( struct ofp_action_enqueue ) );
+  memset( action, 0, sizeof( struct ofp_action_enqueue ) );
+
+  action->type = htons( OFPAT_ENQUEUE );
+  action->len = htons( 16 );
+  action->port = htons( 1 );
+  action->queue_id = htonl( 8 );
+
+  return action;
+}
+
+
+static struct ofp_action_vendor_header *
+create_action_vendor() {
+  struct ofp_action_vendor_header *action = xmalloc( sizeof( struct ofp_action_vendor_header ) );
+  memset( action, 0, sizeof( struct ofp_action_vendor_header ) );
+
+  action->type = htons( OFPAT_VENDOR );
+  action->len = htons( 8 );
+  action->vendor = htonl( 2048 );
+
+  return action;
+}
+
+
+/********************************************************************************
+ * ntoh_match() test.
+ ********************************************************************************/
+
+void
+test_ntoh_match() {
+  struct ofp_match dst;
+  struct ofp_match src;
+
+  memset( &src, 0, sizeof( struct ofp_match ) );
+  memset( &dst, 0, sizeof( struct ofp_match ) );
+
+  src.wildcards = htonl( OFPFW_ALL );
+  src.in_port = htons( 1 );
+  memcpy( &src.dl_src, MAC_ADDR_X, sizeof( src.dl_src ) );
+  memcpy( &src.dl_dst, MAC_ADDR_Y, sizeof( src.dl_dst ) );
+  src.dl_vlan = htons( 1 );
+  src.dl_vlan_pcp = 1;
+  src.dl_type = htons( 0x800 );
+  src.nw_tos = 1;
+  src.nw_proto = 0x6;
+  src.nw_src = htonl( IP_ADDR_X );
+  src.nw_dst = htonl( IP_ADDR_Y );
+  src.tp_src = htons( TP_PORT_X );
+  src.tp_dst = htons( TP_PORT_Y );
+
+  ntoh_match( &dst, &src );
+
+  assert_int_equal( ( int ) htonl( dst.wildcards ), ( int ) src.wildcards );
+  assert_int_equal( htons( dst.in_port ), src.in_port );
+  assert_memory_equal( dst.dl_src, src.dl_src, sizeof( src.dl_src ) );
+  assert_memory_equal( dst.dl_dst, src.dl_dst, sizeof( src.dl_dst ) );
+  assert_int_equal( htons( dst.dl_vlan ), src.dl_vlan );
+  assert_int_equal( dst.dl_vlan_pcp, src.dl_vlan_pcp );
+  assert_int_equal( htons( dst.dl_type ), src.dl_type );
+  assert_int_equal( dst.nw_tos, src.nw_tos );
+  assert_int_equal( dst.nw_proto, src.nw_proto );
+  assert_int_equal( ( int ) htonl( dst.nw_src ), ( int ) src.nw_src );
+  assert_int_equal( ( int ) htonl( dst.nw_dst ), ( int ) src.nw_dst );
+  assert_int_equal( htons( dst.tp_src ), src.tp_src );
+  assert_int_equal( htons( dst.tp_dst ), src.tp_dst );
+}
+
+
+/********************************************************************************
+ * ntoh_phy_port() test.
+ ********************************************************************************/
+
+void
+test_ntoh_phy_port() {
+  struct ofp_phy_port dst;
+  struct ofp_phy_port src;
+
+  memset( &src, 0, sizeof( struct ofp_phy_port ) );
+  memset( &dst, 0, sizeof( struct ofp_phy_port ) );
+
+  src.port_no = htons( 1 );
+  memcpy( src.hw_addr, MAC_ADDR_X, sizeof( src.hw_addr ) );
+  memset( src.name, '\0', OFP_MAX_PORT_NAME_LEN );
+  memcpy( src.name, PORT_NAME, strlen( PORT_NAME ) );
+  src.config = htonl( OFPPC_PORT_DOWN );
+  src.state = htonl( OFPPS_LINK_DOWN );
+  src.curr = htonl( OFPPF_1GB_FD | OFPPF_COPPER | OFPPF_PAUSE );
+  src.advertised = htonl( PORT_FEATURES );
+  src.supported = htonl( PORT_FEATURES );
+  src.peer = htonl( PORT_FEATURES );
+
+  ntoh_phy_port( &dst, &src );
+
+  assert_int_equal( htons( dst.port_no ), src.port_no );
+  assert_memory_equal( dst.hw_addr, src.hw_addr, sizeof( src.hw_addr ) );
+  assert_memory_equal( dst.name, src.name, OFP_MAX_PORT_NAME_LEN );
+  assert_int_equal( ( int ) htonl( dst.config ), ( int ) src.config );
+  assert_int_equal( ( int ) htonl( dst.state ), ( int ) src.state );
+  assert_int_equal( ( int ) htonl( dst.curr ), ( int ) src.curr );
+  assert_int_equal( ( int ) htonl( dst.advertised ), ( int ) src.advertised );
+  assert_int_equal( ( int ) htonl( dst.supported ), ( int ) src.supported );
+  assert_int_equal( ( int ) htonl( dst.peer ), ( int ) src.peer );
+}
+
+
+/********************************************************************************
+ * ntoh_action_output() test.
+ ********************************************************************************/
+
+void
+test_ntoh_action_output() {
+  struct ofp_action_output dst;
+
+  memset( &dst, 0, sizeof( struct ofp_action_output ) );
+
+  struct ofp_action_output *src = create_action_output();
+
+  ntoh_action_output( &dst, src );
+
+  assert_int_equal( htons( dst.type ), src->type );
+  assert_int_equal( htons( dst.len ), src->len );
+  assert_int_equal( htons( dst.port ), src->port );
+  assert_int_equal( htons( dst.max_len ), src->max_len );
+
+  xfree( src );
+}
+
+
+/********************************************************************************
+ * ntoh_action_vlan_vid() test.
+ ********************************************************************************/
+
+void
+test_ntoh_action_vlan_vid() {
+  struct ofp_action_vlan_vid dst;
+
+  memset( &dst, 0, sizeof( struct ofp_action_vlan_vid ) );
+
+  struct ofp_action_vlan_vid *src = create_action_vlan_vid();
+
+  ntoh_action_vlan_vid( &dst, src );
+
+  assert_int_equal( htons( dst.type ), src->type );
+  assert_int_equal( htons( dst.len ), src->len );
+  assert_int_equal( htons( dst.vlan_vid ), src->vlan_vid );
+
+  xfree( src );
+}
+
+
+/********************************************************************************
+ * ntoh_action_vlan_pcp() test.
+ ********************************************************************************/
+
+void
+test_ntoh_action_vlan_pcp() {
+  struct ofp_action_vlan_pcp dst;
+
+  memset( &dst, 0, sizeof( struct ofp_action_vlan_pcp ) );
+
+  struct ofp_action_vlan_pcp *src = create_action_vlan_pcp();
+
+  ntoh_action_vlan_pcp( &dst, src );
+
+  assert_int_equal( htons( dst.type ), src->type );
+  assert_int_equal( htons( dst.len ), src->len );
+  assert_int_equal( dst.vlan_pcp, src->vlan_pcp );
+
+  xfree( src );
+}
+
+
+/********************************************************************************
+ * ntoh_action_strip_vlan() test.
+ ********************************************************************************/
+
+void
+test_ntoh_action_strip_vlan() {
+  struct ofp_action_header dst;
+
+  memset( &dst, 0, sizeof( struct ofp_action_header ) );
+
+  struct ofp_action_header *src = create_action_strip_vlan();
+
+  ntoh_action_strip_vlan( &dst, src );
+
+  assert_int_equal( htons( dst.type ), src->type );
+  assert_int_equal( htons( dst.len ), src->len );
+
+  xfree( src );
+}
+
+
+/********************************************************************************
+ * ntoh_action_dl_addr() test.
+ ********************************************************************************/
+
+void
+test_ntoh_action_dl_addr() {
+  struct ofp_action_dl_addr dst;
+
+  memset( &dst, 0, sizeof( struct ofp_action_dl_addr ) );
+
+  struct ofp_action_dl_addr *src = create_action_dl_addr();
+
+  ntoh_action_dl_addr( &dst, src );
+
+  assert_int_equal( htons( dst.type ), src->type );
+  assert_int_equal( htons( dst.len ), src->len );
+  assert_memory_equal( dst.dl_addr, src->dl_addr, sizeof( src->dl_addr ) );
+
+  xfree( src );
+}
+
+
+/********************************************************************************
+ * ntoh_action_nw_addr() test.
+ ********************************************************************************/
+
+void
+test_ntoh_action_nw_addr() {
+  struct ofp_action_nw_addr dst;
+
+  memset( &dst, 0, sizeof( struct ofp_action_nw_addr ) );
+
+  struct ofp_action_nw_addr *src = create_action_nw_addr();
+
+  ntoh_action_nw_addr( &dst, src );
+
+  assert_int_equal( htons( dst.type ), src->type );
+  assert_int_equal( htons( dst.len ), src->len );
+  assert_int_equal( ( int ) htonl( dst.nw_addr ), ( int ) src->nw_addr );
+
+  xfree( src );
+}
+
+
+/********************************************************************************
+ * ntoh_action_nw_tos() test.
+ ********************************************************************************/
+
+void
+test_ntoh_action_nw_tos() {
+  struct ofp_action_nw_tos dst;
+
+  memset( &dst, 0, sizeof( struct ofp_action_nw_tos ) );
+
+  struct ofp_action_nw_tos *src = create_action_nw_tos();
+
+  ntoh_action_nw_tos( &dst, src );
+
+  assert_int_equal( htons( dst.type ), src->type );
+  assert_int_equal( htons( dst.len ), src->len );
+  assert_int_equal( dst.nw_tos, src->nw_tos );
+
+  xfree( src );
+}
+
+
+/********************************************************************************
+ * ntoh_action_tp_port() test.
+ ********************************************************************************/
+
+void
+test_ntoh_action_tp_port() {
+  struct ofp_action_tp_port dst;
+
+  memset( &dst, 0, sizeof( struct ofp_action_tp_port ) );
+
+  struct ofp_action_tp_port *src = create_action_tp_port();
+
+  ntoh_action_tp_port( &dst, src );
+
+  assert_int_equal( htons( dst.type ), src->type );
+  assert_int_equal( htons( dst.len ), src->len );
+  assert_int_equal( htons( dst.tp_port ), src->tp_port );
+
+  xfree( src );
+}
+
+
+/********************************************************************************
+ * ntoh_action_enqueue() test.
+ ********************************************************************************/
+
+void
+test_ntoh_action_enqueue() {
+  struct ofp_action_enqueue dst;
+
+  memset( &dst, 0, sizeof( struct ofp_action_enqueue ) );
+
+  struct ofp_action_enqueue *src = create_action_enqueue();
+
+  ntoh_action_enqueue( &dst, src );
+
+  assert_int_equal( htons( dst.type ), src->type );
+  assert_int_equal( htons( dst.len ), src->len );
+  assert_int_equal( htons( dst.port) , src->port );
+  assert_int_equal( ( int ) htonl( dst.queue_id ), ( int ) src->queue_id );
+
+  xfree( src );
+}
+
+
+/********************************************************************************
+ * ntoh_action_vendor() test.
+ ********************************************************************************/
+
+void
+test_ntoh_action_vendor() {
+  struct ofp_action_vendor_header dst;
+
+  memset( &dst, 0, sizeof( struct ofp_action_vendor_header ) );
+
+  struct ofp_action_vendor_header *src = create_action_vendor();
+
+  ntoh_action_vendor( &dst, src );
+
+  assert_int_equal( htons( dst.type ), src->type );
+  assert_int_equal( htons( dst.len ), src->len );
+  assert_int_equal( ( int ) htonl( dst.vendor ), ( int ) src->vendor );
+
+  xfree( src );
+}
+
+
+/********************************************************************************
+ * ntoh_action() tests.
+ ********************************************************************************/
+
+void
+test_ntoh_action() {
+  {
+    struct ofp_action_output dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_output ) );
+
+    struct ofp_action_output *src = create_action_output();
+
+    ntoh_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( htons( dst.port ), src->port );
+    assert_int_equal( htons( dst.max_len ), src->max_len );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_vlan_vid dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_vlan_vid ) );
+
+    struct ofp_action_vlan_vid *src = create_action_vlan_vid();
+
+    ntoh_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( htons( dst.vlan_vid ), src->vlan_vid );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_vlan_pcp dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_vlan_pcp ) );
+
+    struct ofp_action_vlan_pcp *src = create_action_vlan_pcp();
+
+    ntoh_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( dst.vlan_pcp, src->vlan_pcp );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_header dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_header ) );
+
+    struct ofp_action_header *src = create_action_strip_vlan();
+
+    ntoh_action( &dst, src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_dl_addr dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_dl_addr ) );
+
+    struct ofp_action_dl_addr *src = create_action_dl_addr();
+
+    ntoh_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_memory_equal( dst.dl_addr, src->dl_addr, sizeof( src->dl_addr ) );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_nw_addr dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_nw_addr ) );
+
+    struct ofp_action_nw_addr *src = create_action_nw_addr();
+
+    ntoh_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( ( int ) htonl( dst.nw_addr ), ( int ) src->nw_addr );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_nw_tos dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_nw_tos ) );
+
+    struct ofp_action_nw_tos *src = create_action_nw_tos();
+
+    ntoh_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( dst.nw_tos, src->nw_tos );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_tp_port dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_tp_port ) );
+
+    struct ofp_action_tp_port *src = create_action_tp_port();
+
+    ntoh_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( htons( dst.tp_port ), src->tp_port );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_enqueue dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_enqueue ) );
+
+    struct ofp_action_enqueue *src = create_action_enqueue();
+
+    ntoh_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( htons( dst.port) , src->port );
+    assert_int_equal( ( int ) htonl( dst.queue_id ), ( int ) src->queue_id );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_vendor_header dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_vendor_header ) );
+
+    struct ofp_action_vendor_header *src = create_action_vendor();
+
+    ntoh_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( ( int ) htonl( dst.vendor ), ( int ) src->vendor );
+
+    xfree( src );
+  }
+}
+
+
+void
+test_ntoh_action_with_undefined_action_type() {
+  struct ofp_action_output dst;
+
+  memset( &dst, 0, sizeof( struct ofp_action_output ) );
+
+  struct ofp_action_output *src = create_action_output();
+
+  src->type = htons( OFPAT_ENQUEUE + 1 );
+  
+  expect_assert_failure( ntoh_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src ) );
+
+  xfree( src );
+}
+
+
+/********************************************************************************
+ * hton_action() tests.
+ ********************************************************************************/
+
+void
+test_hton_action() {
+  {
+    struct ofp_action_output dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_output ) );
+
+    struct ofp_action_output *src = create_action_output();
+    ntoh_action_output( src, src );
+
+    hton_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( htons( dst.port ), src->port );
+    assert_int_equal( htons( dst.max_len ), src->max_len );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_vlan_vid dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_vlan_vid ) );
+
+    struct ofp_action_vlan_vid *src = create_action_vlan_vid();
+    ntoh_action_vlan_vid( src, src );
+
+    hton_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( htons( dst.vlan_vid ), src->vlan_vid );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_vlan_pcp dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_vlan_pcp ) );
+
+    struct ofp_action_vlan_pcp *src = create_action_vlan_pcp();
+    ntoh_action_vlan_pcp( src, src );
+
+    hton_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( dst.vlan_pcp, src->vlan_pcp );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_header dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_header ) );
+
+    struct ofp_action_header *src = create_action_strip_vlan();
+    ntoh_action_strip_vlan( src, src );
+
+    hton_action( &dst, src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_dl_addr dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_dl_addr ) );
+
+    struct ofp_action_dl_addr *src = create_action_dl_addr();
+    ntoh_action_dl_addr( src, src );
+
+    hton_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_memory_equal( dst.dl_addr, src->dl_addr, sizeof( src->dl_addr ) );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_nw_addr dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_nw_addr ) );
+
+    struct ofp_action_nw_addr *src = create_action_nw_addr();
+    ntoh_action_nw_addr( src, src );
+
+    hton_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( ( int ) htonl( dst.nw_addr ), ( int ) src->nw_addr );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_nw_tos dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_nw_tos ) );
+
+    struct ofp_action_nw_tos *src = create_action_nw_tos();
+    ntoh_action_nw_tos( src, src );
+
+    hton_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( dst.nw_tos, src->nw_tos );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_tp_port dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_tp_port ) );
+
+    struct ofp_action_tp_port *src = create_action_tp_port();
+    ntoh_action_tp_port( src, src );
+
+    hton_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( htons( dst.tp_port ), src->tp_port );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_enqueue dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_enqueue ) );
+
+    struct ofp_action_enqueue *src = create_action_enqueue();
+    ntoh_action_enqueue( src, src );
+
+    hton_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( htons( dst.port) , src->port );
+    assert_int_equal( ( int ) htonl( dst.queue_id ), ( int ) src->queue_id );
+
+    xfree( src );
+  }
+
+  {
+    struct ofp_action_vendor_header dst;
+
+    memset( &dst, 0, sizeof( struct ofp_action_vendor_header ) );
+
+    struct ofp_action_vendor_header *src = create_action_vendor();
+    ntoh_action_vendor( src, src );
+
+    hton_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src );
+
+    assert_int_equal( htons( dst.type ), src->type );
+    assert_int_equal( htons( dst.len ), src->len );
+    assert_int_equal( ( int ) htonl( dst.vendor ), ( int ) src->vendor );
+
+    xfree( src );
+  }
+}
+
+
+void
+test_hton_action_with_undefined_action_type() {
+  struct ofp_action_output dst;
+
+  memset( &dst, 0, sizeof( struct ofp_action_output ) );
+
+  struct ofp_action_output *src = create_action_output();
+  ntoh_action_output( src, src );
+
+  src->type = OFPAT_ENQUEUE + 1;
+  
+  expect_assert_failure( hton_action( ( struct ofp_action_header * ) &dst, ( struct ofp_action_header * ) src ) );
+
+  xfree( src );
+}
+
+
+/********************************************************************************
+ * ntoh_flow_stats() tests.
+ ********************************************************************************/
+
+void
+test_ntoh_flow_stats_without_action() {
+  uint16_t length = ( uint16_t ) ( offsetof( struct ofp_flow_stats, actions ) );
+
+  struct ofp_flow_stats *src = xmalloc( length );
+  struct ofp_flow_stats *dst = xmalloc( length );
+
+  memset( src, 0, length );
+  memset( dst, 0, length );
+
+  src->length = htons( length );
+  src->table_id = 1;
+  hton_match( &src->match, &MATCH );
+  src->duration_sec = htonl( 60 );
+  src->duration_nsec = htonl( 5000 );
+  src->priority = htons( UINT16_MAX );
+  src->idle_timeout = htons( 60 );
+  src->hard_timeout = htons( 300 );
+  src->cookie = htonll( COOKIE );
+  src->packet_count = htonll( PACKET_COUNT );
+  src->byte_count= htonll( BYTE_COUNT );
+
+  ntoh_flow_stats( dst, src );
+
+  assert_int_equal( htons( dst->length ), src->length );
+  assert_int_equal( dst->table_id, src->table_id );
+  assert_memory_equal( &dst->match, &MATCH, sizeof( struct ofp_match ) );
+  assert_int_equal( ( int ) htonl( dst->duration_sec ), ( int ) src->duration_sec );
+  assert_int_equal( ( int ) htonl( dst->duration_nsec ), ( int ) src->duration_nsec );
+  assert_int_equal( htons( dst->priority ), src->priority );
+  assert_int_equal( htons( dst->idle_timeout ), src->idle_timeout );
+  assert_int_equal( htons( dst->hard_timeout ), src->hard_timeout );
+  assert_memory_equal( &dst->cookie, &COOKIE, sizeof( uint64_t ) );
+  assert_memory_equal( &dst->packet_count, &PACKET_COUNT, sizeof( uint64_t ) );
+  assert_memory_equal( &dst->byte_count, &BYTE_COUNT, sizeof( uint64_t ) );
+
+  xfree( src );
+  xfree( dst );
+}
+
+
+void
+test_ntoh_flow_stats_with_single_output_action() {
+  uint16_t length = ( uint16_t ) ( offsetof( struct ofp_flow_stats, actions ) + sizeof( struct ofp_action_output ) );
+
+  struct ofp_flow_stats *src = xmalloc( length );
+  struct ofp_flow_stats *dst = xmalloc( length );
+
+  memset( src, 0, length );
+  memset( dst, 0, length );
+
+  src->length = htons( length );
+  src->table_id = 1;
+  hton_match( &src->match, &MATCH );
+  src->duration_sec = htonl( 60 );
+  src->duration_nsec = htonl( 5000 );
+  src->priority = htons( UINT16_MAX );
+  src->idle_timeout = htons( 60 );
+  src->hard_timeout = htons( 300 );
+  src->cookie = htonll( COOKIE );
+  src->packet_count = htonll( PACKET_COUNT );
+  src->byte_count= htonll( BYTE_COUNT );
+  struct ofp_action_output *act_src = ( struct ofp_action_output * ) src->actions;
+  act_src->type = htons( OFPAT_OUTPUT );
+  act_src->len = htons( 8 );
+  act_src->port = htons( 1 );
+  act_src->max_len = htons( 2048 );
+
+  ntoh_flow_stats( dst, src );
+
+  struct ofp_action_output *act_dst = ( struct ofp_action_output * ) dst->actions;
+
+  assert_int_equal( htons( dst->length ), src->length );
+  assert_int_equal( dst->table_id, src->table_id );
+  assert_memory_equal( &dst->match, &MATCH, sizeof( struct ofp_match ) );
+  assert_int_equal( ( int ) htonl( dst->duration_sec ), ( int ) src->duration_sec );
+  assert_int_equal( ( int ) htonl( dst->duration_nsec ), ( int ) src->duration_nsec );
+  assert_int_equal( htons( dst->priority ), src->priority );
+  assert_int_equal( htons( dst->idle_timeout ), src->idle_timeout );
+  assert_int_equal( htons( dst->hard_timeout ), src->hard_timeout );
+  assert_memory_equal( &dst->cookie, &COOKIE, sizeof( uint64_t ) );
+  assert_memory_equal( &dst->packet_count, &PACKET_COUNT, sizeof( uint64_t ) );
+  assert_memory_equal( &dst->byte_count, &BYTE_COUNT, sizeof( uint64_t ) );
+  assert_int_equal( htons( act_dst->type ), act_src->type );
+  assert_int_equal( htons( act_dst->len ), act_src->len );
+  assert_int_equal( htons( act_dst->port ), act_src->port );
+  assert_int_equal( htons( act_dst->max_len ), act_src->max_len );
+
+  xfree( src );
+  xfree( dst );
+}
+
+
+void
+test_ntoh_flow_stats_with_two_output_actions() {
+  uint16_t length = ( uint16_t ) ( offsetof( struct ofp_flow_stats, actions ) + sizeof( struct ofp_action_output ) * 2 );
+
+  struct ofp_flow_stats *src = xmalloc( length );
+  struct ofp_flow_stats *dst = xmalloc( length );
+
+  memset( src, 0, length );
+  memset( dst, 0, length );
+
+  src->length = htons( length );
+  src->table_id = 1;
+  hton_match( &src->match, &MATCH );
+  src->duration_sec = htonl( 60 );
+  src->duration_nsec = htonl( 5000 );
+  src->priority = htons( UINT16_MAX );
+  src->idle_timeout = htons( 60 );
+  src->hard_timeout = htons( 300 );
+  src->cookie = htonll( COOKIE );
+  src->packet_count = htonll( PACKET_COUNT );
+  src->byte_count= htonll( BYTE_COUNT );
+  struct ofp_action_output *act_src[ 2 ];
+  act_src[ 0 ] = ( struct ofp_action_output * ) src->actions;
+  act_src[ 0 ]->type = htons( OFPAT_OUTPUT );
+  act_src[ 0 ]->len = htons( 8 );
+  act_src[ 0 ]->port = htons( 1 );
+  act_src[ 0 ]->max_len = htons( 2048 );
+  act_src[ 1 ] = ( struct ofp_action_output * ) ( ( char * ) src->actions + sizeof( struct ofp_action_output ) );
+  act_src[ 1 ]->type = htons( OFPAT_OUTPUT );
+  act_src[ 1 ]->len = htons( 8 );
+  act_src[ 1 ]->port = htons( 2 );
+  act_src[ 1 ]->max_len = htons( 2048 );
+
+  ntoh_flow_stats( dst, src );
+
+  struct ofp_action_output *act_dst[ 2 ];
+  act_dst[ 0 ] = ( struct ofp_action_output * ) dst->actions;
+  act_dst[ 1 ] = ( struct ofp_action_output * ) ( ( char * ) dst->actions + sizeof( struct ofp_action_output ) );
+
+  assert_int_equal( htons( dst->length ), src->length );
+  assert_int_equal( dst->table_id, src->table_id );
+  assert_memory_equal( &dst->match, &MATCH, sizeof( struct ofp_match ) );
+  assert_int_equal( ( int ) htonl( dst->duration_sec ), ( int ) src->duration_sec );
+  assert_int_equal( ( int ) htonl( dst->duration_nsec ), ( int ) src->duration_nsec );
+  assert_int_equal( htons( dst->priority ), src->priority );
+  assert_int_equal( htons( dst->idle_timeout ), src->idle_timeout );
+  assert_int_equal( htons( dst->hard_timeout ), src->hard_timeout );
+  assert_memory_equal( &dst->cookie, &COOKIE, sizeof( uint64_t ) );
+  assert_memory_equal( &dst->packet_count, &PACKET_COUNT, sizeof( uint64_t ) );
+  assert_memory_equal( &dst->byte_count, &BYTE_COUNT, sizeof( uint64_t ) );
+  assert_int_equal( htons( act_dst[ 0 ]->type ), act_src[ 0 ]->type );
+  assert_int_equal( htons( act_dst[ 0 ]->len ), act_src[ 0 ]->len );
+  assert_int_equal( htons( act_dst[ 0 ]->port ), act_src[ 0 ]->port );
+  assert_int_equal( htons( act_dst[ 0 ]->max_len ), act_src[ 0 ]->max_len );
+  assert_int_equal( htons( act_dst[ 1 ]->type ), act_src[ 1 ]->type );
+  assert_int_equal( htons( act_dst[ 1 ]->len ), act_src[ 1 ]->len );
+  assert_int_equal( htons( act_dst[ 1 ]->port ), act_src[ 1 ]->port );
+  assert_int_equal( htons( act_dst[ 1 ]->max_len ), act_src[ 1 ]->max_len );
+
+  xfree( src );
+  xfree( dst );
+}
+
+
+/********************************************************************************
+ * hton_flow_stats() tests.
+ ********************************************************************************/
+
+void
+test_hton_flow_stats_without_action() {
+  uint16_t length = ( uint16_t ) ( offsetof( struct ofp_flow_stats, actions ) );
+
+  struct ofp_flow_stats *src = xmalloc( length );
+  struct ofp_flow_stats *dst = xmalloc( length );
+
+  memset( src, 0, length );
+  memset( dst, 0, length );
+
+  src->length = length;
+  src->table_id = 1;
+  src->match = MATCH;
+  src->duration_sec = 60;
+  src->duration_nsec = 5000;
+  src->priority = UINT16_MAX;
+  src->idle_timeout = 60;
+  src->hard_timeout = 300;
+  src->cookie = COOKIE;
+  src->packet_count = PACKET_COUNT;
+  src->byte_count= BYTE_COUNT;
+
+  hton_flow_stats( dst, src );
+
+  assert_int_equal( dst->length, htons( src->length ) );
+  assert_int_equal( dst->table_id, src->table_id );
+  hton_match( &src->match, &MATCH );
+  assert_memory_equal( &dst->match, &src->match, sizeof( struct ofp_match ) );
+  assert_int_equal( ( int ) dst->duration_sec, ( int ) htonl( src->duration_sec ) );
+  assert_int_equal( ( int ) dst->duration_nsec, ( int ) htonl( src->duration_nsec ) );
+  assert_int_equal( dst->priority, htons( src->priority ) );
+  assert_int_equal( dst->idle_timeout, htons( src->idle_timeout ) );
+  assert_int_equal( dst->hard_timeout, htons( src->hard_timeout ) );
+  src->cookie = htonll( COOKIE );
+  assert_memory_equal( &dst->cookie, &src->cookie, sizeof( uint64_t ) );
+  src->packet_count = htonll( PACKET_COUNT );
+  assert_memory_equal( &dst->packet_count, &src->packet_count, sizeof( uint64_t ) );
+  src->byte_count = htonll( BYTE_COUNT );
+  assert_memory_equal( &dst->byte_count, &src->byte_count, sizeof( uint64_t ) );
+
+  xfree( src );
+  xfree( dst );
+}
+
+
+void
+test_hton_flow_stats_with_single_output_action() {
+  uint16_t length = ( uint16_t ) ( offsetof( struct ofp_flow_stats, actions ) + sizeof( struct ofp_action_output ) );
+
+  struct ofp_flow_stats *src = xmalloc( length );
+  struct ofp_flow_stats *dst = xmalloc( length );
+
+  memset( src, 0, length );
+  memset( dst, 0, length );
+
+  src->length = length;
+  src->table_id = 1;
+  src->match = MATCH;
+  src->duration_sec = 60;
+  src->duration_nsec = 5000 ;
+  src->priority = UINT16_MAX;
+  src->idle_timeout = 60;
+  src->hard_timeout = 300;
+  src->cookie = COOKIE;
+  src->packet_count = PACKET_COUNT;
+  src->byte_count= BYTE_COUNT;
+  struct ofp_action_output *act_src = ( struct ofp_action_output * ) src->actions;
+  act_src->type = OFPAT_OUTPUT;
+  act_src->len = 8;
+  act_src->port = 1;
+  act_src->max_len = 2048;
+
+  hton_flow_stats( dst, src );
+
+  struct ofp_action_output *act_dst = ( struct ofp_action_output * ) dst->actions;
+
+  assert_int_equal( dst->length, htons( src->length ) );
+  assert_int_equal( dst->table_id, src->table_id );
+  hton_match( &src->match, &MATCH );
+  assert_memory_equal( &dst->match, &src->match, sizeof( struct ofp_match ) );
+  assert_int_equal( ( int ) dst->duration_sec, ( int ) htonl( src->duration_sec ) );
+  assert_int_equal( ( int ) dst->duration_nsec, ( int ) htonl( src->duration_nsec ) );
+  assert_int_equal( dst->priority, htons( src->priority ) );
+  assert_int_equal( dst->idle_timeout, htons( src->idle_timeout ) );
+  assert_int_equal( dst->hard_timeout, htons( src->hard_timeout ) );
+  src->cookie = htonll( COOKIE );
+  assert_memory_equal( &dst->cookie, &src->cookie, sizeof( uint64_t ) );
+  src->packet_count = htonll( PACKET_COUNT );
+  assert_memory_equal( &dst->packet_count, &src->packet_count, sizeof( uint64_t ) );
+  src->byte_count = htonll( BYTE_COUNT );
+  assert_memory_equal( &dst->byte_count, &src->byte_count, sizeof( uint64_t ) );
+  assert_int_equal( act_dst->type, htons( act_src->type ) );
+  assert_int_equal( act_dst->len, htons( act_src->len ) );
+  assert_int_equal( act_dst->port, htons( act_src->port ) );
+  assert_int_equal( act_dst->max_len, htons( act_src->max_len ) );
+
+  xfree( src );
+  xfree( dst );
+}
+
+
+void
+test_hton_flow_stats_with_two_output_actions() {
+  uint16_t length = ( uint16_t ) ( offsetof( struct ofp_flow_stats, actions ) + sizeof( struct ofp_action_output ) * 2 );
+
+  struct ofp_flow_stats *src = xmalloc( length );
+  struct ofp_flow_stats *dst = xmalloc( length );
+
+  memset( src, 0, length );
+  memset( dst, 0, length );
+
+  src->length = length;
+  src->table_id = 1;
+  src->match = MATCH;
+  src->duration_sec = 60;
+  src->duration_nsec = 5000;
+  src->priority = UINT16_MAX;
+  src->idle_timeout = 60;
+  src->hard_timeout = 300;
+  src->cookie = COOKIE;
+  src->packet_count = PACKET_COUNT;
+  src->byte_count= BYTE_COUNT;
+  struct ofp_action_output *act_src[ 2 ];
+  act_src[ 0 ] = ( struct ofp_action_output * ) src->actions;
+  act_src[ 0 ]->type = OFPAT_OUTPUT;
+  act_src[ 0 ]->len = 8;
+  act_src[ 0 ]->port = 1;
+  act_src[ 0 ]->max_len = 2048;
+  act_src[ 1 ] = ( struct ofp_action_output * ) ( ( char * ) src->actions + sizeof( struct ofp_action_output ) );
+  act_src[ 1 ]->type = OFPAT_OUTPUT;
+  act_src[ 1 ]->len = 8;
+  act_src[ 1 ]->port = 2;
+  act_src[ 1 ]->max_len = 2048;
+
+  hton_flow_stats( dst, src );
+
+  struct ofp_action_output *act_dst[ 2 ];
+  act_dst[ 0 ] = ( struct ofp_action_output * ) dst->actions;
+  act_dst[ 1 ] = ( struct ofp_action_output * ) ( ( char * ) dst->actions + sizeof( struct ofp_action_output ) );
+
+  assert_int_equal( htons( dst->length ), src->length );
+  assert_int_equal( dst->table_id, src->table_id );
+  hton_match( &src->match, &MATCH );
+  assert_memory_equal( &dst->match, &src->match, sizeof( struct ofp_match ) );
+  assert_int_equal( ( int ) htonl( dst->duration_sec ), ( int ) src->duration_sec );
+  assert_int_equal( ( int ) htonl( dst->duration_nsec ), ( int ) src->duration_nsec );
+  assert_int_equal( htons( dst->priority ), src->priority );
+  assert_int_equal( htons( dst->idle_timeout ), src->idle_timeout );
+  assert_int_equal( htons( dst->hard_timeout ), src->hard_timeout );
+  src->cookie = htonll( COOKIE );
+  assert_memory_equal( &dst->cookie, &src->cookie, sizeof( uint64_t ) );
+  src->packet_count = htonll( PACKET_COUNT );
+  assert_memory_equal( &dst->packet_count, &src->packet_count, sizeof( uint64_t ) );
+  src->byte_count = htonll( BYTE_COUNT );
+  assert_memory_equal( &dst->byte_count, &src->byte_count, sizeof( uint64_t ) );
+  assert_int_equal( act_dst[ 0 ]->type, htons( act_src[ 0 ]->type ) );
+  assert_int_equal( act_dst[ 0 ]->len, htons( act_src[ 0 ]->len ) );
+  assert_int_equal( act_dst[ 0 ]->port, htons( act_src[ 0 ]->port ) );
+  assert_int_equal( act_dst[ 0 ]->max_len, htons( act_src[ 0 ]->max_len ) );
+  assert_int_equal( act_dst[ 1 ]->type, htons( act_src[ 1 ]->type ) );
+  assert_int_equal( act_dst[ 1 ]->len, htons( act_src[ 1 ]->len ) );
+  assert_int_equal( act_dst[ 1 ]->port, htons( act_src[ 1 ]->port ) );
+  assert_int_equal( act_dst[ 1 ]->max_len, htons( act_src[ 1 ]->max_len ) );
+
+  xfree( src );
+  xfree( dst );
+}
+
+
+/********************************************************************************
+ * ntoh_aggregate_stats() test.
+ ********************************************************************************/
+
+void
+test_ntoh_aggregate_stats() {
+  struct ofp_aggregate_stats_reply dst;
+  struct ofp_aggregate_stats_reply src;
+
+  memset( &src, 0, sizeof( struct ofp_aggregate_stats_reply ) );
+  memset( &dst, 0, sizeof( struct ofp_aggregate_stats_reply ) );
+
+  src.packet_count = htonll( PACKET_COUNT );
+  src.byte_count = htonll( BYTE_COUNT );
+  src.flow_count = htonl( 1000 );
+
+  ntoh_aggregate_stats( &dst, &src );
+
+  assert_memory_equal( &dst.packet_count, &PACKET_COUNT, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.byte_count, &BYTE_COUNT, sizeof( uint64_t ) );
+  assert_int_equal( ( int ) htonl( dst.flow_count ), ( int ) src.flow_count );
+}
+
+
+/********************************************************************************
+ * ntoh_table_stats() test.
+ ********************************************************************************/
+
+void
+test_ntoh_table_stats() {
+  struct ofp_table_stats dst;
+  struct ofp_table_stats src;
+
+  memset( &src, 0, sizeof( struct ofp_table_stats ) );
+  memset( &dst, 0, sizeof( struct ofp_table_stats ) );
+
+  uint64_t lookup_count = 100000000;
+  uint64_t matched_count = 10000000;
+
+  src.table_id = 1;
+  memset( &src.name, '\0', OFP_MAX_TABLE_NAME_LEN );
+  memcpy( &src.name, TABLE_NAME, strlen( TABLE_NAME ) );
+  src.wildcards = htonl( OFPFW_ALL );
+  src.max_entries = htonl( 1000000 );
+  src.active_count = htonl( 1234 );
+  src.lookup_count = htonll( lookup_count );
+  src.matched_count = htonll( matched_count );
+
+  ntoh_table_stats( &dst, &src );
+
+  assert_int_equal( dst.table_id, src.table_id );
+  assert_memory_equal( &dst.name, &src.name, OFP_MAX_TABLE_NAME_LEN );
+  assert_int_equal( ( int ) htonl( dst.wildcards ), ( int ) src.wildcards );
+  assert_int_equal( ( int ) htonl( dst.max_entries ), ( int ) src.max_entries );
+  assert_int_equal( ( int ) htonl( dst.active_count ), ( int ) src.active_count );
+  assert_memory_equal( &dst.lookup_count, &lookup_count, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.matched_count, &matched_count, sizeof( uint64_t ) );
+}
+
+
+/********************************************************************************
+ * ntoh_port_stats() test.
+ ********************************************************************************/
+
+void
+test_ntoh_port_stats() {
+  struct ofp_port_stats dst;
+  struct ofp_port_stats src;
+
+  memset( &src, 0, sizeof( struct ofp_port_stats ) );
+  memset( &dst, 0, sizeof( struct ofp_port_stats ) );
+
+  uint64_t rx_packets = 8000;
+  uint64_t tx_packets = 7000;
+  uint64_t rx_bytes = 6000;
+  uint64_t tx_bytes = 5000;
+  uint64_t rx_dropped = 4000;
+  uint64_t tx_dropped = 3000;
+  uint64_t rx_errors = 2000;
+  uint64_t tx_errors = 1000;
+  uint64_t rx_frame_err = 900;
+  uint64_t rx_over_err = 100;
+  uint64_t rx_crc_err = 10;
+  uint64_t collisions = 1;
+
+  src.port_no = htons( 1 );
+  src.rx_packets = htonll( rx_packets );
+  src.tx_packets = htonll( tx_packets );
+  src.rx_bytes = htonll( rx_bytes );
+  src.tx_bytes = htonll( tx_bytes );
+  src.rx_dropped = htonll( rx_dropped );
+  src.tx_dropped = htonll( tx_dropped );
+  src.rx_errors = htonll( rx_errors );
+  src.tx_errors = htonll( tx_errors );
+  src.rx_frame_err = htonll( rx_frame_err );
+  src.rx_over_err = htonll( rx_over_err );
+  src.rx_crc_err = htonll( rx_crc_err );
+  src.collisions = htonll( collisions );
+
+  ntoh_port_stats( &dst, &src );
+
+  assert_int_equal( htons( dst.port_no ), src.port_no );
+  assert_memory_equal( &dst.rx_packets, &rx_packets, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.tx_packets, &tx_packets, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.rx_bytes, &rx_bytes, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.tx_bytes, &tx_bytes, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.rx_dropped, &rx_dropped, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.tx_dropped, &tx_dropped, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.rx_errors, &rx_errors, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.tx_errors, &tx_errors, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.rx_frame_err, &rx_frame_err, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.rx_over_err, &rx_over_err, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.rx_crc_err, &rx_crc_err, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.collisions, &collisions, sizeof( uint64_t ) );
+}
+
+
+/********************************************************************************
+ * ntoh_queue_stats() test.
+ ********************************************************************************/
+
+void
+test_ntoh_queue_stats() {
+  struct ofp_queue_stats dst;
+  struct ofp_queue_stats src;
+
+  memset( &src, 0, sizeof( struct ofp_queue_stats ) );
+  memset( &dst, 0, sizeof( struct ofp_queue_stats ) );
+
+  uint64_t tx_bytes = 10000000;
+  uint64_t tx_packets = 10000;
+  uint64_t tx_errors = 1;
+
+  src.port_no = htons( 1 );
+  src.queue_id = htonl( 3 );
+  src.tx_bytes = htonll( tx_bytes );
+  src.tx_packets = htonll( tx_packets );
+  src.tx_errors = htonll( tx_errors );
+
+  ntoh_queue_stats( &dst, &src );
+
+  assert_int_equal( htons( dst.port_no ), src.port_no );
+  assert_int_equal( ( int ) htonl( dst.queue_id ), ( int ) src.queue_id );
+  assert_memory_equal( &dst.tx_bytes, &tx_bytes, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.tx_packets, &tx_packets, sizeof( uint64_t ) );
+  assert_memory_equal( &dst.tx_errors, &tx_errors, sizeof( uint64_t ) );
+}
+
+
+/********************************************************************************
+ * ntoh_queue_property() tests.
+ ********************************************************************************/
+
+void
+test_ntoh_queue_property_with_OFPQT_NONE() {
+  struct ofp_queue_prop_header dst;
+  struct ofp_queue_prop_header src;
+
+  memset( &src, 0, sizeof( struct ofp_queue_prop_header ) );
+  memset( &dst, 0, sizeof( struct ofp_queue_prop_header ) );
+
+  src.property = htons( OFPQT_NONE );
+  src.len = htons( 8 );
+
+  ntoh_queue_property( &dst, &src );
+
+  assert_int_equal( htons( dst.property ), src.property );
+  assert_int_equal( htons( dst.len ), src.len );
+}
+
+
+void
+test_ntoh_queue_property_with_OFPQT_MIN_RATE() {
+  struct ofp_queue_prop_min_rate dst;
+  struct ofp_queue_prop_min_rate src;
+
+  memset( &src, 0, sizeof( struct ofp_queue_prop_min_rate ) );
+  memset( &dst, 0, sizeof( struct ofp_queue_prop_min_rate ) );
+
+  src.prop_header.property = htons( OFPQT_MIN_RATE );
+  src.prop_header.len = htons( 16 );
+  src.rate = htons( 500 );
+
+  ntoh_queue_property( ( struct ofp_queue_prop_header * ) &dst, ( struct ofp_queue_prop_header * ) &src );
+
+  assert_int_equal( htons( dst.prop_header.property ), src.prop_header.property );
+  assert_int_equal( htons( dst.prop_header.len ), src.prop_header.len );
+  assert_int_equal( htons( dst.rate ), src.rate );
+}
+
+
+/********************************************************************************
+ * hton_queue_property() tests.
+ ********************************************************************************/
+
+void
+test_hton_queue_property_with_OFPQT_NONE() {
+  struct ofp_queue_prop_header dst;
+  struct ofp_queue_prop_header src;
+
+  memset( &src, 0, sizeof( struct ofp_queue_prop_header ) );
+  memset( &dst, 0, sizeof( struct ofp_queue_prop_header ) );
+
+  src.property = OFPQT_NONE;
+  src.len = 8;
+
+  hton_queue_property( &dst, &src );
+
+  assert_int_equal( dst.property, htons( src.property ) );
+  assert_int_equal( dst.len, htons( src.len ) );
+}
+
+
+void
+test_hton_queue_property_with_OFPQT_MIN_RATE() {
+  struct ofp_queue_prop_min_rate dst;
+  struct ofp_queue_prop_min_rate src;
+
+  memset( &src, 0, sizeof( struct ofp_queue_prop_min_rate ) );
+  memset( &dst, 0, sizeof( struct ofp_queue_prop_min_rate ) );
+
+  src.prop_header.property = OFPQT_MIN_RATE;
+  src.prop_header.len = 16;
+  src.rate = 500;
+
+  hton_queue_property( ( struct ofp_queue_prop_header * ) &dst, ( struct ofp_queue_prop_header * ) &src );
+
+  assert_int_equal( dst.prop_header.property, htons( src.prop_header.property ) );
+  assert_int_equal( dst.prop_header.len, htons( src.prop_header.len ) );
+  assert_int_equal( dst.rate, htons( src.rate ) );
+}
+
+
+/********************************************************************************
+ * ntoh_packet_queue() tests.
+ ********************************************************************************/
+
+void
+test_ntoh_packet_queue_with_single_OFPQT_NONE() {
+  uint16_t length = ( uint16_t ) ( offsetof( struct ofp_packet_queue, properties ) + sizeof( struct ofp_queue_prop_header ) );
+
+  struct ofp_packet_queue *src = xmalloc( length );
+  struct ofp_packet_queue *dst = xmalloc( length );
+
+  memset( src, 0, length );
+  memset( dst, 0, length );
+
+  src->queue_id = htonl( 3 );
+  src->len = htons( length );
+  struct ofp_queue_prop_header *ph_src = src->properties;
+  ph_src->property = htons( OFPQT_NONE );
+  ph_src->len = htons( 8 );
+
+  ntoh_packet_queue( dst, src );
+
+  struct ofp_queue_prop_header *ph_dst = dst->properties;
+
+  assert_int_equal( ( int ) htonl( dst->queue_id ), ( int ) src->queue_id );
+  assert_int_equal( htons( dst->len ), src->len );
+  assert_int_equal( htons( ph_dst->property ), ph_src->property );
+  assert_int_equal( htons( ph_dst->len ), ph_src->len );
+
+  xfree( src );
+  xfree( dst );
+}
+
+
+void
+test_ntoh_packet_queue_with_single_OFPQT_MIN_RATE() {
+  uint16_t length = ( uint16_t ) ( offsetof( struct ofp_packet_queue, properties ) + sizeof( struct ofp_queue_prop_min_rate ) );
+
+  struct ofp_packet_queue *src = xmalloc( length );
+  struct ofp_packet_queue *dst = xmalloc( length );
+
+  memset( src, 0, length );
+  memset( dst, 0, length );
+
+  src->queue_id = htonl( 3 );
+  src->len = htons( length );
+  struct ofp_queue_prop_min_rate *pm_src = ( struct ofp_queue_prop_min_rate * ) src->properties;
+  pm_src->prop_header.property = htons( OFPQT_MIN_RATE );
+  pm_src->prop_header.len = htons( 16 );
+  pm_src->rate = htons( 500 );
+
+  ntoh_packet_queue( dst, src );
+
+  struct ofp_queue_prop_min_rate *pm_dst = ( struct ofp_queue_prop_min_rate * ) dst->properties;
+
+  assert_int_equal( ( int ) htonl( dst->queue_id ), ( int ) src->queue_id );
+  assert_int_equal( htons( dst->len ), src->len );
+  assert_int_equal( htons( pm_dst->prop_header.property ), pm_src->prop_header.property );
+  assert_int_equal( htons( pm_dst->prop_header.len ), pm_src->prop_header.len );
+  assert_int_equal( htons( pm_dst->rate ), pm_src->rate );
+
+  xfree( src );
+  xfree( dst );
+}
+
+
+void
+test_ntoh_packet_queue_with_OFPQT_NONE_and_OFPQT_MIN_RATE() {
+  uint16_t length = ( uint16_t ) ( offsetof( struct ofp_packet_queue, properties ) + sizeof( struct ofp_queue_prop_header ) + sizeof( struct ofp_queue_prop_min_rate ) );
+
+  struct ofp_packet_queue *src = xmalloc( length );
+  struct ofp_packet_queue *dst = xmalloc( length );
+
+  memset( src, 0, length );
+  memset( dst, 0, length );
+
+  src->queue_id = htonl( 3 );
+  src->len = htons( length );
+  struct ofp_queue_prop_header *ph_src = src->properties;
+  ph_src->property = htons( OFPQT_NONE );
+  ph_src->len = htons( 8 );
+  struct ofp_queue_prop_min_rate *pm_src = ( struct ofp_queue_prop_min_rate * ) ( ( char * ) src->properties + sizeof( struct ofp_queue_prop_header ) );
+  pm_src->prop_header.property = htons( OFPQT_MIN_RATE );
+  pm_src->prop_header.len = htons( 16 );
+  pm_src->rate = htons( 500 );
+
+  ntoh_packet_queue( dst, src );
+
+  struct ofp_queue_prop_header *ph_dst = dst->properties;
+  struct ofp_queue_prop_min_rate *pm_dst = ( struct ofp_queue_prop_min_rate * ) ( ( char * ) dst->properties + sizeof( struct ofp_queue_prop_header ) );
+
+  assert_int_equal( ( int ) htonl( dst->queue_id ), ( int ) src->queue_id );
+  assert_int_equal( htons( dst->len ), src->len );
+  assert_int_equal( htons( ph_dst->property ), ph_src->property );
+  assert_int_equal( htons( ph_dst->len ), ph_src->len );
+  assert_int_equal( htons( pm_dst->prop_header.property ),
+                    pm_src->prop_header.property );
+  assert_int_equal( htons( pm_dst->prop_header.len ),
+                    pm_src->prop_header.len );
+  assert_int_equal( htons( pm_dst->rate ), pm_src->rate );
+
+  xfree( src );
+  xfree( dst );
+}
+
+
+/********************************************************************************
+ * hton_packet_queue() tests.
+ ********************************************************************************/
+
+void
+test_hton_packet_queue_with_single_OFPQT_NONE() {
+  uint16_t length = ( uint16_t ) ( offsetof( struct ofp_packet_queue, properties ) + sizeof( struct ofp_queue_prop_header ) );
+
+  struct ofp_packet_queue *src = xmalloc( length );
+  struct ofp_packet_queue *dst = xmalloc( length );
+
+  memset( src, 0, length );
+  memset( dst, 0, length );
+
+  src->queue_id = 3;
+  src->len = length;
+  struct ofp_queue_prop_header *ph_src = src->properties;
+  ph_src->property = OFPQT_NONE;
+  ph_src->len = 8;
+
+  hton_packet_queue( dst, src );
+
+  struct ofp_queue_prop_header *ph_dst = dst->properties;
+
+  assert_int_equal( ( int ) dst->queue_id, ( int ) htonl( src->queue_id ) );
+  assert_int_equal( dst->len, htons( src->len ) );
+  assert_int_equal( ph_dst->property, htons( ph_src->property ) );
+  assert_int_equal( ph_dst->len, htons( ph_src->len ) );
+
+  xfree( src );
+  xfree( dst );
+}
+
+
+void
+test_hton_packet_queue_with_single_OFPQT_MIN_RATE() {
+  uint16_t length = ( uint16_t ) ( offsetof( struct ofp_packet_queue, properties ) + sizeof( struct ofp_queue_prop_min_rate ) );
+
+  struct ofp_packet_queue *src = xmalloc( length );
+  struct ofp_packet_queue *dst = xmalloc( length );
+
+  memset( src, 0, length );
+  memset( dst, 0, length );
+
+  src->queue_id = 3;
+  src->len = length;
+  struct ofp_queue_prop_min_rate *pm_src = ( struct ofp_queue_prop_min_rate * ) src->properties;
+  pm_src->prop_header.property = OFPQT_MIN_RATE;
+  pm_src->prop_header.len = 16;
+  pm_src->rate = 500;
+
+  hton_packet_queue( dst, src );
+
+  struct ofp_queue_prop_min_rate *pm_dst = ( struct ofp_queue_prop_min_rate * ) dst->properties;
+
+  assert_int_equal( ( int ) dst->queue_id, ( int ) htonl( src->queue_id ) );
+  assert_int_equal( dst->len, htons( src->len ) );
+  assert_int_equal( pm_dst->prop_header.property, htons( pm_src->prop_header.property ) );
+  assert_int_equal( pm_dst->prop_header.len, htons( pm_src->prop_header.len ) );
+  assert_int_equal( pm_dst->rate, htons( pm_src->rate ) );
+
+  xfree( src );
+  xfree( dst );
+}
+
+
+void
+test_hton_packet_queue_with_OFPQT_NONE_and_OFPQT_MIN_RATE() {
+  uint16_t length = ( uint16_t ) ( offsetof( struct ofp_packet_queue, properties ) + sizeof( struct ofp_queue_prop_header ) + sizeof( struct ofp_queue_prop_min_rate ) );
+
+  struct ofp_packet_queue *src = xmalloc( length );
+  struct ofp_packet_queue *dst = xmalloc( length );
+
+  memset( src, 0, length );
+  memset( dst, 0, length );
+
+  src->queue_id = 3;
+  src->len = length;
+  struct ofp_queue_prop_header *ph_src = src->properties;
+  ph_src->property = OFPQT_NONE;
+  ph_src->len = 8;
+  struct ofp_queue_prop_min_rate *pm_src = ( struct ofp_queue_prop_min_rate * ) ( ( char * ) src->properties + sizeof( struct ofp_queue_prop_header ) );
+  pm_src->prop_header.property = OFPQT_MIN_RATE;
+  pm_src->prop_header.len = 16;
+  pm_src->rate = 500;
+
+  hton_packet_queue( dst, src );
+
+  struct ofp_queue_prop_header *ph_dst = dst->properties;
+  struct ofp_queue_prop_min_rate *pm_dst = ( struct ofp_queue_prop_min_rate * ) ( ( char * ) dst->properties + sizeof( struct ofp_queue_prop_header ) );
+
+  assert_int_equal( ( int ) dst->queue_id, ( int ) htonl( src->queue_id ) );
+  assert_int_equal( dst->len, htons( src->len ) );
+  assert_int_equal( ph_dst->property, htons( ph_src->property ) );
+  assert_int_equal( ph_dst->len, htons( ph_src->len ) );
+  assert_int_equal( pm_dst->prop_header.property,
+                    htons( pm_src->prop_header.property ) );
+  assert_int_equal( pm_dst->prop_header.len,
+                    htons( pm_src->prop_header.len ) );
+  assert_int_equal( pm_dst->rate, htons( pm_src->rate ) );
+
+  xfree( src );
+  xfree( dst );
+}
+
+
+/********************************************************************************
+ * Run tests.
+ ********************************************************************************/
+
+int
+main() {
+  // FIXME: mockanize in setup()
+  die = mock_die;
+
+  const UnitTest tests[] = {
+    unit_test( test_ntoh_match ),
+    unit_test( test_ntoh_phy_port ),
+    unit_test( test_ntoh_action_output ),
+    unit_test( test_ntoh_action_vlan_vid ),
+    unit_test( test_ntoh_action_vlan_pcp ),
+    unit_test( test_ntoh_action_strip_vlan ),
+    unit_test( test_ntoh_action_dl_addr ),
+    unit_test( test_ntoh_action_nw_addr ),
+    unit_test( test_ntoh_action_nw_tos ),
+    unit_test( test_ntoh_action_tp_port ),
+    unit_test( test_ntoh_action_enqueue ),
+    unit_test( test_ntoh_action_vendor ),
+    unit_test( test_ntoh_action ),
+    unit_test( test_ntoh_action_with_undefined_action_type ),
+    unit_test( test_hton_action ),
+    unit_test( test_hton_action_with_undefined_action_type ),
+    unit_test( test_ntoh_flow_stats_without_action ),
+    unit_test( test_ntoh_flow_stats_with_single_output_action ),
+    unit_test( test_ntoh_flow_stats_with_two_output_actions ),
+    unit_test( test_hton_flow_stats_without_action ),
+    unit_test( test_hton_flow_stats_with_single_output_action ),
+    unit_test( test_hton_flow_stats_with_two_output_actions ),
+    unit_test( test_ntoh_aggregate_stats ),
+    unit_test( test_ntoh_table_stats ),
+    unit_test( test_ntoh_port_stats ),
+    unit_test( test_ntoh_queue_stats ),
+    unit_test( test_ntoh_queue_property_with_OFPQT_NONE ),
+    unit_test( test_ntoh_queue_property_with_OFPQT_MIN_RATE ),
+    unit_test( test_hton_queue_property_with_OFPQT_NONE ),
+    unit_test( test_hton_queue_property_with_OFPQT_MIN_RATE ),
+    unit_test( test_ntoh_packet_queue_with_single_OFPQT_NONE ),
+    unit_test( test_ntoh_packet_queue_with_single_OFPQT_MIN_RATE ),
+    unit_test( test_ntoh_packet_queue_with_OFPQT_NONE_and_OFPQT_MIN_RATE ),
+    unit_test( test_hton_packet_queue_with_single_OFPQT_NONE ),
+    unit_test( test_hton_packet_queue_with_single_OFPQT_MIN_RATE ),
+    unit_test( test_hton_packet_queue_with_OFPQT_NONE_and_OFPQT_MIN_RATE ),
+  };
+  return run_tests( tests );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */