/*
 * Unit tests of functions for creating OpenFlow messages.
 *
 * Author: Yasunori Nakazawa
 *
 * 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include "byteorder.h"
#include "checks.h"
#include "cmockery_trema.h"
#include "log.h"
#include "openflow_message.h"
#include "wrapper.h"


extern uint16_t get_actions_length( const openflow_actions *actions );
extern buffer * create_stats_request( const uint32_t transaction_id, const uint16_t type,
                                      const uint16_t length, const uint16_t flags );
extern buffer * create_stats_reply( const uint32_t transaction_id, const uint16_t type,
                                    const uint16_t length, const uint16_t flags );

static const uint16_t ARP_OP_MASK = 0x00ff; // 8bits
static const uint32_t BUFFER_ID = 0x12345678;
static const uint16_t NO_FLAGS = 0;
static const uint16_t NO_ERROR = 0;
static const uint16_t PRIORITY = 65535;
static const uint32_t MY_TRANSACTION_ID = 0x04030201;
static const uint16_t ONE_MINUTES_TIMEOUT = 60;
static const uint64_t ISSUED_COOKIE = 0x0102030405060708ULL;
static const uint64_t RECEIVED_PACKETS = 50000;
static const uint64_t RECEIVED_BYTES = 300000;
static const uint64_t TRANSMITTED_PACKETS = 50000;
static const uint64_t TRANSMITTED_BYTES = 300000;
static const uint32_t SUPPORTED_ENTRIES_IN_OFPST_TABLE = 10000;
static const uint32_t ACTIVE_ENTRIES_IN_OFPST_TABLE = 1000;
static const uint64_t PACKETS_LOOK_UP_IN_OFPST_TABLE = 10000;
static const uint64_t PACKETS_HIT_OFPST_TABLE = 100;
static const uint32_t VENDOR_ID = 0x00004cff;
static const uint16_t VENDOR_STATS_FLAG = 0xaabb;
static const uint8_t HW_ADDR[ OFP_ETH_ALEN ] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
static const uint32_t NW_ADDR = 0x12345678;
static const uint8_t NW_TOS = 0xfc;
static const uint16_t MAX_LENGTH_OF_SEND_PACKET = 128;
static const uint16_t SHORT_DATA_LENGTH = 32;
static const uint16_t LONG_DATA_LENGTH = 64;
static const struct ofp_match MATCH = { 0, 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 };
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 );


/********************************************************************************
 * Mock function.
 ********************************************************************************/

#define FAKE_PID 1234;

pid_t
mock_getpid() {
  return FAKE_PID;
}


void
mock_die( char *format, ... ) {
  UNUSED( format );
}


void
mock_debug( char *format, ... ) {
  UNUSED( format );
}


static logging_level
mock_get_logging_level() {
  return LOG_DEBUG;
}


/********************************************************************************
 * Common function.
 ********************************************************************************/

static buffer *
create_dummy_data( uint16_t length ) {
  buffer *data = alloc_buffer_with_length( length );
  void *p = append_back_buffer( data, length );
  memset( p, 0xaf, length );

  return data;
}


/********************************************************************************
 * Setup and teardown functions.
 ********************************************************************************/

static void
init() {
  init_openflow_message();
  get_logging_level = mock_get_logging_level;
}


static void
teardown() {
  init_openflow_message();
}


/********************************************************************************
 * Initialization test.
 ********************************************************************************/

static void
test_init_openflow_message() {
  bool ret;
  uint32_t transaction_id;
  pid_t pid = FAKE_PID;

  transaction_id = ( uint32_t ) ( pid << 16 ) + 1;

  ret = init_openflow_message();

  assert_true( ret );
  assert_int_equal( ( int ) get_transaction_id(), ( int ) transaction_id );
}


/********************************************************************************
 * get_transaction_id() tests.
 ********************************************************************************/

static void
test_get_transaction_id() {
  uint32_t transaction_id;
  pid_t pid = FAKE_PID;

  transaction_id = ( uint32_t ) ( pid << 16 ) + 1;

  assert_int_equal( ( int ) get_transaction_id(), ( int ) transaction_id );
}


static void
test_get_transaction_id_if_id_overflows() {
  int i;
  uint32_t transaction_id;
  pid_t pid = FAKE_PID;

  for ( i = 0; i < 0xffff; i++ ) {
    get_transaction_id();
  }

  transaction_id = ( uint32_t ) ( pid << 16 );

  assert_int_equal( ( int ) get_transaction_id(), ( int ) transaction_id );
}


/********************************************************************************
 * get_get_cookie() tests.
 ********************************************************************************/

static void
test_get_cookie() {
  pid_t pid = FAKE_PID;

  uint64_t expected_cookie = ( ( uint64_t ) pid << 48 ) + 1;
  uint64_t tmp_cookie = get_cookie();
  assert_memory_equal( &tmp_cookie, &expected_cookie, sizeof( uint64_t ) );
}


extern uint64_t cookie;

static void
test_get_cookie_if_cookie_overflows() {
  pid_t pid = FAKE_PID;
  cookie = ( ( uint64_t ) pid << 48 ) | ( UINT64_MAX >> 16 );

  uint64_t expected_cookie = ( ( uint64_t ) pid << 48 );
  uint64_t tmp_cookie = get_cookie();
  assert_memory_equal( &tmp_cookie, &expected_cookie, sizeof( uint64_t ) );
}


/********************************************************************************
 * Tests of functions for OFPT_HELLO.
 ********************************************************************************/

static void
test_create_hello() {
  buffer *buffer = create_hello( MY_TRANSACTION_ID );
  assert_true( buffer != NULL );

  struct ofp_header *hello = buffer->data;
  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_header ) );
  assert_int_equal( hello->version, OFP_VERSION );
  assert_int_equal( hello->type, OFPT_HELLO );
  assert_int_equal( ntohs( hello->length ), sizeof( struct ofp_header ) );
  assert_int_equal( ( int ) ntohl( hello->xid ), ( int ) MY_TRANSACTION_ID );

  free_buffer( buffer );
}


static void
test_validate_hello() {
  buffer *hello = create_hello( MY_TRANSACTION_ID );
  assert_true( validate_hello( hello ) == SUCCESS );
  free_buffer( hello );
}


static void
test_validate_hello_fails_with_NULL() {
  expect_assert_failure( validate_hello( NULL ) );
}


static void
test_validate_hello_fails_with_non_hello_message() {
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, NULL );
  assert_int_equal( ERROR_INVALID_TYPE, validate_hello( echo_request ) );
  free_buffer( echo_request );
}


/********************************************************************************
 * Tests of a function for OFPT_ERROR.
 ********************************************************************************/

static void
test_create_error() {
  uint16_t type = OFPET_HELLO_FAILED;
  uint16_t code = OFPHFC_INCOMPATIBLE;
  buffer *data;
  buffer *buffer;
  struct ofp_error_msg *error_msg;
  uint16_t length;

  data = create_hello( MY_TRANSACTION_ID );

  buffer = create_error( MY_TRANSACTION_ID, type, code, data );
  assert_true( buffer != NULL );

  error_msg = ( struct ofp_error_msg * ) buffer->data;
  length = ( uint16_t ) ( sizeof( struct ofp_error_msg ) + data->length );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( error_msg->header.version, OFP_VERSION );
  assert_int_equal( error_msg->header.type, OFPT_ERROR );
  assert_int_equal( ntohs( error_msg->header.length ), length );
  assert_int_equal( ( int ) ntohl( error_msg->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( error_msg->type ), type );
  assert_int_equal( ntohs( error_msg->code ), code );
  assert_memory_equal( error_msg->data, data->data, data->length );

  free_buffer( data );
  free_buffer( buffer );
}


static void
test_create_error_without_data() {
  uint16_t type = OFPET_HELLO_FAILED;
  uint16_t code = OFPHFC_INCOMPATIBLE;
  buffer *data = NULL;
  buffer *buffer;
  struct ofp_error_msg *error_msg;
  uint16_t length;

  buffer = create_error( MY_TRANSACTION_ID, type, code, data );
  assert_true( buffer != NULL );

  error_msg = ( struct ofp_error_msg * ) buffer->data;
  length = ( uint16_t ) ( sizeof( struct ofp_error_msg ) );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( error_msg->header.version, OFP_VERSION );
  assert_int_equal( error_msg->header.type, OFPT_ERROR );
  assert_int_equal( ntohs( error_msg->header.length ), length );
  assert_int_equal( ( int ) ntohl( error_msg->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( error_msg->type ), type );
  assert_int_equal( ntohs( error_msg->code ), code );

  free_buffer( buffer );
}


/********************************************************************************
 * Tests of functions for OFPT_ECHO_REQUEST.
 ********************************************************************************/

static void
test_create_echo_request() {
  buffer *body = create_dummy_data( SHORT_DATA_LENGTH );
  buffer *buffer = create_echo_request( MY_TRANSACTION_ID, body );
  assert_true( buffer != NULL );

  struct ofp_header *echo_request = buffer->data;
  uint16_t length = ( uint16_t ) ( sizeof( struct ofp_header ) + body->length );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( echo_request->version, OFP_VERSION );
  assert_int_equal( echo_request->type, OFPT_ECHO_REQUEST );
  assert_int_equal( ntohs( echo_request->length ), length );
  assert_int_equal( ( int ) ntohl( echo_request->xid ), ( int ) MY_TRANSACTION_ID );

  assert_memory_equal( ( char * ) buffer->data + sizeof( struct ofp_header ), body->data, body->length );

  free_buffer( body );
  free_buffer( buffer );
}


static void
test_create_echo_request_without_data() {
  buffer *buffer = create_echo_request( MY_TRANSACTION_ID, NULL );
  assert_true( buffer != NULL );

  struct ofp_header *echo_request = buffer->data;
  uint16_t length = ( uint16_t ) sizeof( struct ofp_header );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( echo_request->version, OFP_VERSION );
  assert_int_equal( echo_request->type, OFPT_ECHO_REQUEST );
  assert_int_equal( ntohs( echo_request->length ), length );
  assert_int_equal( ( int ) ntohl( echo_request->xid ), ( int ) MY_TRANSACTION_ID );

  free_buffer( buffer );
}


static void
test_validate_echo_request() {
  buffer *body = create_dummy_data( SHORT_DATA_LENGTH );
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, body );

  assert_true( validate_echo_request( echo_request ) == SUCCESS );

  free_buffer( body );
  free_buffer( echo_request );
}


static void
test_validate_echo_request_fails_with_NULL() {
  expect_assert_failure( validate_echo_request( NULL ) );
}


static void
test_validate_echo_request_fails_with_non_echo_request_message() {
  buffer *hello = create_hello( MY_TRANSACTION_ID );

  assert_int_equal( validate_echo_request( hello ), ERROR_INVALID_TYPE );

  free_buffer( hello );
}


/********************************************************************************
 * Tests of functions for OFPT_ECHO_REPLY.
 ********************************************************************************/

static void
test_create_echo_reply() {
  buffer *body = create_dummy_data( SHORT_DATA_LENGTH );
  buffer *buffer = create_echo_reply( MY_TRANSACTION_ID, body );
  assert_true( buffer != NULL );

  struct ofp_header *echo_reply = ( struct ofp_header * ) buffer->data;
  uint16_t length = ( uint16_t ) ( sizeof( struct ofp_header ) + body->length );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( echo_reply->version, OFP_VERSION );
  assert_int_equal( echo_reply->type, OFPT_ECHO_REPLY );
  assert_int_equal( ntohs( echo_reply->length ), length );
  assert_int_equal( ( int ) ntohl( echo_reply->xid ), ( int ) MY_TRANSACTION_ID );

  assert_memory_equal( ( char * ) buffer->data + sizeof( struct ofp_header ), body->data, body->length );

  free_buffer( body );
  free_buffer( buffer );
}


static void
test_create_echo_reply_without_data() {
  buffer *buffer = create_echo_reply( MY_TRANSACTION_ID, NULL );
  assert_true( buffer != NULL );

  struct ofp_header *echo_reply = ( struct ofp_header * ) buffer->data;
  uint16_t length = ( uint16_t ) sizeof( struct ofp_header );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( echo_reply->version, OFP_VERSION );
  assert_int_equal( echo_reply->type, OFPT_ECHO_REPLY );
  assert_int_equal( ntohs( echo_reply->length ), length );
  assert_int_equal( ( int ) ntohl( echo_reply->xid ), ( int ) MY_TRANSACTION_ID );

  free_buffer( buffer );
}


static void
test_validate_echo_reply() {
  buffer *body = create_dummy_data( SHORT_DATA_LENGTH );
  buffer *echo_reply = create_echo_reply( MY_TRANSACTION_ID, body );

  assert_true( validate_echo_reply( echo_reply ) == SUCCESS );

  free_buffer( body );
  free_buffer( echo_reply );
}


static void
test_validate_echo_reply_fails_with_NULL() {
  expect_assert_failure( validate_echo_reply( NULL ) );
}


static void
test_validate_echo_reply_fails_with_non_echo_reply_message() {
  buffer *hello = create_hello( MY_TRANSACTION_ID );

  assert_int_equal( validate_echo_reply( hello ), ERROR_INVALID_TYPE );

  free_buffer( hello );
}


/********************************************************************************
 * Tests of a function for OFPT_VENDOR.
 ********************************************************************************/

static void
test_create_vendor() {
  const uint16_t body_length = 128;

  buffer *body = create_dummy_data( body_length );
  buffer *buffer = create_vendor( MY_TRANSACTION_ID, VENDOR_ID, body );
  assert_true( buffer != NULL );

  assert_int_equal( ( int ) buffer->length,
                    ( int ) sizeof( struct ofp_vendor_header ) + body_length );

  struct ofp_vendor_header *vendor = buffer->data;

  assert_int_equal( vendor->header.version, OFP_VERSION );
  assert_int_equal( vendor->header.type, OFPT_VENDOR );
  assert_int_equal( ( int ) ntohs( vendor->header.length ),
                    ( int ) sizeof( struct ofp_vendor_header ) + body_length );
  assert_int_equal( ( int ) ntohl( vendor->header.xid ),
                    ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ( int ) ntohl( vendor->vendor ), ( int ) VENDOR_ID );
  assert_memory_equal( ( char * ) vendor + sizeof( struct ofp_vendor_header ),
                       body->data,
                       body_length );

  free_buffer( body );
  free_buffer( buffer );
}


static void
test_create_vendor_without_data() {
  buffer *buffer = create_vendor( MY_TRANSACTION_ID, VENDOR_ID, NULL );
  assert_true( buffer != NULL );

  assert_int_equal( ( int ) buffer->length,
                    sizeof( struct ofp_vendor_header ) );

  struct ofp_vendor_header *vendor = buffer->data;

  assert_int_equal( vendor->header.version, OFP_VERSION );
  assert_int_equal( vendor->header.type, OFPT_VENDOR );
  assert_int_equal( ( int ) ntohs( vendor->header.length ),
                    sizeof( struct ofp_vendor_header ) );
  assert_int_equal( ( int ) ntohl( vendor->header.xid ),
                    ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ( int ) ntohl( vendor->vendor ), ( int ) VENDOR_ID );

  free_buffer( buffer );
}


/********************************************************************************
 * Tests of functions for OFPT_FEATURES_REQUEST.
 ********************************************************************************/

static void
test_create_features_request() {
  buffer *buffer = create_features_request( MY_TRANSACTION_ID );
  assert_true( buffer != NULL );

  struct ofp_header *features_request = ( struct ofp_header * ) buffer->data;
  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_header ) );
  assert_int_equal( features_request->version, OFP_VERSION );
  assert_int_equal( features_request->type, OFPT_FEATURES_REQUEST );
  assert_int_equal( ntohs( features_request->length ), sizeof( struct ofp_header ) );
  assert_int_equal( ( int ) ntohl( features_request->xid ), ( int ) MY_TRANSACTION_ID );

  free_buffer( buffer );
}


static void
test_validate_features_request() {
  buffer *features_request = create_features_request( MY_TRANSACTION_ID );
  assert_true( validate_features_request( features_request ) == SUCCESS );
  free_buffer( features_request );
}


static void
test_validate_features_request_fails_with_NULL() {
  expect_assert_failure( validate_features_request( NULL ) );
}


static void
test_validate_features_request_fails_with_non_features_request_message() {
  buffer *hello = create_hello( MY_TRANSACTION_ID );
  assert_int_equal( validate_features_request( hello ), ERROR_INVALID_TYPE );
  free_buffer( hello );
}


/********************************************************************************
 * Test of a function for OFPT_GET_CONFIG_REQUEST.
 ********************************************************************************/

static void
test_create_get_config_request() {
  buffer *buffer;
  struct ofp_header *get_config_request;

  buffer = create_get_config_request( MY_TRANSACTION_ID );
  assert_true( buffer != NULL );

  get_config_request = buffer->data;

  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_header ) );
  assert_int_equal( get_config_request->version, OFP_VERSION );
  assert_int_equal( get_config_request->type, OFPT_GET_CONFIG_REQUEST );
  assert_int_equal( ntohs( get_config_request->length ), sizeof( struct ofp_header ) );
  assert_int_equal( ( int ) ntohl( get_config_request->xid ), ( int ) MY_TRANSACTION_ID );

  free_buffer( buffer );
}


/********************************************************************************
 * Test of a function for OFPT_GET_CONFIG_REPLY.
 ********************************************************************************/

static void
test_create_get_config_reply() {
  uint16_t flags = OFPC_FRAG_NORMAL;
  uint16_t miss_send_len = OFP_DEFAULT_MISS_SEND_LEN;
  buffer *buffer;
  struct ofp_switch_config *switch_config;

  buffer = create_get_config_reply( MY_TRANSACTION_ID, flags, miss_send_len );
  assert_true( buffer != NULL );

  switch_config = ( struct ofp_switch_config * ) buffer->data;

  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_switch_config ) );
  assert_int_equal( switch_config->header.version, OFP_VERSION );
  assert_int_equal( switch_config->header.type, OFPT_GET_CONFIG_REPLY );
  assert_int_equal( ntohs( switch_config->header.length ), sizeof( struct ofp_switch_config ) );
  assert_int_equal( ( int ) ntohl( switch_config->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( switch_config->flags ), flags );
  assert_int_equal( ntohs( switch_config->miss_send_len ), miss_send_len );

  free_buffer( buffer );
}


/********************************************************************************
 * Tests of functions for OFPT_SET_CONFIG.
 ********************************************************************************/

static void
test_create_set_config() {
  buffer *buffer = create_set_config( MY_TRANSACTION_ID, OFPC_FRAG_NORMAL, OFP_DEFAULT_MISS_SEND_LEN );
  assert_true( buffer != NULL );

  struct ofp_switch_config *switch_config = buffer->data;
  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_switch_config ) );
  assert_int_equal( switch_config->header.version, OFP_VERSION );
  assert_int_equal( switch_config->header.type, OFPT_SET_CONFIG );
  assert_int_equal( ntohs( switch_config->header.length ), sizeof( struct ofp_switch_config ) );
  assert_int_equal( ( int ) ntohl( switch_config->header.xid ), ( int ) MY_TRANSACTION_ID );
  assert_int_equal( ntohs( switch_config->flags ), OFPC_FRAG_NORMAL );
  assert_int_equal( ntohs( switch_config->miss_send_len ), OFP_DEFAULT_MISS_SEND_LEN );

  free_buffer( buffer );
}


static void
test_validate_set_config() {
  buffer *set_config = create_set_config( MY_TRANSACTION_ID, OFPC_FRAG_NORMAL, OFP_DEFAULT_MISS_SEND_LEN );
  assert_true( validate_set_config( set_config ) == SUCCESS );
  free_buffer( set_config );
}


static void
test_validate_set_config_fails_with_NULL() {
  expect_assert_failure( validate_set_config( NULL ) );
}


static void
test_validate_set_config_fails_with_non_set_config_message() {
  buffer *hello = create_hello( MY_TRANSACTION_ID );
  assert_int_equal( validate_set_config( hello ), ERROR_INVALID_TYPE );
  free_buffer( hello );
}


/********************************************************************************
 * Test of a function for OFPT_FLOW_REMOVED.
 ********************************************************************************/

static void
test_create_flow_removed() {
  uint64_t cookie = 0x0102030405060708ULL;
  uint8_t reason = OFPRR_IDLE_TIMEOUT;
  uint32_t duration_sec = 180;
  uint32_t duration_nsec = 10000;
  uint16_t idle_timeout = 60;
  uint64_t packet_count = 1000;
  uint64_t byte_count = 100000;
  buffer *buffer;
  struct ofp_flow_removed *flow_removed;
  uint64_t tmp;

  buffer = create_flow_removed( MY_TRANSACTION_ID, MATCH, cookie, PRIORITY, reason, duration_sec,
                                duration_nsec, idle_timeout, packet_count, byte_count );
  assert_true( buffer != NULL );

  flow_removed = buffer->data;

  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_flow_removed ) );
  assert_int_equal( flow_removed->header.version, OFP_VERSION );
  assert_int_equal( flow_removed->header.type, OFPT_FLOW_REMOVED );
  assert_int_equal( ntohs( flow_removed->header.length ), sizeof( struct ofp_flow_removed ) );
  assert_int_equal( ( int ) ntohl( flow_removed->header.xid ), ( int ) MY_TRANSACTION_ID );

  ntoh_match( &flow_removed->match, &flow_removed->match );
  assert_memory_equal( &flow_removed->match, &MATCH, sizeof( MATCH ) );

  tmp = ntohll( flow_removed->cookie );
  assert_memory_equal( &tmp, &cookie, sizeof( cookie ) );
  assert_int_equal( ntohs( flow_removed->priority ), PRIORITY );
  assert_int_equal( flow_removed->reason, reason );
  assert_int_equal( ( int ) ntohl( flow_removed->duration_sec ), ( int ) duration_sec );
  assert_int_equal( ( int ) ntohl( flow_removed->duration_nsec ), ( int ) duration_nsec );
  assert_int_equal( ntohs( flow_removed->idle_timeout ), idle_timeout );
  tmp = ntohll( flow_removed->packet_count );
  assert_memory_equal( &tmp, &packet_count, sizeof( packet_count ) );
  tmp = ntohll( flow_removed->byte_count );
  assert_memory_equal( &tmp, &byte_count, sizeof( byte_count ) );

  {
    void *pad = xmalloc( sizeof( flow_removed->pad ) );
    memset( pad, 0, sizeof( flow_removed->pad ) );
    assert_memory_equal( flow_removed->pad, pad, sizeof( flow_removed->pad ) );
    xfree( pad );

    void *pad2 = xmalloc( sizeof( flow_removed->pad2 ) );
    memset( pad2, 0, sizeof( flow_removed->pad2 ) );
    assert_memory_equal( flow_removed->pad2, pad2, sizeof( flow_removed->pad2 ) );
    xfree( pad2 );
  }

  free_buffer( buffer );
}


/********************************************************************************
 * Test of a function for OFPT_PORT_STATUS.
 ********************************************************************************/

static void
test_create_port_status() {
  uint8_t reason = OFPPR_ADD;
  struct ofp_phy_port desc;
  buffer *buffer;
  struct ofp_port_status *port_status;

  desc.port_no = 1;
  memcpy( desc.hw_addr, HW_ADDR, sizeof( desc.hw_addr ) );
  memset( desc.name, '\0', OFP_MAX_PORT_NAME_LEN );
  strcpy( desc.name, "Navy" );
  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( MY_TRANSACTION_ID, reason, desc );
  assert_true( buffer != NULL );

  port_status = buffer->data;

  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_port_status ) );
  assert_int_equal( port_status->header.version, OFP_VERSION );
  assert_int_equal( port_status->header.type, OFPT_PORT_STATUS );
  assert_int_equal( ntohs( port_status->header.length ), sizeof( struct ofp_port_status ) );
  assert_int_equal( ( int ) ntohl( port_status->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( port_status->reason, reason );
  {
    void *pad = xmalloc( sizeof( port_status->pad ) );
    memset( pad, 0, sizeof( port_status->pad ) );
    assert_memory_equal( port_status->pad, pad, sizeof( port_status->pad ) );
    xfree( pad );
  }
  {
    struct ofp_phy_port d;
    ntoh_phy_port( &d, &port_status->desc );
    assert_memory_equal( &d, &desc, sizeof( struct ofp_phy_port ) );
  }

  free_buffer( buffer );
}


/********************************************************************************
 * Test of a function for OFPT_PORT_MOD.
 ********************************************************************************/

static void
test_create_port_mod() {
  uint16_t port_no = 1;
  uint32_t config = OFPPC_PORT_DOWN;
  uint32_t mask = 0xffffffff;
  uint32_t advertise = 1;
  buffer *buffer;
  struct ofp_port_mod *port_mod;

  buffer = create_port_mod( MY_TRANSACTION_ID, port_no, HW_ADDR, config, mask, advertise );
  assert_true( buffer != NULL );

  port_mod = ( struct ofp_port_mod * ) buffer->data;

  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_port_mod ) );
  assert_int_equal( port_mod->header.version, OFP_VERSION );
  assert_int_equal( port_mod->header.type, OFPT_PORT_MOD );
  assert_int_equal( ntohs( port_mod->header.length ), sizeof( struct ofp_port_mod ) );
  assert_int_equal( ( int ) ntohl( port_mod->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( port_mod->port_no ), port_no );
  assert_memory_equal( port_mod->hw_addr, HW_ADDR, sizeof( HW_ADDR ) );
  assert_int_equal( ( int ) ntohl( port_mod->config ), ( int ) config );
  assert_int_equal( ( int ) ntohl( port_mod->mask ), ( int ) mask );
  assert_int_equal( ( int ) ntohl( port_mod->advertise ), ( int ) advertise );

  {
    void *pad = xmalloc( sizeof( port_mod->pad ) );
    memset( pad, 0, sizeof( port_mod->pad ) );
    assert_memory_equal( port_mod->pad, pad, sizeof( port_mod->pad ) );
    xfree( pad );
  }

  free_buffer( buffer );
}


/********************************************************************************
 * Test of functions for creating/deleting actions.
 ********************************************************************************/

static void
test_create_and_delete_actions() {
  openflow_actions *actions = create_actions();
  bool ret;

  assert_true( actions != NULL );
  assert_int_equal( actions->n_actions, 0 );

  ret = delete_actions( actions );
  assert_true( ret );

  actions = NULL;
  expect_assert_failure( delete_actions( NULL ) );
}


/********************************************************************************
 * append_action_output() test.
 ********************************************************************************/

static void
test_append_action_output() {
  openflow_actions *actions = NULL;
  uint16_t port = 1;
  uint16_t max_len = 128;
  struct ofp_action_output *action_output;
  bool ret;

  expect_assert_failure( append_action_output( actions, port, max_len ) );

  actions = create_actions();

  ret = append_action_output( actions, port, max_len );
  assert_true( ret );

  action_output = actions->list->data;

  assert_int_equal( action_output->type, OFPAT_OUTPUT );
  assert_int_equal( action_output->len, sizeof( struct ofp_action_output ) );
  assert_int_equal( action_output->port, port );
  assert_int_equal( action_output->max_len, max_len );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * append_action_set_vlan_vid() test.
 ********************************************************************************/

static void
test_append_action_set_vlan_vid() {
  openflow_actions *actions = NULL;
  uint16_t vlan_vid = 0x0001;
  struct ofp_action_vlan_vid *action_vlan_vid;
  bool ret;

  expect_assert_failure( append_action_set_vlan_vid( actions, vlan_vid ) );

  actions = create_actions();
  vlan_vid = 0xffff;

  expect_assert_failure( append_action_set_vlan_vid( actions, vlan_vid ) );

  vlan_vid = 0x0001;

  ret = append_action_set_vlan_vid( actions, vlan_vid );
  assert_true( ret );

  action_vlan_vid = actions->list->data;

  assert_int_equal( action_vlan_vid->type, OFPAT_SET_VLAN_VID );
  assert_int_equal( action_vlan_vid->len, sizeof( struct ofp_action_vlan_vid ) );
  assert_int_equal( action_vlan_vid->vlan_vid, vlan_vid );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * append_action_set_vlan_pcp() test.
 ********************************************************************************/

static void
test_append_action_set_vlan_pcp() {
  openflow_actions *actions = NULL;
  uint8_t vlan_pcp = 0x1;
  struct ofp_action_vlan_pcp *action_vlan_pcp;
  bool ret;

  expect_assert_failure( append_action_set_vlan_pcp( actions, vlan_pcp ) );

  actions = create_actions();
  vlan_pcp = 0xf;

  expect_assert_failure( append_action_set_vlan_pcp( actions, vlan_pcp ) );

  vlan_pcp = 0x1;

  ret = append_action_set_vlan_pcp( actions, vlan_pcp );
  assert_true( ret );

  action_vlan_pcp = actions->list->data;

  assert_int_equal( action_vlan_pcp->type, OFPAT_SET_VLAN_PCP );
  assert_int_equal( action_vlan_pcp->len, sizeof( struct ofp_action_vlan_pcp ) );
  assert_int_equal( action_vlan_pcp->vlan_pcp, vlan_pcp );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * append_action_strip_vlan() test.
 ********************************************************************************/

static void
test_append_action_strip_vlan() {
  openflow_actions *actions = NULL;
  struct ofp_action_header *action_strip_vlan;
  bool ret;

  expect_assert_failure( append_action_strip_vlan( actions ) );

  actions = create_actions();

  ret = append_action_strip_vlan( actions );
  assert_true( ret );

  action_strip_vlan = actions->list->data;

  assert_int_equal( action_strip_vlan->type, OFPAT_STRIP_VLAN );
  assert_int_equal( action_strip_vlan->len, sizeof( struct ofp_action_header ) );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * append_action_set_dl_src() test.
 ********************************************************************************/

static void
test_append_action_set_dl_src() {
  openflow_actions *actions = NULL;
  struct ofp_action_dl_addr *action_dl_addr;
  bool ret;

  expect_assert_failure( append_action_set_dl_src( actions, HW_ADDR ) );

  actions = create_actions();

  ret = append_action_set_dl_src( actions, HW_ADDR );
  assert_true( ret );

  action_dl_addr = actions->list->data;

  assert_int_equal( action_dl_addr->type, OFPAT_SET_DL_SRC );
  assert_int_equal( action_dl_addr->len, sizeof( struct ofp_action_dl_addr ) );
  assert_memory_equal( action_dl_addr->dl_addr, HW_ADDR, OFP_ETH_ALEN );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * append_action_set_dl_dst() test.
 ********************************************************************************/

static void
test_append_action_set_dl_dst() {
  openflow_actions *actions = NULL;
  struct ofp_action_dl_addr *action_dl_addr;
  bool ret;

  expect_assert_failure( append_action_set_dl_dst( actions, HW_ADDR ) );

  actions = create_actions();

  ret = append_action_set_dl_dst( actions, HW_ADDR );
  assert_true( ret );

  action_dl_addr = actions->list->data;

  assert_int_equal( action_dl_addr->type, OFPAT_SET_DL_DST );
  assert_int_equal( action_dl_addr->len, sizeof( struct ofp_action_dl_addr ) );
  assert_memory_equal( action_dl_addr->dl_addr, HW_ADDR, OFP_ETH_ALEN );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * append_action_set_nw_src() test.
 ********************************************************************************/

static void
test_append_action_set_nw_src() {
  openflow_actions *actions = NULL;
  struct ofp_action_nw_addr *action_nw_addr;
  bool ret;

  expect_assert_failure( append_action_set_nw_src( actions, NW_ADDR ) );

  actions = create_actions();

  ret = append_action_set_nw_src( actions, NW_ADDR );
  assert_true( ret );

  action_nw_addr = actions->list->data;

  assert_int_equal( action_nw_addr->type, OFPAT_SET_NW_SRC );
  assert_int_equal( action_nw_addr->len, sizeof( struct ofp_action_nw_addr ) );
  assert_int_equal( ( int ) action_nw_addr->nw_addr, ( int ) NW_ADDR );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * append_action_set_nw_dst() test.
 ********************************************************************************/

static void
test_append_action_set_nw_dst() {
  openflow_actions *actions = NULL;
  struct ofp_action_nw_addr *action_nw_addr;
  bool ret;

  expect_assert_failure( append_action_set_nw_dst( actions, NW_ADDR ) );

  actions = create_actions();

  ret = append_action_set_nw_dst( actions, NW_ADDR );
  assert_true( ret );

  action_nw_addr = actions->list->data;

  assert_int_equal( action_nw_addr->type, OFPAT_SET_NW_DST );
  assert_int_equal( action_nw_addr->len, sizeof( struct ofp_action_nw_addr ) );
  assert_int_equal( ( int ) action_nw_addr->nw_addr, ( int ) NW_ADDR );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * append_action_set_nw_tos() test.
 ********************************************************************************/

static void
test_append_action_set_nw_tos() {
  openflow_actions *actions = NULL;
  uint8_t nw_tos = 0xfc;
  struct ofp_action_nw_tos *action_nw_tos;
  bool ret;

  expect_assert_failure( append_action_set_nw_tos( actions, nw_tos ) );

  actions = create_actions();
  nw_tos = 0xff;

  expect_assert_failure( append_action_set_nw_tos( actions, nw_tos ) );

  nw_tos = 0xfc;

  ret = append_action_set_nw_tos( actions, nw_tos );
  assert_true( ret );

  action_nw_tos = actions->list->data;

  assert_int_equal( action_nw_tos->type, OFPAT_SET_NW_TOS );
  assert_int_equal( action_nw_tos->len, sizeof( struct ofp_action_nw_tos ) );
  assert_int_equal( action_nw_tos->nw_tos, nw_tos );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * append_action_set_tp_src() test.
 ********************************************************************************/

static void
test_append_action_set_tp_src() {
  openflow_actions *actions = NULL;
  uint16_t tp_port = 1;
  struct ofp_action_tp_port *action_tp_port;
  bool ret;

  expect_assert_failure( append_action_set_tp_src( actions, tp_port ) );

  actions = create_actions();

  ret = append_action_set_tp_src( actions, tp_port );
  assert_true( ret );

  action_tp_port = actions->list->data;

  assert_int_equal( action_tp_port->type, OFPAT_SET_TP_SRC );
  assert_int_equal( action_tp_port->len, sizeof( struct ofp_action_tp_port ) );
  assert_int_equal( action_tp_port->tp_port, tp_port );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * append_action_set_tp_dst() test.
 ********************************************************************************/

static void
test_append_action_set_tp_dst() {
  openflow_actions *actions = NULL;
  uint16_t tp_port = 1;
  struct ofp_action_tp_port *action_tp_port;
  bool ret;

  expect_assert_failure( append_action_set_tp_dst( actions, tp_port ) );

  actions = create_actions();

  ret = append_action_set_tp_dst( actions, tp_port );
  assert_true( ret );

  action_tp_port = actions->list->data;

  assert_int_equal( action_tp_port->type, OFPAT_SET_TP_DST );
  assert_int_equal( action_tp_port->len, sizeof( struct ofp_action_tp_port ) );
  assert_int_equal( action_tp_port->tp_port, tp_port );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * append_action_enqueue() test.
 ********************************************************************************/

static void
test_append_action_enqueue() {
  openflow_actions *actions = NULL;
  uint16_t port = 1;
  uint32_t queue_id = 10;
  struct ofp_action_enqueue *action_enqueue;
  bool ret;

  expect_assert_failure( append_action_enqueue( actions, port, queue_id ) );

  actions = create_actions();

  ret = append_action_enqueue( actions, port, queue_id );
  assert_true( ret );

  action_enqueue = actions->list->data;

  assert_int_equal( action_enqueue->type, OFPAT_ENQUEUE );
  assert_int_equal( action_enqueue->len, sizeof( struct ofp_action_enqueue ) );
  assert_int_equal( action_enqueue->port, port );
  assert_int_equal( ( int ) action_enqueue->queue_id, ( int ) queue_id );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * append_action_vendor() test.
 ********************************************************************************/

static void
test_append_action_vendor() {
  openflow_actions *actions = NULL;
  uint32_t vendor = 1;
  buffer *body;
  struct ofp_action_vendor_header *action_vendor;
  uint16_t length;
  bool ret;

  body = create_dummy_data( SHORT_DATA_LENGTH );

  length = ( uint16_t ) ( sizeof( struct ofp_action_vendor_header ) + body->length );

  expect_assert_failure( append_action_vendor( actions, vendor, body ) );

  actions = create_actions();

  ret = append_action_vendor( actions, vendor, body );
  assert_true( ret );

  action_vendor = actions->list->data;

  assert_int_equal( action_vendor->type, OFPAT_VENDOR );
  assert_int_equal( action_vendor->len, length );
  assert_int_equal( ( int ) action_vendor->vendor, ( int ) vendor );

  assert_int_equal( actions->n_actions, 1 );

  free_buffer( body );
  delete_actions( actions );
}


/********************************************************************************
 * append_action_vendor_without_data() test.
 ********************************************************************************/

static void
test_append_action_vendor_without_data() {
  openflow_actions *actions = NULL;
  uint32_t vendor = 1;
  buffer *body = NULL;
  struct ofp_action_vendor_header *action_vendor;
  uint16_t length;
  bool ret;

  length = ( uint16_t ) sizeof( struct ofp_action_vendor_header );

  expect_assert_failure( append_action_vendor( actions, vendor, body ) );

  actions = create_actions();

  ret = append_action_vendor( actions, vendor, body );
  assert_true( ret );

  action_vendor = actions->list->data;

  assert_int_equal( action_vendor->type, OFPAT_VENDOR );
  assert_int_equal( action_vendor->len, length );
  assert_int_equal( ( int ) action_vendor->vendor, ( int ) vendor );

  assert_int_equal( actions->n_actions, 1 );

  delete_actions( actions );
}


/********************************************************************************
 * create_packet_out() tests.
 ********************************************************************************/

static void
test_create_packet_out() {
  uint16_t in_port = 2;
  uint16_t port = 1;
  uint16_t max_len = 128;
  openflow_actions *actions;
  buffer *expected_data;
  buffer *buffer;
  struct ofp_packet_out *packet_out;
  uint16_t actions_len;
  uint16_t length;

  actions = create_actions();
  append_action_output( actions, port, max_len );

  expected_data = create_dummy_data( LONG_DATA_LENGTH );

  buffer = create_packet_out( MY_TRANSACTION_ID, BUFFER_ID, in_port, actions, expected_data );
  assert_true( buffer != NULL );

  packet_out = buffer->data;

  actions_len = get_actions_length( actions );
  length = ( uint16_t ) ( sizeof( struct ofp_packet_out ) + actions_len + expected_data->length );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( packet_out->header.version, OFP_VERSION );
  assert_int_equal( packet_out->header.type, OFPT_PACKET_OUT );
  assert_int_equal( ntohs( packet_out->header.length ), length );
  assert_int_equal( ( int ) ntohl( packet_out->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ( int ) ntohl( packet_out->buffer_id ), ( int ) BUFFER_ID );
  assert_int_equal( ntohs( packet_out->in_port ), in_port );
  assert_int_equal( ntohs( packet_out->actions_len ), actions_len );

  {
    void *a = packet_out->actions;
    list_element *expected_action = actions->list;

    while ( expected_action != NULL ) {
      struct ofp_action_header tmp_a;
      ntoh_action( &tmp_a, ( struct ofp_action_header * ) a );

      struct ofp_action_header *expected_action_header = expected_action->data;

      assert_int_equal( tmp_a.type, expected_action_header->type );
      assert_int_equal( tmp_a.len, expected_action_header->len );
      assert_memory_equal( tmp_a.pad, expected_action_header->pad, sizeof( expected_action_header->pad ) );

      a = ( void * ) ( ( char * ) a + tmp_a.len );
      expected_action = expected_action->next;
    }
  }

  void *d = ( void * ) ( ( char * ) buffer->data + sizeof( struct ofp_packet_out ) + actions_len );
  assert_memory_equal( d, expected_data->data, expected_data->length );

  assert_int_equal( actions->n_actions, 1 );

  free_buffer( expected_data );
  free_buffer( buffer );
  delete_actions( actions );
}


static void
test_create_packet_out_without_actions() {
  uint16_t in_port = 1;
  openflow_actions *actions = NULL;
  buffer *expected_data;
  buffer *buffer;
  struct ofp_packet_out *packet_out;
  uint16_t length;

  expected_data = create_dummy_data( SHORT_DATA_LENGTH );

  buffer = create_packet_out( MY_TRANSACTION_ID, BUFFER_ID, in_port, actions, expected_data );
  assert_true( buffer != NULL );

  packet_out = buffer->data;

  length = ( uint16_t ) ( sizeof( struct ofp_packet_out ) + expected_data->length );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( packet_out->header.version, OFP_VERSION );
  assert_int_equal( packet_out->header.type, OFPT_PACKET_OUT );
  assert_int_equal( ntohs( packet_out->header.length ), length );
  assert_int_equal( ( int ) ntohl( packet_out->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ( int ) ntohl( packet_out->buffer_id ), ( int ) BUFFER_ID );
  assert_int_equal( ntohs( packet_out->in_port ), in_port );
  assert_int_equal( ntohs( packet_out->actions_len ), 0 );

  void *d = ( void * ) ( ( char * ) buffer->data + sizeof( struct ofp_packet_out ) );
  assert_memory_equal( d, expected_data->data, expected_data->length );

  free_buffer( expected_data );
  free_buffer( buffer );
}


/********************************************************************************
 * create_flow_mod() test.
 ********************************************************************************/

static void
test_create_flow_mod() {
  uint64_t cookie = 10;
  uint16_t command = OFPFC_ADD;
  uint16_t idle_timeout = 5;
  uint16_t hard_timeout = 10;
  uint32_t buffer_id = 10;
  uint16_t out_port = UINT16_MAX;
  uint16_t flags = OFPFF_CHECK_OVERLAP | OFPFF_SEND_FLOW_REM;
  openflow_actions *actions;
  uint16_t port = 1;
  uint16_t max_len = 128;
  buffer *buffer;
  struct ofp_flow_mod *flow_mod;
  uint16_t actions_len;
  uint16_t length;
  uint64_t tmp;

  actions = create_actions();
  append_action_output( actions, port, max_len );

  actions_len = get_actions_length( actions );

  buffer = create_flow_mod( MY_TRANSACTION_ID, MATCH, cookie, command, idle_timeout,
                            hard_timeout, PRIORITY, buffer_id, out_port, flags, actions );
  assert_true( buffer != NULL );

  flow_mod = ( struct ofp_flow_mod * ) buffer->data;

  length = ( uint16_t ) ( sizeof( struct ofp_flow_mod ) + actions_len );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( flow_mod->header.version, OFP_VERSION );
  assert_int_equal( flow_mod->header.type, OFPT_FLOW_MOD );
  assert_int_equal( ntohs( flow_mod->header.length ), length );
  assert_int_equal( ( int ) ntohl( flow_mod->header.xid ), ( int ) MY_TRANSACTION_ID );

  ntoh_match( &flow_mod->match, &flow_mod->match );
  assert_memory_equal( &flow_mod->match, &MATCH, sizeof( MATCH ) );

  tmp = ntohll( flow_mod->cookie );
  assert_memory_equal( &tmp, &cookie, sizeof( cookie ) );
  assert_int_equal( ntohs( flow_mod->idle_timeout ), idle_timeout );
  assert_int_equal( ntohs( flow_mod->hard_timeout ), hard_timeout );
  assert_int_equal( ntohs( flow_mod->priority ), PRIORITY );
  assert_int_equal( ( int ) ntohl( flow_mod->buffer_id ), ( int ) buffer_id );
  assert_int_equal( ntohs( flow_mod->out_port ), out_port );
  assert_int_equal( ntohs( flow_mod->flags ), flags );

  {
    void *a = flow_mod->actions;
    list_element *expected_action = actions->list;

    while ( expected_action != NULL ) {
      struct ofp_action_header tmp_a;
      ntoh_action( &tmp_a, ( struct ofp_action_header * ) a );

      struct ofp_action_header *expected_action_header = expected_action->data;

      assert_int_equal( tmp_a.type, expected_action_header->type );
      assert_int_equal( tmp_a.len, expected_action_header->len );
      assert_memory_equal( tmp_a.pad, expected_action_header->pad, sizeof( expected_action_header->pad ) );

      a = ( void * ) ( ( char * ) a + tmp_a.len );
      expected_action = expected_action->next;
    }
  }

  assert_int_equal( actions->n_actions, 1 );

  free_buffer( buffer );
  delete_actions( actions );
}


/********************************************************************************
 * create_stats_request() test.
 ********************************************************************************/

static void
test_create_stats_request() {
  uint16_t type = OFPST_DESC;
  buffer *buffer;
  struct ofp_stats_request *stats_request;
  uint16_t length;

  length = sizeof( struct ofp_stats_request );

  buffer = create_stats_request( MY_TRANSACTION_ID, type, length, NO_FLAGS );
  assert_true( buffer != NULL );

  stats_request = buffer->data;

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( stats_request->header.version, OFP_VERSION );
  assert_int_equal( stats_request->header.type, OFPT_STATS_REQUEST );
  assert_int_equal( ntohs( stats_request->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_request->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_request->type ), type );
  assert_int_equal( ntohs( stats_request->flags ), NO_FLAGS );

  free_buffer( buffer );
}


/********************************************************************************
 * create_stats_reply() test.
 ********************************************************************************/

static void
test_create_stats_reply() {
  uint16_t type = OFPST_DESC;
  uint16_t length = sizeof( struct ofp_stats_reply );
  buffer *buffer;
  struct ofp_stats_reply *stats_reply;

  buffer = create_stats_reply( MY_TRANSACTION_ID, type, length, NO_FLAGS );
  assert_true( buffer != NULL );

  stats_reply = ( struct ofp_stats_reply * ) buffer->data;

  assert_int_equal( stats_reply->header.version, OFP_VERSION );
  assert_int_equal( stats_reply->header.type, OFPT_STATS_REPLY );
  assert_int_equal( ntohs( stats_reply->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_reply->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_reply->type ), type );
  assert_int_equal( ntohs( stats_reply->flags ), NO_FLAGS );

  free_buffer( buffer );
}


/********************************************************************************
 * create_desc_stats_request() test.
 ********************************************************************************/

static void
test_create_desc_stats_request() {
  buffer *buffer;
  struct ofp_stats_request *stats_request;

  buffer = create_desc_stats_request( MY_TRANSACTION_ID, NO_FLAGS );

  assert_true( buffer != NULL );

  stats_request = ( struct ofp_stats_request * ) buffer->data;

  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_stats_request ) );
  assert_int_equal( stats_request->header.version, OFP_VERSION );
  assert_int_equal( stats_request->header.type, OFPT_STATS_REQUEST );
  assert_int_equal( ntohs( stats_request->header.length ), sizeof( struct ofp_stats_request ) );
  assert_int_equal( ( int ) ntohl( stats_request->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_request->type ), OFPST_DESC );
  assert_int_equal( ntohs( stats_request->flags ), NO_FLAGS );

  free_buffer( buffer );
}


/********************************************************************************
 * create_desc_stats_reply() test.
 ********************************************************************************/

static void
test_create_desc_stats_reply() {
  const char mfr_desc[ DESC_STR_LEN ] = "NEC Corporation";
  const char hw_desc[ DESC_STR_LEN ] = "OpenFlow Switch Hardware";
  const char sw_desc[ DESC_STR_LEN ] = "OpenFlow Switch Software";
  const char serial_num[ SERIAL_NUM_LEN ] = "1234";
  const char dp_desc[ DESC_STR_LEN ] = "Datapath 0";
  uint16_t length;
  buffer *buffer;
  struct ofp_stats_reply *stats_reply;
  struct ofp_desc_stats *desc_stats;

  length = ( uint16_t ) ( sizeof( struct ofp_stats_reply ) + sizeof( struct ofp_desc_stats ) );

  buffer = create_desc_stats_reply( MY_TRANSACTION_ID, NO_FLAGS, mfr_desc, hw_desc, sw_desc, serial_num, dp_desc );
  assert_true( buffer != NULL );

  stats_reply = ( struct ofp_stats_reply * ) buffer->data;
  desc_stats = ( struct ofp_desc_stats * ) ( ( char * ) buffer->data + sizeof( struct ofp_stats_reply ) );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( stats_reply->header.version, OFP_VERSION );
  assert_int_equal( stats_reply->header.type, OFPT_STATS_REPLY );
  assert_int_equal( ntohs( stats_reply->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_reply->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_reply->type ), OFPST_DESC );
  assert_int_equal( ntohs( stats_reply->flags ), NO_FLAGS );

  assert_memory_equal( desc_stats->mfr_desc, mfr_desc, strlen( mfr_desc ) + 1 );
  assert_memory_equal( desc_stats->hw_desc, hw_desc, strlen( mfr_desc ) + 1 );
  assert_memory_equal( desc_stats->sw_desc, sw_desc, strlen( mfr_desc ) + 1 );
  assert_memory_equal( desc_stats->serial_num, serial_num, strlen( mfr_desc ) + 1 );
  assert_memory_equal( desc_stats->dp_desc, dp_desc, strlen( mfr_desc ) + 1 );

  free_buffer( buffer );
}


/********************************************************************************
 * create_flow_stats_request() test.
 ********************************************************************************/

static void
test_create_flow_stats_request() {
  uint8_t table_id = 0xff;
  uint16_t out_port = 1;
  buffer *buffer;
  struct ofp_stats_request *stats_request;
  struct ofp_flow_stats_request *flow_stats_request;
  uint16_t length;

  buffer = create_flow_stats_request( MY_TRANSACTION_ID, NO_FLAGS, MATCH, table_id, out_port );
  assert_true( buffer != NULL );

  stats_request = ( struct ofp_stats_request * ) buffer->data;
  length = ( uint16_t ) ( offsetof( struct ofp_stats_request, body ) + sizeof( struct ofp_flow_stats_request ) );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( stats_request->header.version, OFP_VERSION );
  assert_int_equal( stats_request->header.type, OFPT_STATS_REQUEST );
  assert_int_equal( ntohs( stats_request->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_request->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_request->type ), OFPST_FLOW );
  assert_int_equal( ntohs( stats_request->flags ), NO_FLAGS );

  flow_stats_request = ( struct ofp_flow_stats_request * ) ( ( char * ) buffer->data
                       + offsetof( struct ofp_stats_request, body ) );

  ntoh_match( &flow_stats_request->match, &flow_stats_request->match );
  assert_memory_equal( &flow_stats_request->match, &MATCH, sizeof( MATCH ) );

  assert_int_equal( flow_stats_request->table_id, table_id );
  assert_int_equal( flow_stats_request->pad, 0 );
  assert_int_equal( ntohs( flow_stats_request->out_port ), out_port );

  free_buffer( buffer );
}


/********************************************************************************
 * create_flow_stats_reply() test.
 ********************************************************************************/

static void
test_create_flow_stats_reply() {
  uint16_t flags = OFPSF_REPLY_MORE;
  list_element *expected_list, *list;
  buffer *buffer;
  uint16_t stats_len = 0;
  struct ofp_stats_reply *stats_reply;
  struct ofp_flow_stats *expected_stats[ 2 ], *flow_stats;
  struct ofp_action_output *action;
  uint16_t length;

  stats_len = offsetof( struct ofp_flow_stats, actions ) + sizeof( struct ofp_action_output );

  expected_stats[ 0 ] = xcalloc( 1, stats_len );
  expected_stats[ 1 ] = xcalloc( 1, stats_len );

  expected_stats[ 0 ]->length = stats_len;
  expected_stats[ 0 ]->table_id = 1;
  expected_stats[ 0 ]->pad = 0;
  expected_stats[ 0 ]->match = MATCH;
  expected_stats[ 0 ]->duration_sec = 60;
  expected_stats[ 0 ]->duration_nsec = 10000;
  expected_stats[ 0 ]->priority = 1024;
  expected_stats[ 0 ]->idle_timeout = 60;
  expected_stats[ 0 ]->hard_timeout = 3600;
  expected_stats[ 0 ]->cookie = 0x0102030405060708ULL;
  expected_stats[ 0 ]->packet_count = 1000;
  expected_stats[ 0 ]->byte_count = 100000;
  action = ( struct ofp_action_output * ) expected_stats[ 0 ]->actions;
  action->type = OFPAT_OUTPUT;
  action->len = 8;
  action->port = 1;
  action->max_len = 2048;

  memcpy( expected_stats[ 1 ], expected_stats[ 0 ], stats_len );
  expected_stats[ 1 ]->cookie = 0x0203040506070809ULL;
  action = ( struct ofp_action_output * ) expected_stats[ 1 ]->actions;
  action->port = 2;

  create_list( &expected_list );
  append_to_tail( &expected_list, expected_stats[ 0 ] );
  append_to_tail( &expected_list, expected_stats[ 1 ] );

  buffer = create_flow_stats_reply( MY_TRANSACTION_ID, flags, expected_list );
  assert_true( buffer != NULL );

  stats_reply = buffer->data;
  flow_stats = ( struct ofp_flow_stats * ) stats_reply->body;
  length = ( uint16_t ) ( stats_len * 2 );
  length = ( uint16_t ) ( length + offsetof( struct ofp_stats_reply, body ) );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( stats_reply->header.version, OFP_VERSION );
  assert_int_equal( stats_reply->header.type, OFPT_STATS_REPLY );
  assert_int_equal( ntohs( stats_reply->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_reply->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_reply->type ), OFPST_FLOW );
  assert_int_equal( ntohs( stats_reply->flags ), flags );

  list = expected_list;
  while ( list != NULL ) {
    struct ofp_flow_stats *next = flow_stats;
    struct ofp_flow_stats *expected_flow_stats = list->data;

    next = ( struct ofp_flow_stats * ) ( ( char * ) flow_stats + ntohs( flow_stats->length ) );
    ntoh_flow_stats( flow_stats, flow_stats );

    assert_memory_equal( flow_stats, expected_flow_stats, expected_flow_stats->length );

    flow_stats = next;
    list = list->next;
  }

  xfree( expected_stats[ 0 ] );
  xfree( expected_stats[ 1 ] );
  delete_list( expected_list );
  free_buffer( buffer );
}


/********************************************************************************
 * create_aggregate_stats_request() test.
 ********************************************************************************/

static void
test_create_aggregate_stats_request() {
  uint8_t table_id = 0xff;
  uint16_t out_port = 1;
  buffer *buffer;
  struct ofp_stats_request *stats_request;
  struct ofp_aggregate_stats_request *aggregate_stats_request;
  uint16_t length;

  buffer = create_aggregate_stats_request( MY_TRANSACTION_ID, NO_FLAGS, MATCH, table_id, out_port );
  assert_true( buffer != NULL );

  stats_request = ( struct ofp_stats_request * ) buffer->data;
  length = ( uint16_t ) ( offsetof( struct ofp_stats_request, body ) + sizeof( struct ofp_flow_stats_request ) );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( stats_request->header.version, OFP_VERSION );
  assert_int_equal( stats_request->header.type, OFPT_STATS_REQUEST );
  assert_int_equal( ntohs( stats_request->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_request->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_request->type ), OFPST_AGGREGATE );
  assert_int_equal( ntohs( stats_request->flags ), NO_FLAGS );

  aggregate_stats_request = ( struct ofp_aggregate_stats_request * ) stats_request->body;

  ntoh_match( &aggregate_stats_request->match, &aggregate_stats_request->match );
  assert_memory_equal( &aggregate_stats_request->match, &MATCH, sizeof( MATCH ) );

  assert_int_equal( aggregate_stats_request->table_id, table_id );
  assert_int_equal( aggregate_stats_request->pad, 0 );
  assert_int_equal( ntohs( aggregate_stats_request->out_port ), out_port );

  free_buffer( buffer );
}


/********************************************************************************
 * create_aggregate_stats_reply() test.
 ********************************************************************************/

static void
test_create_aggregate_stats_reply() {
  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;
  uint16_t length;
  uint64_t tmp;

  buffer = create_aggregate_stats_reply( MY_TRANSACTION_ID, NO_FLAGS, packet_count, byte_count, flow_count );
  assert_true( buffer != NULL );

  stats_reply = ( struct ofp_stats_reply * ) buffer->data;
  length = ( uint16_t ) ( offsetof( struct ofp_stats_reply, body ) + sizeof( struct ofp_aggregate_stats_reply ) );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( stats_reply->header.version, OFP_VERSION );
  assert_int_equal( stats_reply->header.type, OFPT_STATS_REPLY );
  assert_int_equal( ntohs( stats_reply->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_reply->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_reply->type ), OFPST_AGGREGATE );
  assert_int_equal( ntohs( stats_reply->flags ), NO_FLAGS );

  aggregate_stats_reply = ( struct ofp_aggregate_stats_reply * ) stats_reply->body;

  tmp = ntohll( aggregate_stats_reply->packet_count );
  assert_memory_equal( &tmp, &packet_count, sizeof( packet_count ) );
  tmp = ntohll( aggregate_stats_reply->byte_count );
  assert_memory_equal( &tmp, &byte_count, sizeof( byte_count ) );
  assert_int_equal( ( int ) ntohl( aggregate_stats_reply->flow_count ), ( int ) flow_count );

  free_buffer( buffer );
}


/********************************************************************************
 * create_table_stats_request() test.
 ********************************************************************************/

static void
test_create_table_stats_request() {
  buffer *buffer;
  struct ofp_stats_request *stats_request;

  buffer = create_table_stats_request( MY_TRANSACTION_ID, NO_FLAGS );
  assert_true( buffer != NULL );

  stats_request = ( struct ofp_stats_request * ) buffer->data;

  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_stats_request ) );
  assert_int_equal( stats_request->header.version, OFP_VERSION );
  assert_int_equal( stats_request->header.type, OFPT_STATS_REQUEST );
  assert_int_equal( ntohs( stats_request->header.length ), sizeof( struct ofp_stats_request ) );
  assert_int_equal( ( int ) ntohl( stats_request->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_request->type ), OFPST_TABLE );
  assert_int_equal( ntohs( stats_request->flags ), NO_FLAGS );

  free_buffer( buffer );
}


/********************************************************************************
 * create_table_stats_reply() test.
 ********************************************************************************/

static void
test_create_table_stats_reply() {
  uint16_t flags = OFPSF_REPLY_MORE;
  uint16_t stats_len;
  buffer *buffer;
  list_element *expected_list, *list;
  struct ofp_stats_reply *stats_reply;
  struct ofp_table_stats *stats[ 2 ], *table_stats, *next;
  uint16_t length = 0;

  stats_len = sizeof( struct ofp_table_stats );

  stats[ 0 ] = xcalloc( 1, stats_len );
  stats[ 1 ] = xcalloc( 1, stats_len );

  stats[ 0 ]->table_id = 1;
  strcpy( 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;
  strcpy( stats[ 1 ]->name, "Table 2" );

  create_list( &expected_list );
  append_to_tail( &expected_list, stats[ 0 ] );
  append_to_tail( &expected_list, stats[ 1 ] );

  buffer = create_table_stats_reply( MY_TRANSACTION_ID, flags, expected_list );
  assert_true( buffer != NULL );

  stats_reply = ( struct ofp_stats_reply * ) buffer->data;
  length = ( uint16_t ) ( offsetof( struct ofp_stats_reply, body ) + sizeof( struct ofp_table_stats ) * 2 );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( stats_reply->header.version, OFP_VERSION );
  assert_int_equal( stats_reply->header.type, OFPT_STATS_REPLY );
  assert_int_equal( ntohs( stats_reply->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_reply->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_reply->type ), OFPST_TABLE );
  assert_int_equal( ntohs( stats_reply->flags ), flags );

  table_stats = ( struct ofp_table_stats * ) stats_reply->body;

  list = expected_list;
  while ( list != NULL ) {
    struct ofp_table_stats *expected_table_stats = ( struct ofp_table_stats * ) list->data;

    next = ( struct ofp_table_stats * ) ( ( char * ) table_stats + sizeof( struct ofp_table_stats ) );
    ntoh_table_stats( table_stats, table_stats );

    assert_memory_equal( table_stats, expected_table_stats, sizeof( struct ofp_table_stats ) );

    table_stats = next;
    list = list->next;
  }

  xfree( stats[ 0 ] );
  xfree( stats[ 1 ] );
  delete_list( expected_list );
  free_buffer( buffer );
}


/********************************************************************************
 * create_port_stats_request() test.
 ********************************************************************************/

static void
test_create_port_stats_request() {
  uint16_t port_no = 1;
  buffer *buffer;
  struct ofp_stats_request *stats_request;
  struct ofp_port_stats_request *port_stats_request;
  uint16_t length;

  buffer = create_port_stats_request( MY_TRANSACTION_ID, NO_FLAGS, port_no );
  assert_true( buffer != NULL );

  stats_request = ( struct ofp_stats_request * ) buffer->data;
  length = ( uint16_t ) ( offsetof( struct ofp_stats_request, body )
           + sizeof( struct ofp_port_stats_request ) );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( stats_request->header.version, OFP_VERSION );
  assert_int_equal( stats_request->header.type, OFPT_STATS_REQUEST );
  assert_int_equal( ntohs( stats_request->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_request->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_request->type ), OFPST_PORT );
  assert_int_equal( ntohs( stats_request->flags ), NO_FLAGS );

  port_stats_request = ( struct ofp_port_stats_request * ) ( ( char * ) buffer->data
                       + offsetof( struct ofp_stats_request, body ) );

  assert_int_equal( ntohs( port_stats_request->port_no ), port_no );

  {
    void *pad = xmalloc( sizeof( port_stats_request->pad ) );
    memset( pad, 0, sizeof( port_stats_request->pad ) );
    assert_memory_equal( port_stats_request->pad, pad, sizeof( port_stats_request->pad ) );
    xfree( pad );
  }

  free_buffer( buffer );
}


/********************************************************************************
 * create_port_stats_reply() test.
 ********************************************************************************/

static void
test_create_port_stats_reply() {
  void *expected_data;
  uint16_t flags = OFPSF_REPLY_MORE;
  uint16_t stats_len;
  buffer *buffer;
  list_element *expected_list, *list;
  struct ofp_stats_reply *stats_reply;
  struct ofp_port_stats *stats[ 2 ], *port_stats, *next;
  uint16_t length = 0;

  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( &expected_list );
  append_to_tail( &expected_list, stats[ 0 ] );
  append_to_tail( &expected_list, 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( MY_TRANSACTION_ID, flags, expected_list );
  assert_true( buffer != NULL );

  stats_reply = buffer->data;
  length = ( uint16_t ) ( offsetof( struct ofp_stats_reply, body )
           + sizeof( struct ofp_port_stats ) * 2 );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( stats_reply->header.version, OFP_VERSION );
  assert_int_equal( stats_reply->header.type, OFPT_STATS_REPLY );
  assert_int_equal( ntohs( stats_reply->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_reply->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_reply->type ), OFPST_PORT );
  assert_int_equal( ntohs( stats_reply->flags ), flags );

  port_stats = ( struct ofp_port_stats * ) stats_reply->body;

  list = expected_list;
  while ( list != NULL ) {
    struct ofp_port_stats *expected_port_stats = ( struct ofp_port_stats * ) list->data;

    next = ( struct ofp_port_stats * ) ( ( char * ) port_stats + sizeof( struct ofp_port_stats ) );
    ntoh_port_stats( port_stats, port_stats );

    assert_memory_equal( port_stats, expected_port_stats, sizeof( struct ofp_port_stats ) );

    port_stats = next;
    list = list->next;
  }

  xfree( stats[ 0 ] );
  xfree( stats[ 1 ] );
  xfree( expected_data );
  delete_list( expected_list );
  free_buffer( buffer );
}


/********************************************************************************
 * create_queue_stats_request() test.
 ********************************************************************************/

static void
test_create_queue_stats_request() {
  uint16_t port_no = 1;
  uint32_t queue_id = 10;
  buffer *buffer;
  struct ofp_stats_request *stats_request;
  struct ofp_queue_stats_request *queue_stats_request;
  uint16_t length;

  buffer = create_queue_stats_request( MY_TRANSACTION_ID, NO_FLAGS, port_no, queue_id );
  assert_true( buffer != NULL );

  stats_request = ( struct ofp_stats_request * ) buffer->data;
  length = ( uint16_t ) ( offsetof( struct ofp_stats_request, body )
           + sizeof( struct ofp_queue_stats_request ) );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( stats_request->header.version, OFP_VERSION );
  assert_int_equal( stats_request->header.type, OFPT_STATS_REQUEST );
  assert_int_equal( ntohs( stats_request->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_request->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_request->type ), OFPST_QUEUE );
  assert_int_equal( ntohs( stats_request->flags ), NO_FLAGS );

  queue_stats_request = ( struct ofp_queue_stats_request * ) ( ( char * ) buffer->data
                        + offsetof( struct ofp_stats_request, body ) );

  assert_int_equal( ntohs( queue_stats_request->port_no ), port_no );

  {
    void *pad = xmalloc( sizeof( queue_stats_request->pad ) );
    memset( pad, 0, sizeof( queue_stats_request->pad ) );
    assert_memory_equal( queue_stats_request->pad, pad, sizeof( queue_stats_request->pad ) );
    xfree( pad );
  }

  assert_int_equal( ( int ) ntohl( queue_stats_request->queue_id ), ( int ) queue_id );

  free_buffer( buffer );
}


/********************************************************************************
 * create_queue_stats_reply() test.
 ********************************************************************************/

static void
test_create_queue_stats_reply() {
  uint16_t flags = OFPSF_REPLY_MORE;
  list_element *list, *l;
  uint16_t stats_len;
  struct ofp_stats_reply *stats_reply;
  struct ofp_queue_stats *stats[ 2 ], *queue_stats;
  uint16_t n_queues = 2;
  uint16_t length;
  buffer *buffer;

  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( &list );
  append_to_tail( &list, stats[ 0 ] );
  append_to_tail( &list, stats[ 1 ] );

  buffer = create_queue_stats_reply( MY_TRANSACTION_ID, flags, list );
  assert_true( buffer != NULL );

  stats_reply = buffer->data;
  length = ( uint16_t ) ( offsetof( struct ofp_stats_reply, body )
           + sizeof( struct ofp_queue_stats ) * n_queues );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( stats_reply->header.version, OFP_VERSION );
  assert_int_equal( stats_reply->header.type, OFPT_STATS_REPLY );
  assert_int_equal( ntohs( stats_reply->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_reply->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_reply->type ), OFPST_QUEUE );
  assert_int_equal( ntohs( stats_reply->flags ), flags );

  queue_stats = ( struct ofp_queue_stats * ) stats_reply->body;
  l = list;
  while ( list != NULL ) {
    void *next = ( char * ) queue_stats + stats_len;
    ntoh_queue_stats( queue_stats, queue_stats );

    assert_memory_equal( queue_stats, list->data, stats_len );

    list = list->next;
    queue_stats = next;
  }

  xfree( stats[ 0 ] );
  xfree( stats[ 1 ] );
  delete_list( l );
  free_buffer( buffer );
}


/********************************************************************************
 * create_barrier_request() test.
 ********************************************************************************/

static void
test_create_barrier_request() {
  buffer *buffer;
  struct ofp_header *barrier_request;

  buffer = create_barrier_request( MY_TRANSACTION_ID );

  assert_true( buffer != NULL );

  barrier_request = ( struct ofp_header * ) buffer->data;

  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_header ) );
  assert_int_equal( barrier_request->version, OFP_VERSION );
  assert_int_equal( barrier_request->type, OFPT_BARRIER_REQUEST );
  assert_int_equal( ntohs( barrier_request->length ), sizeof( struct ofp_header ) );
  assert_int_equal( ( int ) ntohl( barrier_request->xid ), ( int ) MY_TRANSACTION_ID );

  free_buffer( buffer );
}


/********************************************************************************
 * create_barrier_reply() test.
 ********************************************************************************/

static void
test_create_barrier_reply() {
  buffer *buffer;
  struct ofp_header *barrier_reply;

  buffer = create_barrier_reply( MY_TRANSACTION_ID );
  assert_true( buffer != NULL );

  barrier_reply = buffer->data;

  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_header ) );
  assert_int_equal( barrier_reply->version, OFP_VERSION );
  assert_int_equal( barrier_reply->type, OFPT_BARRIER_REPLY );
  assert_int_equal( ntohs( barrier_reply->length ), sizeof( struct ofp_header ) );
  assert_int_equal( ( int ) ntohl( barrier_reply->xid ), ( int ) MY_TRANSACTION_ID );

  free_buffer( buffer );
}


/********************************************************************************
 * create_queue_get_config_request() test.
 ********************************************************************************/

static void
test_create_queue_get_config_request() {
  uint16_t port = 1;
  buffer *buffer;
  struct ofp_queue_get_config_request *queue_get_config_request;

  buffer = create_queue_get_config_request( MY_TRANSACTION_ID, port );

  assert_true( buffer != NULL );

  queue_get_config_request = buffer->data;

  assert_int_equal( ( int ) buffer->length, sizeof( struct ofp_queue_get_config_request ) );
  assert_int_equal( queue_get_config_request->header.version, OFP_VERSION );
  assert_int_equal( queue_get_config_request->header.type, OFPT_QUEUE_GET_CONFIG_REQUEST );
  assert_int_equal( ntohs( queue_get_config_request->header.length ), sizeof( struct ofp_queue_get_config_request ) );
  assert_int_equal( ( int ) ntohl( queue_get_config_request->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ( int ) ntohs( queue_get_config_request->port ), ( int ) port );

  {
    void *pad = xmalloc( sizeof( queue_get_config_request->pad ) );
    memset( pad, 0, sizeof( queue_get_config_request->pad ) );
    assert_memory_equal( queue_get_config_request->pad, pad, sizeof( queue_get_config_request->pad ) );
    xfree( pad );
  }

  free_buffer( buffer );
}


/********************************************************************************
 * create_queue_get_config_reply() test.
 ********************************************************************************/

static void
test_create_queue_get_config_reply() {
  size_t queue_len;
  uint16_t port = 1;
  uint8_t expected_pad[ 6 ];
  list_element *list, *l;
  buffer *buffer;
  struct ofp_queue_get_config_reply *queue_get_config_reply;
  struct ofp_packet_queue *queue[ 2 ], *packet_queue;
  struct ofp_queue_prop_header *prop_header;
  uint16_t queues_length;
  uint16_t length;

  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( &list );
  append_to_tail( &list, queue[ 0 ] );
  append_to_tail( &list, queue[ 1 ] );

  buffer = create_queue_get_config_reply( MY_TRANSACTION_ID, port, list );
  assert_true( buffer != NULL );

  queue_get_config_reply = buffer->data;

  queues_length = ( uint16_t ) ( queue[ 0 ]->len + queue[ 1 ]->len );
  length = ( uint16_t ) ( offsetof( struct ofp_queue_get_config_reply, queues ) + queues_length );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( queue_get_config_reply->header.version, OFP_VERSION );
  assert_int_equal( queue_get_config_reply->header.type, OFPT_QUEUE_GET_CONFIG_REPLY );
  assert_int_equal( ntohs( queue_get_config_reply->header.length ), length );
  assert_int_equal( ( int ) ntohl( queue_get_config_reply->header.xid ), ( int ) MY_TRANSACTION_ID );

  memset( &expected_pad, 0, sizeof( expected_pad ) );
  assert_int_equal( ntohs( queue_get_config_reply->port ), port );
  assert_memory_equal( queue_get_config_reply->pad, expected_pad, sizeof( expected_pad ) );

  l = list;
  packet_queue = queue_get_config_reply->queues;
  while ( list != NULL ) {
    ntoh_packet_queue( packet_queue, packet_queue );
    void *next = ( char * ) packet_queue + packet_queue->len;
    struct ofp_packet_queue *expected_packet_queue = ( struct ofp_packet_queue * ) list->data;
    assert_memory_equal( packet_queue, expected_packet_queue, expected_packet_queue->len );

    list = list->next;
    packet_queue = next;
  }

  xfree( queue[ 0 ] );
  xfree( queue[ 1 ] );
  delete_list( l );
  free_buffer( buffer );
}


/********************************************************************************
 * create_vendor_stats_request() tests.
 ********************************************************************************/

static void
test_create_vendor_stats_request() {
  const uint16_t body_length = 128;

  buffer *body = create_dummy_data( body_length );
  buffer *buffer = create_vendor_stats_request( MY_TRANSACTION_ID, VENDOR_STATS_FLAG, VENDOR_ID, body );
  assert_true( buffer != NULL );

  assert_int_equal( ( int ) buffer->length,
                    ( int ) ( offsetof( struct ofp_stats_request, body ) + sizeof( uint32_t ) + body_length ) );

  struct ofp_stats_request *stats = buffer->data;

  assert_int_equal( stats->header.version, OFP_VERSION );
  assert_int_equal( stats->header.type, OFPT_STATS_REQUEST );
  assert_int_equal( ( int ) ntohs( stats->header.length ),
                    ( int ) ( offsetof( struct ofp_stats_request, body ) + sizeof( uint32_t ) + body_length ) );
  assert_int_equal( ( int ) ntohl( stats->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ( int ) ntohs( stats->type ), ( int ) OFPST_VENDOR );
  assert_int_equal( ( int ) ntohs( stats->flags ), ( int ) VENDOR_STATS_FLAG );
  uint32_t vendor_id = *( ( uint32_t * ) ( ( char * ) stats + offsetof( struct ofp_stats_request, body ) ) );
  assert_int_equal( ( int ) ntohl( vendor_id ), ( int ) VENDOR_ID );
  assert_memory_equal( ( char * ) stats + offsetof( struct ofp_stats_request, body ) + sizeof ( uint32_t ),
                       body->data, body_length );

  free_buffer( body );
  free_buffer( buffer );
}


static void
test_create_vendor_stats_request_without_data() {
  buffer *buffer = create_vendor_stats_request( MY_TRANSACTION_ID, VENDOR_STATS_FLAG, VENDOR_ID, NULL );
  assert_true( buffer != NULL );

  struct ofp_stats_request *stats = buffer->data;

  assert_int_equal( stats->header.version, OFP_VERSION );
  assert_int_equal( stats->header.type, OFPT_STATS_REQUEST );
  assert_int_equal( ( int ) ntohs( stats->header.length ),
                    ( int ) ( offsetof( struct ofp_stats_request, body ) + sizeof( uint32_t ) ) );
  assert_int_equal( ( int ) ntohl( stats->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ( int ) ntohs( stats->type ), ( int ) OFPST_VENDOR );
  assert_int_equal( ( int ) ntohs( stats->flags ), ( int ) VENDOR_STATS_FLAG );
  uint32_t vendor_id = *( ( uint32_t * ) ( ( char * ) stats + offsetof( struct ofp_stats_request, body ) ) );
  assert_int_equal( ( int ) ntohl( vendor_id ), ( int ) VENDOR_ID );

  free_buffer( buffer );
}


/********************************************************************************
 * create_vendor_stats_reply() test.
 ********************************************************************************/

static void
test_create_vendor_stats_reply() {
  void *data;
  uint32_t expected_vendor = VENDOR_ID;
  uint32_t *vendor;
  buffer *buffer, *body;
  struct ofp_stats_reply *stats_reply;
  uint16_t length;

  body = alloc_buffer_with_length( 128 );
  append_back_buffer( body, 128 );
  memset( body->data, 0xa1, body->length );

  buffer = create_vendor_stats_reply( MY_TRANSACTION_ID, NO_FLAGS, expected_vendor, body );
  assert_true( buffer != NULL );

  stats_reply = buffer->data;
  length = ( uint16_t ) ( offsetof( struct ofp_stats_reply, body ) + sizeof( uint32_t ) + body->length );

  assert_int_equal( ( int ) buffer->length, length );
  assert_int_equal( stats_reply->header.version, OFP_VERSION );
  assert_int_equal( stats_reply->header.type, OFPT_STATS_REPLY );
  assert_int_equal( ntohs( stats_reply->header.length ), length );
  assert_int_equal( ( int ) ntohl( stats_reply->header.xid ), ( int ) MY_TRANSACTION_ID );

  assert_int_equal( ntohs( stats_reply->type ), OFPST_VENDOR );
  assert_int_equal( ntohs( stats_reply->flags ), NO_FLAGS );

  vendor = ( uint32_t * ) stats_reply->body;
  *vendor = ntohl( *vendor );

  assert_int_equal( ( int ) *vendor, ( int ) expected_vendor );

  data = ( char * ) vendor + sizeof( uint32_t );
  assert_memory_equal( data, body->data, body->length );

  free_buffer( body );
  free_buffer( buffer );
}


/********************************************************************************
 * validate_error() test.
 ********************************************************************************/

static void
test_validate_error() {
  uint16_t type = OFPET_HELLO_FAILED;
  uint16_t code = OFPHFC_INCOMPATIBLE;
  buffer *expected_data;
  buffer *expected_message = NULL;
  int ret_val;

  expect_assert_failure( validate_error( expected_message ) );

  expected_data = create_dummy_data( SHORT_DATA_LENGTH );

  expected_message = create_error( MY_TRANSACTION_ID, type, code, expected_data );

  ret_val = validate_error( expected_message );
  assert_int_equal( ret_val, 0 );

  free_buffer( expected_data );
  free_buffer( expected_message );

  // error case.
  expected_message = create_echo_request( MY_TRANSACTION_ID, NULL );

  ret_val = validate_error( expected_message );
  assert_int_equal( ret_val, ERROR_INVALID_TYPE );

  free_buffer( expected_message );
}


/********************************************************************************
 * validate_validate_vendor() tests.
 ********************************************************************************/

static void
test_validate_vendor() {
  buffer *data = create_dummy_data( 32 );
  buffer *message = create_vendor( MY_TRANSACTION_ID, VENDOR_ID, data );

  assert_int_equal( validate_vendor( message ), 0 );

  free_buffer( data );
  free_buffer( message );
}


static void
test_validate_vendor_without_data() {
  buffer *message = create_vendor( MY_TRANSACTION_ID, VENDOR_ID, NULL );

  assert_int_equal( validate_vendor( message ), 0 );

  free_buffer( message );
}


static void
test_validate_vendor_fails_if_message_is_NULL() {
  expect_assert_failure( validate_vendor( NULL ) );
}


static void
test_validate_vendor_fails_if_message_is_not_vendor_header() {
  buffer *message = create_hello( MY_TRANSACTION_ID );

  assert_int_equal( validate_vendor( message ), ERROR_INVALID_TYPE );

  free_buffer( message );
}


/********************************************************************************
 * validate_features_reply() test.
 ********************************************************************************/

static void
test_validate_features_reply() {
  uint64_t datapath_id = 0x12345600;
  uint32_t n_buffers = 128;
  uint8_t n_tables = 1;
  uint32_t capabilities;
  uint32_t actions;
  struct ofp_phy_port phy_port[ 2 ];
  list_element *ports;
  buffer *expected_message = NULL;
  int ret_val;

  expect_assert_failure( validate_features_reply( expected_message ) );

  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 ].port_no = 1;
  memcpy( phy_port[ 0 ].hw_addr, HW_ADDR, sizeof( phy_port[ 0 ].hw_addr ) );
  strcpy( phy_port[ 0 ].name, "Brown" );
  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;

  create_list( &ports );
  append_to_tail( &ports, &phy_port[ 0 ] );

  phy_port[ 1 ].port_no = 2;
  memcpy( phy_port[ 1 ].hw_addr, HW_ADDR, sizeof( phy_port[ 1 ].hw_addr ) );
  strcpy( phy_port[ 1 ].name, "Amber" );
  phy_port[ 1 ].config = OFPPC_PORT_DOWN;
  phy_port[ 1 ].state = OFPPS_LINK_DOWN;
  phy_port[ 1 ].curr = OFPPF_1GB_FD | OFPPF_COPPER | OFPPF_PAUSE;
  phy_port[ 1 ].advertised = PORT_FEATURES;
  phy_port[ 1 ].supported = PORT_FEATURES;
  phy_port[ 1 ].peer = PORT_FEATURES;

  append_to_tail( &ports, &phy_port[ 1 ] );
  expected_message = create_features_reply( MY_TRANSACTION_ID, datapath_id, n_buffers, n_tables, capabilities, actions, ports );

  ret_val = validate_features_reply( expected_message );
  assert_int_equal( ret_val, 0 );

  delete_list( ports );
  free_buffer( expected_message );

  // error case.
  expected_message = create_hello( MY_TRANSACTION_ID );

  ret_val = validate_features_reply( expected_message );
  assert_int_equal( ret_val, ERROR_INVALID_TYPE );

  free_buffer( expected_message );
}


/********************************************************************************
 * validate_get_config_request() tests.
 ********************************************************************************/

static void
test_validate_get_config_request() {
  buffer *get_config_request = create_get_config_request( MY_TRANSACTION_ID );

  assert_int_equal( validate_get_config_request( get_config_request ), 0 );

  free_buffer( get_config_request );
}


static void
test_validate_get_config_request_fails_if_message_is_NULL() {
  expect_assert_failure( validate_get_config_request( NULL ) );
}


static void
test_validate_get_config_request_fails_if_message_is_not_get_config_request() {
  buffer *hello = create_hello( MY_TRANSACTION_ID );

  assert_int_equal( validate_get_config_request( hello ), ERROR_INVALID_TYPE );

  free_buffer( hello );
}


/********************************************************************************
 * validate_get_config_reply() test.
 ********************************************************************************/

static void
test_validate_get_config_reply() {
  uint16_t flags = OFPC_FRAG_NORMAL;
  uint16_t miss_send_len = OFP_DEFAULT_MISS_SEND_LEN;
  buffer *expected_message = NULL;
  int ret_val;

  expect_assert_failure( validate_get_config_reply( expected_message ) );

  expected_message = create_get_config_reply( MY_TRANSACTION_ID, flags, miss_send_len );

  ret_val = validate_get_config_reply( expected_message );
  assert_int_equal( ret_val, 0 );

  free_buffer( expected_message );

  // error case.
  expected_message = create_echo_request( MY_TRANSACTION_ID, NULL );

  ret_val = validate_get_config_reply( expected_message );
  assert_int_equal( ret_val, ERROR_INVALID_TYPE );

  free_buffer( expected_message );
}


/********************************************************************************
 * validate_packet_in() test.
 ********************************************************************************/

static void
test_validate_packet_in() {
  uint16_t total_len;
  uint16_t in_port = 1;
  uint8_t reason = OFPR_NO_MATCH;
  buffer *expected_data = NULL;
  buffer *expected_message = NULL;
  int ret_val;

  expect_assert_failure( validate_packet_in( expected_message ) );

  expected_data = create_dummy_data( LONG_DATA_LENGTH );
  total_len = ( uint16_t ) expected_data->length;
  expected_message = create_packet_in( MY_TRANSACTION_ID, BUFFER_ID, total_len, in_port, reason, expected_data );

  ret_val = validate_packet_in( expected_message );
  assert_int_equal( ret_val, 0 );

  free_buffer( expected_message );

  // error case.
  expected_message = create_echo_request( MY_TRANSACTION_ID, NULL );

  ret_val = validate_packet_in( expected_message );
  assert_int_equal( ret_val, ERROR_INVALID_TYPE );

  free_buffer( expected_data );
  free_buffer( expected_message );
}


/********************************************************************************
 * validate_flow_removed() test.
 ********************************************************************************/

static void
test_validate_flow_removed() {
  uint64_t cookie = 0x0102030405060708ULL;
  uint8_t reason = OFPRR_IDLE_TIMEOUT;
  uint32_t duration_sec = 180;
  uint32_t duration_nsec = 10000;
  uint16_t idle_timeout = 60;
  uint64_t packet_count = 1000;
  uint64_t byte_count = 100000;
  buffer *expected_message = NULL;
  int ret_val;

  expect_assert_failure( validate_flow_removed( expected_message ) );

  expected_message = create_flow_removed( MY_TRANSACTION_ID, MATCH, cookie, PRIORITY, reason, duration_sec,
                                          duration_nsec, idle_timeout, packet_count, byte_count );

  ret_val = validate_flow_removed( expected_message );
  assert_int_equal( ret_val, 0 );

  free_buffer( expected_message );

  // error case.
  expected_message = create_echo_request( MY_TRANSACTION_ID, NULL );

  ret_val = validate_flow_removed( expected_message );
  assert_int_equal( ret_val, ERROR_INVALID_TYPE );

  free_buffer( expected_message );
}


/********************************************************************************
 * validate_port_status() test.
 ********************************************************************************/

static void
test_validate_port_status() {
  uint8_t reason = OFPPR_ADD;
  struct ofp_phy_port desc;
  buffer *expected_message = NULL;
  int ret_val;

  expect_assert_failure( validate_port_status( expected_message ) );

  desc.port_no = 1;
  memcpy( desc.hw_addr, HW_ADDR, sizeof( desc.hw_addr ) );
  memset( desc.name, '\0', OFP_MAX_PORT_NAME_LEN );
  strcpy( desc.name, "Navy" );
  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;
  expected_message = create_port_status( MY_TRANSACTION_ID, reason, desc );

  ret_val = validate_port_status( expected_message );
  assert_int_equal( ret_val, 0 );

  free_buffer( expected_message );
}


/********************************************************************************
 * validate_packet_out() tests.
 ********************************************************************************/

static void
test_validate_packet_out() {
  openflow_actions *actions = create_actions();
  append_action_output( actions, 1, 128 );
  buffer *data = create_dummy_data( LONG_DATA_LENGTH );
  buffer *packet_out = create_packet_out( MY_TRANSACTION_ID, UINT32_MAX, 1, actions, data );

  assert_int_equal( validate_packet_out( packet_out ), 0 );

  free_buffer( data );
  free_buffer( packet_out );
  delete_actions( actions );
}


static void
test_validate_packet_out_without_data() {
  openflow_actions *actions = create_actions();
  append_action_output( actions, 1, 128 );
  buffer *packet_out = create_packet_out( MY_TRANSACTION_ID, BUFFER_ID, 1, actions, NULL );

  assert_int_equal( validate_packet_out( packet_out ), 0 );

  free_buffer( packet_out );
  delete_actions( actions );
}


static void
test_validate_packet_out_fails_if_message_is_NULL() {
  expect_assert_failure( validate_packet_out( NULL ) );
}


static void
test_validate_packet_out_fails_if_message_is_not_packet_out() {
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, NULL );

  assert_int_equal( validate_packet_out( echo_request ), ERROR_INVALID_TYPE );

  free_buffer( echo_request );
}


/********************************************************************************
 * validate_flow_mod() tests.
 ********************************************************************************/

static void
test_validate_flow_mod() {
  uint64_t cookie = 10;
  uint16_t hard_timeout = 10;
  uint16_t idle_timeout = 5;
  uint16_t out_port = UINT16_MAX;
  openflow_actions *actions = create_actions();
  append_action_output( actions, 1, 128 );
  buffer *flow_mod = create_flow_mod( MY_TRANSACTION_ID, MATCH, cookie, OFPFC_ADD, idle_timeout, hard_timeout, PRIORITY,
                                      BUFFER_ID, out_port, OFPFF_CHECK_OVERLAP | OFPFF_SEND_FLOW_REM, actions );

  assert_int_equal( validate_flow_mod( flow_mod ), 0 );

  free_buffer( flow_mod );
  delete_actions( actions );
}


static void
test_validate_flow_mod_fails_if_message_is_NULL() {
  expect_assert_failure( validate_flow_mod( NULL ) );
}


static void
test_validate_flow_mod_fails_if_message_is_not_flow_mod() {
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, NULL );

  assert_int_equal( validate_flow_mod( echo_request ), ERROR_INVALID_TYPE );

  free_buffer( echo_request );
}


/********************************************************************************
 * validate_port_mod() tests.
 ********************************************************************************/

static void
test_validate_port_mod() {
  uint16_t port_no = 1;
  uint32_t mask = 0;
  uint32_t advertise = 1;
  buffer *port_mod = create_port_mod( MY_TRANSACTION_ID, port_no, HW_ADDR, OFPPC_PORT_DOWN, mask, advertise );

  assert_int_equal( validate_port_mod( port_mod ), 0 );

  free_buffer( port_mod );
}


static void
test_validate_port_mod_fails_if_message_is_NULL() {
  expect_assert_failure( validate_port_mod( NULL ) );
}


static void
test_validate_port_mod_fails_if_message_is_not_port_mod() {
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, NULL );

  assert_int_equal( validate_port_mod( echo_request ), ERROR_INVALID_TYPE );

  free_buffer( echo_request );
}


/********************************************************************************
 * validate_desc_stats_request() tests.
 ********************************************************************************/

static void
test_validate_desc_stats_request() {
  buffer *desc_stats_request = create_desc_stats_request( MY_TRANSACTION_ID, 0 );

  assert_int_equal( validate_desc_stats_request( desc_stats_request ), 0 );

  free_buffer( desc_stats_request );
}


static void
test_validate_desc_stats_request_fails_if_message_is_NULL() {
  expect_assert_failure( validate_desc_stats_request( NULL ) );
}


static void
test_validate_desc_stats_request_fails_if_message_is_not_desc_stats_request() {
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, NULL );

  assert_int_equal( validate_desc_stats_request( echo_request ), ERROR_INVALID_TYPE );

  free_buffer( echo_request );
}


/********************************************************************************
 * validate_desc_stats_reply() test.
 ********************************************************************************/

static void
test_validate_desc_stats_reply() {
  const char mfr_desc[ DESC_STR_LEN ] = "NEC Corporation";
  const char hw_desc[ DESC_STR_LEN ] = "OpenFlow Switch Hardware";
  const char sw_desc[ DESC_STR_LEN ] = "OpenFlow Switch Software";
  const char serial_num[ SERIAL_NUM_LEN ] = "1234";
  const char dp_desc[ DESC_STR_LEN ] = "Datapath 0";
  buffer *expected_message = NULL;
  int ret_val;

  expect_assert_failure( validate_desc_stats_reply( expected_message ) );

  expected_message = create_desc_stats_reply( MY_TRANSACTION_ID, NO_FLAGS, mfr_desc, hw_desc, sw_desc, serial_num, dp_desc );

  ret_val = validate_desc_stats_reply( expected_message );
  assert_int_equal( ret_val, 0 );

  free_buffer( expected_message );
}


/********************************************************************************
 * validate_flow_stats_request() tests.
 ********************************************************************************/

static void
test_validate_flow_stats_request() {
  uint8_t table_id = 0xff;
  uint16_t out_port = 1;
  buffer *flow_stats_request = create_flow_stats_request( MY_TRANSACTION_ID, NO_FLAGS, MATCH, table_id, out_port );

  assert_int_equal( validate_flow_stats_request( flow_stats_request ), 0 );

  free_buffer( flow_stats_request );
}


static void
test_validate_flow_stats_request_fails_if_message_is_NULL() {
  expect_assert_failure( validate_flow_stats_request( NULL ) );
}


static void
test_validate_flow_stats_request_fails_if_message_is_not_flow_stats_request() {
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, NULL );

  assert_int_equal( validate_flow_stats_request( echo_request ), ERROR_INVALID_TYPE );

  free_buffer( echo_request );
}


/********************************************************************************
 * validate_flow_stats_reply() test.
 ********************************************************************************/

static void
test_validate_flow_stats_reply() {
  uint16_t flags = OFPSF_REPLY_MORE;
  list_element *expected_list;
  uint16_t stats_len = 0;
  struct ofp_flow_stats *expected_stats[ 2 ];
  struct ofp_action_output *action;
  buffer *expected_message = NULL;

  expect_assert_failure( validate_flow_stats_reply( expected_message ) );

  stats_len = offsetof( struct ofp_flow_stats, actions ) + sizeof( struct ofp_action_output );

  expected_stats[ 0 ] = xcalloc( 1, stats_len );
  expected_stats[ 1 ] = xcalloc( 1, stats_len );

  expected_stats[ 0 ]->length = stats_len;
  expected_stats[ 0 ]->table_id = 1;
  expected_stats[ 0 ]->pad = 0;
  expected_stats[ 0 ]->match = MATCH;
  expected_stats[ 0 ]->duration_sec = 60;
  expected_stats[ 0 ]->duration_nsec = 10000;
  expected_stats[ 0 ]->priority = UINT16_MAX;
  expected_stats[ 0 ]->idle_timeout = 60;
  expected_stats[ 0 ]->hard_timeout = 3600;
  expected_stats[ 0 ]->cookie = 0x0102030405060708ULL;
  expected_stats[ 0 ]->packet_count = 1000;
  expected_stats[ 0 ]->byte_count = 100000;
  action = ( struct ofp_action_output * ) expected_stats[ 0 ]->actions;
  action->type = OFPAT_OUTPUT;
  action->len = 8;
  action->port = 1;
  action->max_len = 2048;

  memcpy( expected_stats[ 1 ], expected_stats[ 0 ], stats_len );
  expected_stats[ 1 ]->cookie = 0x0203040506070809ULL;
  action = ( struct ofp_action_output * ) expected_stats[ 1 ]->actions;
  action->port = 2;

  create_list( &expected_list );
  append_to_tail( &expected_list, expected_stats[ 0 ] );
  append_to_tail( &expected_list, expected_stats[ 1 ] );

  expected_message = create_flow_stats_reply( MY_TRANSACTION_ID, flags, expected_list );

  int ret_val = validate_flow_stats_reply( expected_message );
  assert_int_equal( ret_val, 0 );

  xfree( expected_stats[ 0 ] );
  xfree( expected_stats[ 1 ] );
  delete_list( expected_list );
  free_buffer( expected_message );
}


/********************************************************************************
 * validate_aggregate_stats_request() tests.
 ********************************************************************************/

static void
test_validate_aggregate_stats_request() {
  uint8_t table_id = 0xff;
  uint16_t out_port = 1;
  buffer *aggregate_stats_request = create_aggregate_stats_request( MY_TRANSACTION_ID, NO_FLAGS, MATCH, table_id, out_port );

  assert_int_equal( validate_aggregate_stats_request( aggregate_stats_request ), 0 );

  free_buffer( aggregate_stats_request );
}


static void
test_validate_aggregate_stats_request_fails_if_message_is_NULL() {
  expect_assert_failure( validate_aggregate_stats_request( NULL ) );
}


static void
test_validate_aggregate_stats_request_fails_if_message_is_not_aggregate_stats_request() {
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, NULL );

  assert_int_equal( validate_aggregate_stats_request( echo_request ), ERROR_INVALID_TYPE );

  free_buffer( echo_request );
}


/********************************************************************************
 * validate_aggregate_stats_reply() test.
 ********************************************************************************/

static void
test_validate_aggregate_stats_reply() {
  uint32_t flow_count = 1000;
  uint64_t packet_count = 1000;
  uint64_t byte_count = 10000;
  buffer *expected_message = NULL;
  int ret_val;

  expected_message = create_aggregate_stats_reply( MY_TRANSACTION_ID, NO_FLAGS, packet_count, byte_count, flow_count );

  ret_val = validate_aggregate_stats_reply( expected_message );
  assert_int_equal( ret_val, 0 );

  free_buffer( expected_message );
}


/********************************************************************************
 * validate_table_stats_request() tests.
 ********************************************************************************/

static void
test_validate_table_stats_request() {
  buffer *table_stats_request = create_table_stats_request( MY_TRANSACTION_ID, 0 );

  assert_int_equal( validate_table_stats_request( table_stats_request ), 0 );

  free_buffer( table_stats_request );
}


static void
test_validate_table_stats_request_fails_if_message_is_NULL() {
  expect_assert_failure( validate_table_stats_request( NULL ) );
}


static void
test_validate_table_stats_request_fails_if_message_is_not_table_stats_request() {
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, NULL );

  assert_int_equal( validate_table_stats_request( echo_request ), ERROR_INVALID_TYPE );

  free_buffer( echo_request );
}


/********************************************************************************
 * validate_table_stats_reply() test.
 ********************************************************************************/

static void
test_validate_table_stats_reply() {
  uint16_t flags = OFPSF_REPLY_MORE;
  uint16_t stats_len;
  list_element *expected_list;
  struct ofp_table_stats *stats[ 2 ];
  buffer *expected_message = NULL;
  int ret_val;

  stats_len = sizeof( struct ofp_table_stats );

  stats[ 0 ] = xcalloc( 1, stats_len );
  stats[ 1 ] = xcalloc( 1, stats_len );

  stats[ 0 ]->table_id = 1;
  strcpy( 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;
  strcpy( stats[ 1 ]->name, "Table 2" );

  create_list( &expected_list );
  append_to_tail( &expected_list, stats[ 0 ] );
  append_to_tail( &expected_list, stats[ 1 ] );

  expected_message = create_table_stats_reply( MY_TRANSACTION_ID, flags, expected_list );

  ret_val = validate_table_stats_reply( expected_message );
  assert_int_equal( ret_val, 0 );

  xfree( stats[ 0 ] );
  xfree( stats[ 1 ] );
  delete_list( expected_list );
  free_buffer( expected_message );
}


/********************************************************************************
 * validate_port_stats_request() tests.
 ********************************************************************************/

static void
test_validate_port_stats_request() {
  uint16_t port_no = 1;
  buffer *port_stats_request = create_port_stats_request( MY_TRANSACTION_ID, NO_FLAGS, port_no );

  assert_int_equal( validate_port_stats_request( port_stats_request ), 0 );

  free_buffer( port_stats_request );
}


static void
test_validate_port_stats_request_fails_if_message_is_NULL() {
  expect_assert_failure( validate_port_stats_request( NULL ) );
}


static void
test_validate_port_stats_request_fails_if_message_is_not_port_stats_request() {
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, NULL );

  assert_int_equal( validate_port_stats_request( echo_request ), ERROR_INVALID_TYPE );

  free_buffer( echo_request );
}


/********************************************************************************
 * validate_port_stats_reply() test.
 ********************************************************************************/

static void
test_validate_port_stats_reply() {
  void *expected_data;
  uint16_t flags = OFPSF_REPLY_MORE;
  uint16_t stats_len;
  list_element *expected_list;
  struct ofp_port_stats *stats[ 2 ];
  buffer *expected_message = NULL;
  int ret_val;

  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( &expected_list );
  append_to_tail( &expected_list, stats[ 0 ] );
  append_to_tail( &expected_list, 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 );

  expected_message = create_port_stats_reply( MY_TRANSACTION_ID, flags, expected_list );

  ret_val = validate_port_stats_reply( expected_message );
  assert_int_equal( ret_val, 0 );

  xfree( stats[ 0 ] );
  xfree( stats[ 1 ] );
  xfree( expected_data );
  delete_list( expected_list );
  free_buffer( expected_message );
}


/********************************************************************************
 * validate_stats_request() tests.
 ********************************************************************************/

static void
test_validate_stats_request_sucseed_with_OFPST_DESC_message() {
  buffer *stats_desc_request = create_desc_stats_request( MY_TRANSACTION_ID, 0 );

  assert_int_equal( validate_stats_request( stats_desc_request ), 0 );

  free_buffer( stats_desc_request );
}


static void
test_validate_stats_request_sucseed_with_OFPST_FLOW_message() {
  uint8_t table_id = 0xff;
  uint16_t port_no = 1;
  buffer *stats_flow_request = create_flow_stats_request( MY_TRANSACTION_ID, NO_FLAGS, MATCH, table_id, port_no );

  assert_int_equal( validate_stats_request( stats_flow_request ), 0 );

  free_buffer( stats_flow_request );
}


static void
test_validate_stats_request_sucseed_with_OFPST_AGGREGATE_message() {
  uint8_t table_id = 0xff;
  uint16_t port_no = 1;
  buffer *stats_addregate_request = create_aggregate_stats_request( MY_TRANSACTION_ID, NO_FLAGS, MATCH, table_id, port_no );

  assert_int_equal( validate_stats_request( stats_addregate_request ), 0 );

  free_buffer( stats_addregate_request );
}


static void
test_validate_stats_request_sucseed_with_OFPST_TABLE_message() {
  buffer *stats_table_request = create_table_stats_request( MY_TRANSACTION_ID, 0 );

  assert_int_equal( validate_stats_request( stats_table_request ), 0 );

  free_buffer( stats_table_request );
}


static void
test_validate_stats_request_sucseed_with_OFPST_PORT_message() {
  uint16_t port_no = 1;
  buffer *stats_port_request = create_port_stats_request( MY_TRANSACTION_ID, NO_FLAGS, port_no );

  assert_int_equal( validate_stats_request( stats_port_request ), 0 );

  free_buffer( stats_port_request );
}


static void
test_validate_stats_request_sucseed_with_OFPST_QUEUE_message() {
  uint16_t port_no = 1;
  uint32_t queue_id = 10;
  buffer *stats_queue_request = create_queue_stats_request( MY_TRANSACTION_ID, NO_FLAGS, port_no, queue_id );

  assert_int_equal( validate_stats_request( stats_queue_request ), 0 );

  free_buffer( stats_queue_request );
}


static void
test_validate_stats_request_sucseed_with_OFPST_VENDOR_message() {
  buffer *stats_vendor_request = create_vendor_stats_request( MY_TRANSACTION_ID, NO_FLAGS, VENDOR_ID, NULL );

  assert_int_equal( validate_stats_request( stats_vendor_request ), 0 );

  free_buffer( stats_vendor_request );
}


static void
test_validate_stats_request_fails_if_message_is_NULL() {
  expect_assert_failure( validate_stats_request( NULL ) );
}


static void
test_validate_stats_request_fails_with_unsupported_stats_type() {
  buffer *broken_stats_request = create_vendor_stats_request( MY_TRANSACTION_ID, NO_FLAGS, VENDOR_ID, NULL );
  struct ofp_stats_request *stats_request = ( struct ofp_stats_request * ) broken_stats_request->data;
  const uint16_t unsupported_stats_type = ( uint16_t ) -2;
  stats_request->type = htons( unsupported_stats_type );

  assert_int_equal( validate_stats_request( broken_stats_request ), ERROR_UNSUPPORTED_STATS_TYPE );

  free_buffer( broken_stats_request );
}


/********************************************************************************
 * validate_stats_reply() tests.
 ********************************************************************************/

static void
test_validate_stats_reply_with_OFPST_DESC_message() {
  const char mfr_desc[ DESC_STR_LEN ] = "Trema Corporation";
  const char hw_desc[ DESC_STR_LEN ] = "Switching Hub type:B - for Trema";
  const char sw_desc[ DESC_STR_LEN ] = "System - b - OS version 1.0.0";
  const char serial_num[ SERIAL_NUM_LEN ] = "SN101224";
  const char dp_desc[ DESC_STR_LEN ] = "readble datapath 1012-1103";
  buffer *desc_stats_reply = create_desc_stats_reply( MY_TRANSACTION_ID, 0, mfr_desc, hw_desc, sw_desc, serial_num, dp_desc );

  assert_int_equal( validate_stats_reply( desc_stats_reply ), 0 );

  free_buffer( desc_stats_reply );
}


static void
test_validate_stats_reply_with_OFPST_FLOW_message() {
  list_element *flow_stats_list;
  struct ofp_flow_stats *flow_stats[ 2 ];
  struct ofp_action_output *action;

  uint16_t flow_stats_len = offsetof( struct ofp_flow_stats, actions ) + sizeof( struct ofp_action_output );
  flow_stats[ 0 ] = xcalloc( 1, flow_stats_len );
  flow_stats[ 1 ] = xcalloc( 1, flow_stats_len );
  flow_stats[ 0 ]->length = flow_stats_len;
  flow_stats[ 0 ]->table_id = 1;
  flow_stats[ 0 ]->pad = 0;
  flow_stats[ 0 ]->match = MATCH;
  flow_stats[ 0 ]->duration_sec = 60;
  flow_stats[ 0 ]->duration_nsec = 10000;
  flow_stats[ 0 ]->priority = PRIORITY;
  flow_stats[ 0 ]->idle_timeout = ONE_MINUTES_TIMEOUT;
  flow_stats[ 0 ]->hard_timeout = ( uint16_t ) ( ONE_MINUTES_TIMEOUT * 60 );
  flow_stats[ 0 ]->cookie = ISSUED_COOKIE;
  flow_stats[ 0 ]->packet_count = RECEIVED_PACKETS;
  flow_stats[ 0 ]->byte_count = RECEIVED_BYTES;
  action = ( struct ofp_action_output * ) flow_stats[ 0 ]->actions;
  action->type = OFPAT_OUTPUT;
  action->len = 8;
  action->port = 1;
  action->max_len = 2048;
  memcpy( flow_stats[ 1 ], flow_stats[ 0 ], flow_stats_len );
  ( ( struct ofp_action_output * ) flow_stats[ 1 ]->actions )->port = 2;
  create_list( &flow_stats_list );
  append_to_tail( &flow_stats_list, flow_stats[ 0 ] );
  append_to_tail( &flow_stats_list, flow_stats[ 1 ] );
  buffer *flow_stats_reply = create_flow_stats_reply( MY_TRANSACTION_ID, OFPSF_REPLY_MORE, flow_stats_list );

  assert_int_equal( validate_stats_reply( flow_stats_reply ), 0 );

  xfree( flow_stats[ 0 ] );
  xfree( flow_stats[ 1 ] );
  delete_list( flow_stats_list );
  free_buffer( flow_stats_reply );
}


static void
test_validate_stats_reply_with_OFPST_AGGREGATE_message() {
  uint32_t flow_count = 1000;
  uint64_t packet_count = RECEIVED_PACKETS;
  uint64_t byte_count = RECEIVED_BYTES;
  buffer *aggregate_stats_reply = create_aggregate_stats_reply( MY_TRANSACTION_ID, 0, packet_count, byte_count, flow_count );

  assert_int_equal( validate_stats_reply( aggregate_stats_reply ), 0 );

  free_buffer( aggregate_stats_reply );
}


static void
test_validate_stats_reply_with_OFPST_TABLE_message() {
  uint16_t table_stats_len;
  list_element *table_stats_list;
  struct ofp_table_stats *table_stats[ 2 ];

  table_stats_len = sizeof( struct ofp_table_stats );
  table_stats[ 0 ] = xcalloc( 1, table_stats_len );
  table_stats[ 1 ] = xcalloc( 1, table_stats_len );
  table_stats[ 0 ]->table_id = 1;
  strcpy( table_stats[ 0 ]->name, "Name of Flow Table No.1" );
  table_stats[ 0 ]->wildcards =  OFPFW_ALL;
  table_stats[ 0 ]->max_entries = SUPPORTED_ENTRIES_IN_OFPST_TABLE;
  table_stats[ 0 ]->active_count = ACTIVE_ENTRIES_IN_OFPST_TABLE;
  table_stats[ 0 ]->lookup_count = PACKETS_LOOK_UP_IN_OFPST_TABLE;
  table_stats[ 0 ]->matched_count = PACKETS_HIT_OFPST_TABLE;
  memcpy( table_stats[ 1 ], table_stats[ 0 ], table_stats_len );
  table_stats[ 1 ]->table_id = 2;
  strcpy( table_stats[ 1 ]->name, "Name of Flow Table No.2" );
  create_list( &table_stats_list );
  append_to_tail( &table_stats_list, table_stats[ 0 ] );
  append_to_tail( &table_stats_list, table_stats[ 1 ] );
  buffer *table_stats_reply = create_table_stats_reply( MY_TRANSACTION_ID, OFPSF_REPLY_MORE, table_stats_list );

  assert_int_equal( validate_stats_reply( table_stats_reply ), 0 );

  xfree( table_stats[ 0 ] );
  xfree( table_stats[ 1 ] );
  delete_list( table_stats_list );
  free_buffer( table_stats_reply );
}


static void
test_validate_stats_reply_with_OFPST_PORT_message() {
  list_element *port_stats_list;
  struct ofp_port_stats *port_stats[ 2 ];

  uint16_t port_stats_len = sizeof( struct ofp_port_stats );
  port_stats[ 0 ] = xcalloc( 1, port_stats_len );
  port_stats[ 1 ] = xcalloc( 1, port_stats_len );
  port_stats[ 0 ]->port_no = 1;
  port_stats[ 0 ]->rx_packets = RECEIVED_PACKETS;
  port_stats[ 0 ]->tx_packets = TRANSMITTED_PACKETS;
  port_stats[ 0 ]->rx_bytes = RECEIVED_BYTES;
  port_stats[ 0 ]->tx_bytes = TRANSMITTED_BYTES;
  // Not packets dropped.
  port_stats[ 0 ]->rx_dropped = NO_ERROR;
  port_stats[ 0 ]->tx_dropped = NO_ERROR;
  // Not packet errors.
  port_stats[ 0 ]->rx_errors = NO_ERROR;
  port_stats[ 0 ]->tx_errors = NO_ERROR;
  // Not frame alignment errors.
  port_stats[ 0 ]->rx_frame_err = NO_ERROR;
  // Not packets with RX overrun.
  port_stats[ 0 ]->rx_over_err = NO_ERROR;
  // Not CRC errors.
  port_stats[ 0 ]->rx_crc_err = NO_ERROR;
  // Not collisions.
  port_stats[ 0 ]->collisions = NO_ERROR;
  memcpy( port_stats[ 1 ], port_stats[ 0 ], port_stats_len );
  port_stats[ 1 ]->port_no = 2;
  create_list( &port_stats_list );
  append_to_tail( &port_stats_list, port_stats[ 0 ] );
  append_to_tail( &port_stats_list, port_stats[ 1 ] );
  buffer *port_stats_reply = create_port_stats_reply( MY_TRANSACTION_ID, OFPSF_REPLY_MORE, port_stats_list );

  assert_int_equal( validate_stats_reply( port_stats_reply ), 0 );

  xfree( port_stats[ 0 ] );
  xfree( port_stats[ 1 ] );
  delete_list( port_stats_list );
  free_buffer( port_stats_reply );
}


static void
test_validate_stats_reply_with_OFPST_QUEUE_message() {
  list_element *queue_stats_list;
  uint16_t queue_stats_len;
  struct ofp_queue_stats *queue_stats[ 2 ];

  queue_stats_len = sizeof( struct ofp_queue_stats );
  queue_stats[ 0 ] = xcalloc( 1, queue_stats_len );
  queue_stats[ 1 ] = xcalloc( 1, queue_stats_len );
  queue_stats[ 0 ]->port_no = 1;
  queue_stats[ 0 ]->queue_id = 2;
  queue_stats[ 0 ]->tx_bytes = TRANSMITTED_BYTES;
  queue_stats[ 0 ]->tx_packets = TRANSMITTED_PACKETS;
  // Not packets dropped.
  queue_stats[ 0 ]->tx_errors = NO_ERROR;
  memcpy( queue_stats[ 1 ], queue_stats[ 0 ], queue_stats_len );
  queue_stats[ 1 ]->queue_id = 3;
  create_list( &queue_stats_list );
  append_to_tail( &queue_stats_list, queue_stats[ 0 ] );
  append_to_tail( &queue_stats_list, queue_stats[ 1 ] );
  buffer *queue_stats_reply = create_queue_stats_reply( MY_TRANSACTION_ID, OFPSF_REPLY_MORE, queue_stats_list );

  assert_int_equal( validate_stats_reply( queue_stats_reply ), 0 );

  xfree( queue_stats[ 0 ] );
  xfree( queue_stats[ 1 ] );
  delete_list( queue_stats_list );
  free_buffer( queue_stats_reply );
}


static void
test_validate_stats_reply_with_OFPST_VENDOR_message() {
  buffer *vendor_body = alloc_buffer_with_length( 128 );
  append_back_buffer( vendor_body, 128 );
  memset( vendor_body->data, 0xa1, vendor_body->length );
  buffer *vendor_stats_reply = create_vendor_stats_reply( MY_TRANSACTION_ID, 0, VENDOR_ID, vendor_body );

  assert_int_equal( validate_stats_reply( vendor_stats_reply ), 0 );

  free_buffer( vendor_body );
  free_buffer( vendor_stats_reply );
}


static void
test_validate_stats_reply_fails_if_message_is_NULL() {
  expect_assert_failure( validate_stats_reply( NULL ) );
}


static void
test_validate_stats_reply_fails_with_unsupported_stats_type() {
  buffer *broken_stats_reply = create_vendor_stats_reply( MY_TRANSACTION_ID, NO_FLAGS, VENDOR_ID, NULL );
  struct ofp_stats_reply *stats_reply = ( struct ofp_stats_reply * ) broken_stats_reply->data;
  const uint16_t unsupported_stats_type = ( uint16_t ) -2;
  stats_reply->type = htons( unsupported_stats_type );

  assert_int_equal( validate_stats_reply( broken_stats_reply ), ERROR_UNSUPPORTED_STATS_TYPE );

  free_buffer( broken_stats_reply );
}


/********************************************************************************
 * validate_queue_stats_request() tests.
 ********************************************************************************/

static void
test_validate_queue_stats_request() {
  buffer *port_stats_request = create_queue_stats_request( MY_TRANSACTION_ID, NO_FLAGS, OFPP_ALL, OFPQ_ALL );

  assert_int_equal( validate_queue_stats_request( port_stats_request ), 0 );

  free_buffer( port_stats_request );
}


static void
test_validate_queue_stats_request_fails_if_message_is_NULL() {
  expect_assert_failure( validate_queue_stats_request( NULL ) );
}


static void
test_validate_queue_stats_request_fails_if_message_is_not_queue_stats_request() {
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, NULL );

  assert_int_equal( validate_queue_stats_request( echo_request ), ERROR_INVALID_TYPE );

  free_buffer( echo_request );
}


/********************************************************************************
 * validate_queue_stats_reply() test.
 ********************************************************************************/

static void
test_validate_queue_stats_reply() {
  uint16_t flags = OFPSF_REPLY_MORE;
  list_element *list;
  uint16_t stats_len;
  struct ofp_queue_stats *stats[ 2 ];
  buffer *expected_message;
  int ret_val;

  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( &list );
  append_to_tail( &list, stats[ 0 ] );
  append_to_tail( &list, stats[ 1 ] );

  expected_message = create_queue_stats_reply( MY_TRANSACTION_ID, flags, list );

  ret_val = validate_queue_stats_reply( expected_message );
  assert_int_equal( ret_val, 0 );

  xfree( stats[ 0 ] );
  xfree( stats[ 1 ] );
  delete_list( list );
  free_buffer( expected_message );
}


/********************************************************************************
 * validate_vendor_stats_request() tests.
 ********************************************************************************/

static void
test_validate_vendor_stats_request() {
  buffer *vendor_stats_request = create_vendor_stats_request( MY_TRANSACTION_ID, NO_FLAGS, VENDOR_ID, NULL );

  assert_int_equal( validate_vendor_stats_request( vendor_stats_request ), 0 );

  free_buffer( vendor_stats_request );
}


static void
test_validate_vendor_stats_request_fails_if_message_is_NULL() {
  expect_assert_failure( validate_vendor_stats_request( NULL ) );
}


static void
test_validate_vendor_stats_request_fails_if_message_is_not_vendor_stats_request() {
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, NULL );

  assert_int_equal( validate_vendor_stats_request( echo_request ), ERROR_INVALID_TYPE );

  free_buffer( echo_request );
}


/********************************************************************************
 * validate_vendor_stats_reply() test.
 ********************************************************************************/

static void
test_validate_vendor_stats_reply() {
  uint32_t expected_vendor = VENDOR_ID;
  buffer *expected_message, *body;
  struct ofp_stats_reply;
  int ret_val;

  body = alloc_buffer_with_length( 128 );
  append_back_buffer( body, 128 );
  memset( body->data, 0xa1, body->length );

  expected_message = create_vendor_stats_reply( MY_TRANSACTION_ID, NO_FLAGS, expected_vendor, body );

  ret_val = validate_vendor_stats_reply( expected_message );
  assert_int_equal( ret_val, 0 );

  free_buffer( body );
  free_buffer( expected_message );
}


/********************************************************************************
 * validate_barrier_reply() test.
 ********************************************************************************/

static void
test_validate_barrier_reply() {
  buffer *expected_message;
  int ret_val;
  expected_message = create_barrier_reply( MY_TRANSACTION_ID );

  ret_val = validate_barrier_reply( expected_message );
  assert_int_equal( ret_val, 0 );
  free_buffer( expected_message );
}


/********************************************************************************
 * validate_queue_get_config_reply() test.
 ********************************************************************************/

static void
test_validate_queue_get_config_reply() {
  size_t queue_len;
  uint16_t port = 1;
  list_element *list;
  buffer *expected_message;
  struct ofp_packet_queue *queue[ 2 ];
  struct ofp_queue_prop_header *prop_header;
  int ret_val;

  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( &list );
  append_to_tail( &list, queue[ 0 ] );
  append_to_tail( &list, queue[ 1 ] );

  expected_message = create_queue_get_config_reply( MY_TRANSACTION_ID, port, list );

  ret_val = validate_queue_get_config_reply( expected_message );
  assert_int_equal( ret_val, 0 );

  xfree( queue[ 0 ] );
  xfree( queue[ 1 ] );
  delete_list( list );
  free_buffer( expected_message );
}


/********************************************************************************
 * validate_action_output() tests.
 ********************************************************************************/

static void
test_validate_action_output() {
  uint16_t port = 1;

  openflow_actions *actions = create_actions();
  append_action_output( actions, port, MAX_LENGTH_OF_SEND_PACKET );
  struct ofp_action_output action_output;
  hton_action_output( &action_output, ( struct ofp_action_output * ) ( actions->list->data ) );

  assert_int_equal( validate_action_output( &action_output ), 0 );

  delete_actions( actions );
}


static void
test_validate_action_output_fails_with_invalid_action_type() {
  openflow_actions *actions = create_actions();
  append_action_set_dl_src( actions, HW_ADDR );
  struct ofp_action_dl_addr action_dl_addr;
  hton_action_dl_addr( &action_dl_addr, ( struct ofp_action_dl_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_output( ( struct ofp_action_output * ) &action_dl_addr ), ERROR_INVALID_ACTION_TYPE );

  delete_actions( actions );
}


static void
test_validate_action_output_fails_with_too_short_ofp_action_output() {
  uint16_t port = 1;

  openflow_actions *actions = create_actions();
  append_action_output( actions, port, MAX_LENGTH_OF_SEND_PACKET );
  uint16_t too_short_action_length = sizeof( struct ofp_action_output ) - 1;
  ( ( struct ofp_action_output * ) ( actions->list->data ) )->len = too_short_action_length;
  struct ofp_action_output too_short_action_output;
  hton_action_output( &too_short_action_output, ( struct ofp_action_output * ) ( actions->list->data ) );

  assert_int_equal( validate_action_output( &too_short_action_output ), ERROR_TOO_SHORT_ACTION_OUTPUT );

  delete_actions( actions );
}


static void
test_validate_action_output_fails_with_too_long_ofp_action_output() {
  uint16_t port = 1;

  openflow_actions *actions = create_actions();
  append_action_output( actions, port, MAX_LENGTH_OF_SEND_PACKET );
  uint16_t too_long_action_length = sizeof( struct ofp_action_output ) + 1;
  ( ( struct ofp_action_output * ) ( actions->list->data ) )->len = too_long_action_length;
  struct ofp_action_output too_long_action_output;
  hton_action_output( &too_long_action_output, ( struct ofp_action_output * ) ( actions->list->data ) );

  assert_int_equal( validate_action_output( &too_long_action_output ), ERROR_TOO_LONG_ACTION_OUTPUT );

  delete_actions( actions );
}


static void
test_validate_action_output_fails_with_invalid_port_no() {
  uint16_t port = 0;

  openflow_actions *actions = create_actions();
  append_action_output( actions, port, MAX_LENGTH_OF_SEND_PACKET );
  struct ofp_action_output action_output;
  hton_action_output( &action_output, ( struct ofp_action_output * ) ( actions->list->data ) );

  assert_int_equal( validate_action_output( &action_output ), ERROR_INVALID_PORT_NO );

  delete_actions( actions );
}


/********************************************************************************
 * validate_action_set_vlan_vid() tests.
 ********************************************************************************/

static void
test_validate_action_set_vlan_vid() {
  openflow_actions *actions = create_actions();
  uint16_t vlan_vid = 0x0001;
  append_action_set_vlan_vid( actions, vlan_vid );
  struct ofp_action_vlan_vid action_vlan_vid;
  hton_action_vlan_vid( &action_vlan_vid, actions->list->data );

  assert_int_equal( validate_action_set_vlan_vid( &action_vlan_vid ), 0 );

  delete_actions( actions );
}


static void
test_validate_action_set_vlan_vid_fails_with_invalid_action_type() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_dst( actions, NW_ADDR );
  struct ofp_action_nw_addr action_nw_addr;
  hton_action_nw_addr( &action_nw_addr, actions->list->data );

  assert_int_equal( validate_action_set_vlan_vid( ( struct ofp_action_vlan_vid * ) &action_nw_addr ), ERROR_INVALID_ACTION_TYPE );

  delete_actions( actions );
}


static void
test_validate_action_set_vlan_vid_fails_with_invalid_vlan_vid() {
  openflow_actions *actions = create_actions();
  uint16_t vlan_vid = 0x0001;
  append_action_set_vlan_vid( actions, vlan_vid );
  uint16_t invalid_vlan_vid = 0x1000;
  ( ( struct ofp_action_vlan_vid * ) actions->list->data )->vlan_vid = invalid_vlan_vid;
  struct ofp_action_vlan_vid action_vlan_vid;
  hton_action_vlan_vid( &action_vlan_vid, actions->list->data );

  assert_int_equal( validate_action_set_vlan_vid( &action_vlan_vid ), ERROR_INVALID_VLAN_VID );

  delete_actions( actions );
}


static void
test_validate_action_set_vlan_vid_fails_with_too_short_ofp_action_vlan_vid() {
  openflow_actions *actions = create_actions();
  uint16_t vlan_vid = 0x0001;
  append_action_set_vlan_vid( actions, vlan_vid );
  struct ofp_action_vlan_vid *too_short_action_length = ( struct ofp_action_vlan_vid * ) actions->list->data;
  too_short_action_length->len = ( uint16_t ) ( too_short_action_length->len - 1 );
  struct ofp_action_vlan_vid too_short_action_vlan_vid;
  hton_action_vlan_vid( &too_short_action_vlan_vid, actions->list->data );

  assert_int_equal( validate_action_set_vlan_vid( &too_short_action_vlan_vid ), ERROR_TOO_SHORT_ACTION_VLAN_VID );

  delete_actions( actions );
}


static void
test_validate_action_set_vlan_vid_fails_with_too_long_ofp_action_vlan_vid() {
  openflow_actions *actions = create_actions();
  uint16_t vlan_vid = 0x0001;
  append_action_set_vlan_vid( actions, vlan_vid );
  struct ofp_action_vlan_vid *too_long_action_length = ( struct ofp_action_vlan_vid * ) actions->list->data;
  too_long_action_length->len = ( uint16_t ) ( too_long_action_length->len + 1 );
  struct ofp_action_vlan_vid too_long_action_vlan_vid;
  hton_action_vlan_vid( &too_long_action_vlan_vid, actions->list->data );

  assert_int_equal( validate_action_set_vlan_vid( &too_long_action_vlan_vid ), ERROR_TOO_LONG_ACTION_VLAN_VID );

  delete_actions( actions );
}


/********************************************************************************
 * validate_action_set_vlan_pcp() tests.
 ********************************************************************************/

static void
test_validate_action_set_vlan_pcp() {
  openflow_actions *actions = create_actions();
  uint8_t vlan_pcp = 0x01;
  append_action_set_vlan_pcp( actions, vlan_pcp );
  struct ofp_action_vlan_pcp action_vlan_pcp;
  hton_action_vlan_pcp( &action_vlan_pcp, actions->list->data );

  assert_int_equal( validate_action_set_vlan_pcp( &action_vlan_pcp ), 0 );

  delete_actions( actions );
}


static void
test_validate_action_set_vlan_pcp_fails_with_invalid_action_type() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_dst( actions, NW_ADDR );
  struct ofp_action_nw_addr action_nw_addr;
  hton_action_nw_addr( &action_nw_addr, actions->list->data );

  assert_int_equal( validate_action_set_vlan_pcp( ( struct ofp_action_vlan_pcp * ) &action_nw_addr ), ERROR_INVALID_ACTION_TYPE );

  delete_actions( actions );
}


static void
test_validate_action_set_vlan_pcp_fails_with_invalid_vlan_pcp() {
  openflow_actions *actions = create_actions();
  uint8_t vlan_pcp = 0x01;
  append_action_set_vlan_pcp( actions, vlan_pcp );
  uint8_t invalid_vlan_pcp = 0x08;
  ( ( struct ofp_action_vlan_pcp * ) actions->list->data )->vlan_pcp = invalid_vlan_pcp;
  struct ofp_action_vlan_pcp action_vlan_pcp;
  hton_action_vlan_pcp( &action_vlan_pcp, actions->list->data );

  assert_int_equal( validate_action_set_vlan_pcp( &action_vlan_pcp ), ERROR_INVALID_VLAN_PCP );

  delete_actions( actions );
}


static void
test_validate_action_set_vlan_pcp_fails_with_too_short_ofp_action_vlan_pcp() {
  openflow_actions *actions = create_actions();
  uint8_t vlan_pcp = 0x01;
  append_action_set_vlan_pcp( actions, vlan_pcp );
  struct ofp_action_vlan_pcp *too_short_action_length = ( struct ofp_action_vlan_pcp * ) actions->list->data;
  too_short_action_length->len = ( uint16_t ) ( too_short_action_length->len - 1 );
  struct ofp_action_vlan_pcp too_short_action_vlan_pcp;
  hton_action_vlan_pcp( &too_short_action_vlan_pcp, actions->list->data );

  assert_int_equal( validate_action_set_vlan_pcp( &too_short_action_vlan_pcp ), ERROR_TOO_SHORT_ACTION_VLAN_PCP );

  delete_actions( actions );
}


static void
test_validate_action_set_vlan_pcp_fails_with_too_long_ofp_action_vlan_pcp() {
  openflow_actions *actions = create_actions();
  uint8_t vlan_pcp = 0x01;
  append_action_set_vlan_pcp( actions, vlan_pcp );
  struct ofp_action_vlan_pcp *too_long_action_length = ( struct ofp_action_vlan_pcp * ) actions->list->data;
  too_long_action_length->len = ( uint16_t ) ( too_long_action_length->len + 1 );
  struct ofp_action_vlan_pcp too_long_action_vlan_pcp;
  hton_action_vlan_pcp( &too_long_action_vlan_pcp, actions->list->data );

  assert_int_equal( validate_action_set_vlan_pcp( &too_long_action_vlan_pcp ), ERROR_TOO_LONG_ACTION_VLAN_PCP );

  delete_actions( actions );
}


/********************************************************************************
 * validate_action_strip_vlan() tests.
 ********************************************************************************/

static void
test_validate_action_strip_vlan() {
  openflow_actions *actions = create_actions();
  append_action_strip_vlan( actions );
  struct ofp_action_header action_strip_vlan;
  hton_action_strip_vlan( &action_strip_vlan, actions->list->data );

  assert_int_equal( validate_action_strip_vlan( &action_strip_vlan ), 0 );

  delete_actions( actions );
}


static void
test_validate_action_strip_vlan_fails_with_invalid_action_type() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_dst( actions, NW_ADDR );
  struct ofp_action_nw_addr action_nw_addr;
  hton_action_nw_addr( &action_nw_addr, actions->list->data );

  assert_int_equal( validate_action_strip_vlan( ( struct ofp_action_header * ) &action_nw_addr ), ERROR_INVALID_ACTION_TYPE );

  delete_actions( actions );
}


static void
test_validate_action_strip_vlan_fails_with_too_short_ofp_action_header() {
  openflow_actions *actions = create_actions();
  append_action_strip_vlan( actions );
  struct ofp_action_header *too_short_action_length = ( struct ofp_action_header * ) actions->list->data;
  too_short_action_length->len = ( uint16_t ) ( too_short_action_length->len - 1 );
  struct ofp_action_header too_short_action_header;
  hton_action_strip_vlan( &too_short_action_header, actions->list->data );

  assert_int_equal( validate_action_strip_vlan( &too_short_action_header ), ERROR_TOO_SHORT_ACTION_STRIP_VLAN );

  delete_actions( actions );
}


static void
test_validate_action_strip_vlan_fails_with_too_long_ofp_action_header() {
  openflow_actions *actions = create_actions();
  append_action_strip_vlan( actions );
  struct ofp_action_header *too_long_action_length = ( struct ofp_action_header * ) actions->list->data;
  too_long_action_length->len = ( uint16_t ) ( too_long_action_length->len + 1 );
  struct ofp_action_header too_long_action_header;
  hton_action_strip_vlan( &too_long_action_header, actions->list->data );

  assert_int_equal( validate_action_strip_vlan( &too_long_action_header ), ERROR_TOO_LONG_ACTION_STRIP_VLAN );

  delete_actions( actions );
}


/********************************************************************************
 * validate_action_set_dl_src() tests.
 ********************************************************************************/

static void
test_validate_action_set_dl_src() {
  openflow_actions *actions = create_actions();
  append_action_set_dl_src( actions, HW_ADDR );
  struct ofp_action_dl_addr action_dl_addr;
  hton_action_dl_addr( &action_dl_addr, ( struct ofp_action_dl_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_dl_src( &action_dl_addr ), 0 );

  delete_actions( actions );
}


static void
test_validate_action_set_dl_src_fails_with_invalid_action_type() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_src( actions, NW_ADDR );
  struct ofp_action_nw_addr action_nw_addr;
  hton_action_nw_addr( &action_nw_addr, ( struct ofp_action_nw_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_dl_src( ( struct ofp_action_dl_addr * ) &action_nw_addr ), ERROR_INVALID_ACTION_TYPE );

  delete_actions( actions );
}


static void
test_validate_action_set_dl_src_fails_with_too_short_ofp_action_dl_addr() {
  openflow_actions *actions = create_actions();
  append_action_set_dl_src( actions, HW_ADDR );
  uint16_t too_short_action_length = sizeof( struct ofp_action_dl_addr ) - 1;
  ( ( struct ofp_action_dl_addr * ) ( actions->list->data ) )->len = too_short_action_length;
  struct ofp_action_dl_addr too_short_action_dl_addr;
  hton_action_dl_addr( &too_short_action_dl_addr, ( struct ofp_action_dl_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_dl_src( &too_short_action_dl_addr ), ERROR_TOO_SHORT_ACTION_DL_SRC );

  delete_actions( actions );
}


static void
test_validate_action_set_dl_src_fails_with_too_long_ofp_action_dl_addr() {
  openflow_actions *actions = create_actions();
  append_action_set_dl_src( actions, HW_ADDR );
  uint16_t too_long_action_length = sizeof( struct ofp_action_dl_addr ) + 1;
  ( ( struct ofp_action_dl_addr * ) ( actions->list->data ) )->len = too_long_action_length;
  struct ofp_action_dl_addr too_long_action_dl_addr;
  hton_action_dl_addr( &too_long_action_dl_addr, ( struct ofp_action_dl_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_dl_src( &too_long_action_dl_addr ), ERROR_TOO_LONG_ACTION_DL_SRC );

  delete_actions( actions );
}


/********************************************************************************
 * validate_action_set_dl_dst() tests.
 ********************************************************************************/

static void
test_validate_action_set_dl_dst() {
  openflow_actions *actions = create_actions();
  append_action_set_dl_dst( actions, HW_ADDR );
  struct ofp_action_dl_addr action_dl_addr;
  hton_action_dl_addr( &action_dl_addr, ( struct ofp_action_dl_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_dl_dst( &action_dl_addr ), 0 );

  delete_actions( actions );
}


static void
test_validate_action_set_dl_dst_fails_with_invalid_action_type() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_src( actions, NW_ADDR );
  struct ofp_action_nw_addr action_nw_addr;
  hton_action_nw_addr( &action_nw_addr, ( struct ofp_action_nw_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_dl_dst( ( struct ofp_action_dl_addr * ) &action_nw_addr ), ERROR_INVALID_ACTION_TYPE );

  delete_actions( actions );
}


static void
test_validate_action_set_dl_dst_fails_with_too_short_ofp_action_dl_addr() {
  openflow_actions *actions = create_actions();
  append_action_set_dl_dst( actions, HW_ADDR );
  uint16_t too_short_action_length = sizeof( struct ofp_action_dl_addr ) - 1;
  ( ( struct ofp_action_dl_addr * ) ( actions->list->data ) )->len = too_short_action_length;
  struct ofp_action_dl_addr too_short_action_dl_addr;
  hton_action_dl_addr( &too_short_action_dl_addr, ( struct ofp_action_dl_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_dl_dst( &too_short_action_dl_addr ), ERROR_TOO_SHORT_ACTION_DL_DST );

  delete_actions( actions );
}


static void
test_validate_action_set_dl_dst_fails_with_too_long_ofp_action_dl_addr() {
  openflow_actions *actions = create_actions();
  append_action_set_dl_dst( actions, HW_ADDR );
  uint16_t too_long_action_length = sizeof( struct ofp_action_dl_addr ) + 1;
  ( ( struct ofp_action_dl_addr * ) ( actions->list->data ) )->len = too_long_action_length;
  struct ofp_action_dl_addr too_long_action_dl_addr;
  hton_action_dl_addr( &too_long_action_dl_addr, ( struct ofp_action_dl_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_dl_dst( &too_long_action_dl_addr ), ERROR_TOO_LONG_ACTION_DL_DST );

  delete_actions( actions );
}


/********************************************************************************
 * validate_action_set_nw_src() tests.
 ********************************************************************************/

static void
test_validate_action_set_nw_src() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_src( actions, NW_ADDR );
  struct ofp_action_nw_addr action_nw_addr;
  hton_action_nw_addr( &action_nw_addr, ( struct ofp_action_nw_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_nw_src( &action_nw_addr ), 0 );

  delete_actions( actions );
}


static void
test_validate_action_set_nw_src_fails_with_invalid_action_type() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_tos( actions, NW_TOS );
  struct ofp_action_nw_tos action_nw_tos;
  hton_action_nw_tos( &action_nw_tos, ( struct ofp_action_nw_tos * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_nw_src( ( struct ofp_action_nw_addr * ) &action_nw_tos ), ERROR_INVALID_ACTION_TYPE );

  delete_actions( actions );
}


static void
test_validate_action_set_nw_src_fails_with_too_short_ofp_action_nw_addr() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_src( actions, NW_ADDR );
  uint16_t too_short_action_length = sizeof( struct ofp_action_nw_addr ) - 1;
  ( ( struct ofp_action_nw_addr * ) ( actions->list->data ) )->len = too_short_action_length;
  struct ofp_action_nw_addr too_short_action_nw_addr;
  hton_action_nw_addr( &too_short_action_nw_addr, ( struct ofp_action_nw_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_nw_src( &too_short_action_nw_addr ), ERROR_TOO_SHORT_ACTION_NW_SRC );

  delete_actions( actions );
}


static void
test_validate_action_set_nw_src_fails_with_too_long_ofp_action_nw_addr() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_src( actions, NW_ADDR );
  uint16_t too_long_action_length = sizeof( struct ofp_action_nw_addr ) + 1;
  ( ( struct ofp_action_nw_addr * ) ( actions->list->data ) )->len = too_long_action_length;
  struct ofp_action_nw_addr too_long_action_nw_addr;
  hton_action_nw_addr( &too_long_action_nw_addr, ( struct ofp_action_nw_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_nw_src( &too_long_action_nw_addr ), ERROR_TOO_LONG_ACTION_NW_SRC );

  delete_actions( actions );
}


/********************************************************************************
 * validate_action_set_nw_dst() tests.
 ********************************************************************************/

static void
test_validate_action_set_nw_dst() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_dst( actions, NW_ADDR );
  struct ofp_action_nw_addr action_nw_addr;
  hton_action_nw_addr( &action_nw_addr, ( struct ofp_action_nw_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_nw_dst( &action_nw_addr ), 0 );

  delete_actions( actions );
}


static void
test_validate_action_set_nw_dst_fails_with_invalid_action_type() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_tos( actions, NW_TOS );
  struct ofp_action_nw_tos action_nw_tos;
  hton_action_nw_tos( &action_nw_tos, ( struct ofp_action_nw_tos * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_nw_dst( ( struct ofp_action_nw_addr * ) &action_nw_tos ), ERROR_INVALID_ACTION_TYPE );

  delete_actions( actions );
}


static void
test_validate_action_set_nw_dst_fails_with_too_short_ofp_action_nw_addr() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_dst( actions, NW_ADDR );
  uint16_t too_short_action_length = sizeof( struct ofp_action_nw_addr ) - 1;
  ( ( struct ofp_action_nw_addr * ) ( actions->list->data ) )->len = too_short_action_length;
  struct ofp_action_nw_addr too_short_action_nw_addr;
  hton_action_nw_addr( &too_short_action_nw_addr, ( struct ofp_action_nw_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_nw_dst( &too_short_action_nw_addr ), ERROR_TOO_SHORT_ACTION_NW_DST );

  delete_actions( actions );
}


static void
test_validate_action_set_nw_dst_fails_with_too_long_ofp_action_nw_addr() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_dst( actions, NW_ADDR );
  uint16_t too_long_action_length = sizeof( struct ofp_action_nw_addr ) + 1;
  ( ( struct ofp_action_nw_addr * ) ( actions->list->data ) )->len = too_long_action_length;
  struct ofp_action_nw_addr too_long_action_nw_addr;
  hton_action_nw_addr( &too_long_action_nw_addr, ( struct ofp_action_nw_addr * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_nw_dst( &too_long_action_nw_addr ), ERROR_TOO_LONG_ACTION_NW_DST );

  delete_actions( actions );
}


/********************************************************************************
 * validate_action_set_nw_tos() tests.
 ********************************************************************************/

static void
test_validate_action_set_nw_tos() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_tos( actions, NW_TOS );
  struct ofp_action_nw_tos action_nw_tos;
  hton_action_nw_tos( &action_nw_tos, ( struct ofp_action_nw_tos * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_nw_tos( &action_nw_tos ), 0 );

  delete_actions( actions );
}


static void
test_validate_action_set_nw_tos_fails_with_invalid_action_type() {
  uint16_t tp_port = 1;

  openflow_actions *actions = create_actions();
  append_action_set_tp_src( actions, tp_port );
  struct ofp_action_tp_port action_tp_port;
  hton_action_tp_port( &action_tp_port, ( struct ofp_action_tp_port * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_nw_tos( ( struct ofp_action_nw_tos * ) &action_tp_port ), ERROR_INVALID_ACTION_TYPE );

  delete_actions( actions );
}


static void
test_validate_action_set_nw_tos_fails_with_too_short_ofp_action_nw_tos() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_tos( actions, NW_TOS );
  uint16_t too_short_action_length = sizeof( struct ofp_action_nw_tos ) - 1;
  ( ( struct ofp_action_nw_tos * ) ( actions->list->data ) )->len = too_short_action_length;
  struct ofp_action_nw_tos too_short_action_nw_tos;
  hton_action_nw_tos( &too_short_action_nw_tos, ( struct ofp_action_nw_tos * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_nw_tos( &too_short_action_nw_tos ), ERROR_TOO_SHORT_ACTION_NW_TOS );

  delete_actions( actions );
}


static void
test_validate_action_set_nw_tos_fails_with_too_long_ofp_action_nw_tos() {
  openflow_actions *actions = create_actions();
  append_action_set_nw_tos( actions, NW_TOS );
  uint16_t too_long_action_length = sizeof( struct ofp_action_nw_tos ) + 1;
  ( ( struct ofp_action_nw_tos * ) ( actions->list->data ) )->len = too_long_action_length;
  struct ofp_action_nw_tos too_long_action_nw_tos;
  hton_action_nw_tos( &too_long_action_nw_tos, ( struct ofp_action_nw_tos * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_nw_tos( &too_long_action_nw_tos ), ERROR_TOO_LONG_ACTION_NW_TOS );

  delete_actions( actions );
}


/********************************************************************************
 * validate_action_set_tp_src() tests.
 ********************************************************************************/

static void
test_validate_action_set_tp_src() {
  uint16_t tp_port = 1;

  openflow_actions *actions = create_actions();
  append_action_set_tp_src( actions, tp_port );
  struct ofp_action_tp_port action_tp_port;
  hton_action_tp_port( &action_tp_port, ( struct ofp_action_tp_port * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_tp_src( &action_tp_port ), 0 );

  delete_actions( actions );
}


static void
test_validate_action_set_tp_src_fails_with_invalid_action_type() {
  uint16_t port = 1;
  uint32_t queue_id = 10;

  openflow_actions *actions = create_actions();
  append_action_enqueue( actions, port, queue_id );
  struct ofp_action_enqueue action_enqueue;
  hton_action_enqueue( &action_enqueue, ( struct ofp_action_enqueue * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_tp_src( ( struct ofp_action_tp_port * ) &action_enqueue ), ERROR_INVALID_ACTION_TYPE );

  delete_actions( actions );
}


static void
test_validate_action_set_tp_src_fails_with_too_short_ofp_action_tp_port() {
  uint16_t tp_port = 1;

  openflow_actions *actions = create_actions();
  append_action_set_tp_src( actions, tp_port );
  uint16_t too_short_action_length = sizeof( struct ofp_action_tp_port ) - 1;
  ( ( struct ofp_action_tp_port * ) ( actions->list->data ) )->len = too_short_action_length;
  struct ofp_action_tp_port too_short_action_tp_port;
  hton_action_tp_port( &too_short_action_tp_port, ( struct ofp_action_tp_port * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_tp_src( &too_short_action_tp_port ), ERROR_TOO_SHORT_ACTION_TP_SRC );

  delete_actions( actions );
}


static void
test_validate_action_set_tp_src_fails_with_too_long_ofp_action_tp_port() {
  uint16_t tp_port = 1;

  openflow_actions *actions = create_actions();
  append_action_set_tp_src( actions, tp_port );
  uint16_t too_long_action_length = sizeof( struct ofp_action_tp_port ) + 1;
  ( ( struct ofp_action_tp_port * ) ( actions->list->data ) )->len = too_long_action_length;
  struct ofp_action_tp_port too_long_action_tp_port;
  hton_action_tp_port( &too_long_action_tp_port, ( struct ofp_action_tp_port * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_tp_src( &too_long_action_tp_port ), ERROR_TOO_LONG_ACTION_TP_SRC );

  delete_actions( actions );
}


/********************************************************************************
 * validate_action_set_tp_dst() tests.
 ********************************************************************************/

static void
test_validate_action_set_tp_dst() {
  uint16_t tp_port = 1;

  openflow_actions *actions = create_actions();
  append_action_set_tp_dst( actions, tp_port );
  struct ofp_action_tp_port action_tp_port;
  hton_action_tp_port( &action_tp_port, ( struct ofp_action_tp_port * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_tp_dst( &action_tp_port ), 0 );

  delete_actions( actions );
}


static void
test_validate_action_set_tp_dst_fails_with_invalid_action_type() {
  uint16_t port = 1;
  uint32_t queue_id = 10;

  openflow_actions *actions = create_actions();
  append_action_enqueue( actions, port, queue_id );
  struct ofp_action_enqueue action_enqueue;
  hton_action_enqueue( &action_enqueue, ( struct ofp_action_enqueue * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_tp_dst( ( struct ofp_action_tp_port * ) &action_enqueue ), ERROR_INVALID_ACTION_TYPE );

  delete_actions( actions );
}


static void
test_validate_action_set_tp_dst_fails_with_too_short_ofp_action_tp_port() {
  uint16_t tp_port = 1;

  openflow_actions *actions = create_actions();
  append_action_set_tp_dst( actions, tp_port );
  uint16_t too_short_action_length = sizeof( struct ofp_action_tp_port ) - 1;
  ( ( struct ofp_action_tp_port * ) ( actions->list->data ) )->len = too_short_action_length;
  struct ofp_action_tp_port too_short_action_tp_port;
  hton_action_tp_port( &too_short_action_tp_port, ( struct ofp_action_tp_port * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_tp_dst( &too_short_action_tp_port ), ERROR_TOO_SHORT_ACTION_TP_DST );

  delete_actions( actions );
}


static void
test_validate_action_set_tp_dst_fails_with_too_long_ofp_action_tp_port() {
  uint16_t tp_port = 1;

  openflow_actions *actions = create_actions();
  append_action_set_tp_dst( actions, tp_port );
  uint16_t too_long_action_length = sizeof( struct ofp_action_tp_port ) + 1;
  ( ( struct ofp_action_tp_port * ) ( actions->list->data ) )->len = too_long_action_length;
  struct ofp_action_tp_port too_long_action_tp_port;
  hton_action_tp_port( &too_long_action_tp_port, ( struct ofp_action_tp_port * ) ( actions->list->data ) );

  assert_int_equal( validate_action_set_tp_dst( &too_long_action_tp_port ), ERROR_TOO_LONG_ACTION_TP_DST );

  delete_actions( actions );
}


/********************************************************************************
 * validate_action_enqueue() tests.
 ********************************************************************************/

static void
test_validate_action_enqueue() {
  uint16_t port = 1;
  uint32_t queue_id = 10;

  openflow_actions *actions = create_actions();
  append_action_enqueue( actions, port, queue_id );
  struct ofp_action_enqueue action_enqueue;
  hton_action_enqueue( &action_enqueue, ( struct ofp_action_enqueue * ) ( actions->list->data ) );

  assert_int_equal( validate_action_enqueue( &action_enqueue ), 0 );

  delete_actions( actions );
}


static void
test_validate_action_enqueue_fails_with_invalid_action_type() {
  buffer *body = create_dummy_data( SHORT_DATA_LENGTH );
  openflow_actions *actions = create_actions();
  append_action_vendor( actions, VENDOR_ID, body );
  struct ofp_action_vendor_header action_vendor;
  hton_action_vendor( &action_vendor, ( struct ofp_action_vendor_header * ) ( actions->list->data ) );

  assert_int_equal( validate_action_enqueue( ( struct ofp_action_enqueue * ) &action_vendor ), ERROR_INVALID_ACTION_TYPE );

  free_buffer( body );
  delete_actions( actions );
}


static void
test_validate_action_enqueue_fails_with_too_short_ofp_action_enqueue() {
  uint16_t port = 1;
  uint32_t queue_id = 10;

  openflow_actions *actions = create_actions();
  append_action_enqueue( actions, port, queue_id );
  uint16_t too_short_action_length = sizeof( struct ofp_action_enqueue ) - 1;
  ( ( struct ofp_action_enqueue * )( actions->list->data ) )->len = too_short_action_length;
  struct ofp_action_enqueue too_short_action_enqueue;
  hton_action_enqueue( &too_short_action_enqueue, ( struct ofp_action_enqueue * ) ( actions->list->data ) );

  assert_int_equal( validate_action_enqueue( &too_short_action_enqueue ), ERROR_TOO_SHORT_ACTION_ENQUEUE );

  delete_actions( actions );
}


static void
test_validate_action_enqueue_fails_with_too_long_ofp_action_enqueue() {
  uint16_t port = 1;
  uint32_t queue_id = 10;

  openflow_actions *actions = create_actions();
  append_action_enqueue( actions, port, queue_id );
  uint16_t too_long_action_length = sizeof( struct ofp_action_enqueue ) + 1;
  ( ( struct ofp_action_enqueue * ) ( actions->list->data ) )->len = too_long_action_length;
  struct ofp_action_enqueue too_long_action_enqueue;
  hton_action_enqueue( &too_long_action_enqueue, ( struct ofp_action_enqueue * ) ( actions->list->data ) );

  assert_int_equal( validate_action_enqueue( &too_long_action_enqueue ), ERROR_TOO_LONG_ACTION_ENQUEUE );

  delete_actions( actions );
}


/********************************************************************************
 * validate_action_vendor() tests.
 ********************************************************************************/

static void
test_validate_action_vendor() {
  buffer *body = create_dummy_data( SHORT_DATA_LENGTH );
  openflow_actions *actions = create_actions();
  append_action_vendor( actions, VENDOR_ID, body );
  struct ofp_action_vendor_header action_vendor_header;
  hton_action_vendor( &action_vendor_header, ( struct ofp_action_vendor_header * ) ( actions->list->data ) );

  assert_int_equal( validate_action_vendor( &action_vendor_header ), 0 );

  free_buffer( body );
  delete_actions( actions );
}


static void
test_validate_action_vendor_fails_with_invalid_action_type() {
  uint16_t port = 1;
  uint32_t queue_id = 10;

  openflow_actions *actions = create_actions();
  append_action_enqueue( actions, port, queue_id );
  struct ofp_action_enqueue action_enqueue;
  hton_action_enqueue( &action_enqueue, ( struct ofp_action_enqueue * ) ( actions->list->data ) );

  assert_int_equal( validate_action_vendor( ( struct ofp_action_vendor_header * ) &action_enqueue ), ERROR_INVALID_ACTION_TYPE );

  delete_actions( actions );
}


static void
test_validate_action_vendor_fails_with_too_short_ofp_action_vendor_header() {
  buffer *body = create_dummy_data( SHORT_DATA_LENGTH );
  openflow_actions *actions = create_actions();
  append_action_vendor( actions, VENDOR_ID, body );
  uint16_t too_short_action_length = sizeof( struct ofp_action_vendor_header ) - 1;
  ( ( struct ofp_action_vendor_header * )( actions->list->data ) )->len = too_short_action_length;
  struct ofp_action_vendor_header too_short_action_vendor_header;
  hton_action_vendor( &too_short_action_vendor_header, ( struct ofp_action_vendor_header * ) ( actions->list->data ) );

  assert_int_equal( validate_action_vendor( &too_short_action_vendor_header ), ERROR_TOO_SHORT_ACTION_VENDOR );

  free_buffer( body );
  delete_actions( ( openflow_actions * ) actions );
}


/********************************************************************************
 * validate_openflow_message() tests.
 ********************************************************************************/

static void
test_validate_openflow_message_succeeds_with_valid_OFPT_HELLO_message() {
  buffer *hello = create_hello( MY_TRANSACTION_ID );

  assert_int_equal( validate_openflow_message( hello ), 0 );

  free_buffer( hello );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_ERROR_message() {
  buffer *dummy_data = create_dummy_data( SHORT_DATA_LENGTH );
  buffer *error = create_error( MY_TRANSACTION_ID, OFPET_HELLO_FAILED, OFPHFC_INCOMPATIBLE, dummy_data );

  assert_int_equal( validate_openflow_message( error ), 0 );

  free_buffer( dummy_data );
  free_buffer( error );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_ECHO_REQUEST_message() {
  buffer *dummy_data = create_dummy_data( SHORT_DATA_LENGTH );
  buffer *echo_request = create_echo_request( MY_TRANSACTION_ID, dummy_data );

  assert_int_equal( validate_openflow_message( echo_request ), 0 );

  free_buffer( dummy_data );
  free_buffer( echo_request );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_ECHO_REPLY_message() {
  buffer *dummy_data = create_dummy_data( SHORT_DATA_LENGTH );
  buffer *echo_reply = create_echo_reply( MY_TRANSACTION_ID, dummy_data );

  assert_int_equal( validate_openflow_message( echo_reply ), 0 );

  free_buffer( dummy_data );
  free_buffer( echo_reply );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_VENDOR_message() {
  buffer *dummy_data = create_dummy_data( 32 );
  buffer *vendor = create_vendor( MY_TRANSACTION_ID, VENDOR_ID, dummy_data );

  assert_int_equal( validate_openflow_message( vendor ), 0 );

  free_buffer( dummy_data );
  free_buffer( vendor );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_FEATURES_REQUEST_message() {
  buffer *features_request = create_features_request( MY_TRANSACTION_ID );

  assert_int_equal( validate_openflow_message( features_request ), 0 );

  free_buffer( features_request );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_FEATURES_REPLY_message() {
  uint64_t datapath_id = 0x12345600;
  uint32_t n_buffers = 128;
  uint8_t n_tables = 1;
  struct ofp_phy_port phy_port[ 2 ];
  list_element *ports;

  uint32_t capabilities = ( OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS | OFPC_QUEUE_STATS | OFPC_ARP_MATCH_IP );
  uint32_t actions = ( ( 1 << OFPAT_OUTPUT ) | ( 1 << OFPAT_SET_VLAN_VID ) | ( 1 << OFPAT_SET_TP_SRC ) | ( 1 << OFPAT_SET_TP_DST ) );
  phy_port[ 0 ].port_no = 1;
  memcpy( phy_port[ 0 ].hw_addr, HW_ADDR, sizeof( phy_port[ 0 ].hw_addr ) );
  strcpy( phy_port[ 0 ].name, "Brown" );
  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;
  create_list( &ports );
  append_to_tail( &ports, &phy_port[ 0 ] );
  phy_port[ 1 ].port_no = 2;
  memcpy( phy_port[ 1 ].hw_addr, HW_ADDR, sizeof( phy_port[ 1 ].hw_addr ) );
  strcpy( phy_port[ 1 ].name, "Amber" );
  phy_port[ 1 ].config = OFPPC_PORT_DOWN;
  phy_port[ 1 ].state = OFPPS_LINK_DOWN;
  phy_port[ 1 ].curr = OFPPF_1GB_FD | OFPPF_COPPER | OFPPF_PAUSE;
  phy_port[ 1 ].advertised = PORT_FEATURES;
  phy_port[ 1 ].supported = PORT_FEATURES;
  phy_port[ 1 ].peer = PORT_FEATURES;
  append_to_tail( &ports, &phy_port[ 1 ] );
  buffer *features_reply = create_features_reply( MY_TRANSACTION_ID, datapath_id, n_buffers, n_tables, capabilities, actions, ports );

  assert_int_equal( validate_openflow_message( features_reply ), 0 );

  delete_list( ports );
  free_buffer( features_reply );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_GET_CONFIG_REQUEST_message() {
  buffer *get_config_request = create_get_config_request( MY_TRANSACTION_ID );

  assert_int_equal( validate_openflow_message( get_config_request ), 0 );

  free_buffer( get_config_request );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_GET_CONFIG_REPLY_message() {
  buffer *get_config_reply = create_get_config_reply( MY_TRANSACTION_ID, OFPC_FRAG_NORMAL, OFP_DEFAULT_MISS_SEND_LEN );

  assert_int_equal( validate_openflow_message( get_config_reply ), 0 );

  free_buffer( get_config_reply );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_SET_CONFIG_message() {
  buffer *set_config = create_set_config( MY_TRANSACTION_ID, OFPC_FRAG_NORMAL, OFP_DEFAULT_MISS_SEND_LEN );

  assert_int_equal( validate_openflow_message( set_config ), 0 );

  free_buffer( set_config );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_PACKET_IN_message() {
  uint32_t buffer_id = 0x01020304;
  uint16_t in_port = 1;

  buffer *dummy_data = create_dummy_data( LONG_DATA_LENGTH );
  uint16_t total_len = ( uint16_t ) dummy_data->length;
  buffer *packet_in = create_packet_in( MY_TRANSACTION_ID, buffer_id, total_len, in_port, OFPR_NO_MATCH, dummy_data );

  assert_int_equal( validate_openflow_message( packet_in ), 0 );

  free_buffer( dummy_data );
  free_buffer( packet_in );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_FLOW_REMOVED_message() {
  uint64_t cookie = 0x0102030405060708ULL;
  uint16_t priority = 65535;
  uint32_t duration_sec = 180;
  uint32_t duration_nsec = 10000;
  uint16_t idle_timeout = 60;
  uint64_t packet_count = 1000;
  uint64_t byte_count = 100000;

  buffer *flow_removed = create_flow_removed( MY_TRANSACTION_ID, MATCH, cookie, priority, OFPRR_IDLE_TIMEOUT, duration_sec,
                                              duration_nsec, idle_timeout, packet_count, byte_count );

  assert_int_equal( validate_openflow_message( flow_removed ), 0 );

  free_buffer( flow_removed );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_PORT_STATUS_message() {
  struct ofp_phy_port desc;

  desc.port_no = 1;
  memcpy( desc.hw_addr, HW_ADDR, sizeof( desc.hw_addr ) );
  memset( desc.name, '\0', OFP_MAX_PORT_NAME_LEN );
  strcpy( desc.name, "Navy" );
  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 *port_status = create_port_status( MY_TRANSACTION_ID, OFPPR_ADD, desc );

  assert_int_equal( validate_openflow_message( port_status ), 0 );

  free_buffer( port_status );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_PACKET_OUT_message() {
  openflow_actions *actions = create_actions();
  append_action_output( actions, 1, 128 );
  buffer *dummy_data = create_dummy_data( LONG_DATA_LENGTH );
  buffer *packet_out = create_packet_out( MY_TRANSACTION_ID, BUFFER_ID, 1, actions, dummy_data );

  assert_int_equal( validate_openflow_message( packet_out ), 0 );

  free_buffer( dummy_data );
  free_buffer( packet_out );
  delete_actions( actions );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_FLOW_MOD_message() {
  uint64_t cookie = 10;
  uint16_t hard_timeout = 10;
  uint16_t idle_timeout = 5;
  uint16_t out_port = UINT16_MAX;

  openflow_actions *actions = create_actions();
  append_action_output( actions, 1, 128 );
  buffer *flow_mod = create_flow_mod( MY_TRANSACTION_ID, MATCH, cookie, OFPFC_ADD, idle_timeout, hard_timeout, PRIORITY,
                                      BUFFER_ID, out_port, OFPFF_CHECK_OVERLAP | OFPFF_SEND_FLOW_REM, actions );

  assert_int_equal( validate_openflow_message( flow_mod ), 0 );

  free_buffer( flow_mod );
  delete_actions( actions );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_PORT_MOD_message() {
  uint16_t port_no = 1;
  uint32_t mask = 0;
  uint32_t advertise = 1;

  buffer *port_mod = create_port_mod( MY_TRANSACTION_ID, port_no, HW_ADDR, OFPPC_PORT_DOWN, mask, advertise );

  assert_int_equal( validate_openflow_message( port_mod ), 0 );

  free_buffer( port_mod );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_STATS_REQUEST_message() {
  buffer *stats_desc_request = create_desc_stats_request( MY_TRANSACTION_ID, 0 );

  assert_int_equal( validate_openflow_message( stats_desc_request ), 0 );

  free_buffer( stats_desc_request );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_STATS_REPLY_message() {
  const char mfr_desc[ DESC_STR_LEN ] = "NEC Corporation";
  const char hw_desc[ DESC_STR_LEN ] = "OpenFlow Switch Hardware";
  const char sw_desc[ DESC_STR_LEN ] = "OpenFlow Switch Software";
  const char serial_num[ SERIAL_NUM_LEN ] = "1234";
  const char dp_desc[ DESC_STR_LEN ] = "Datapath 0";

  buffer *stats_desc_reply = create_desc_stats_reply( MY_TRANSACTION_ID, NO_FLAGS, mfr_desc, hw_desc, sw_desc, serial_num, dp_desc );

  assert_int_equal( validate_openflow_message( stats_desc_reply ), 0 );

  free_buffer( stats_desc_reply );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_BARRIER_REQUEST_message() {
  buffer *barrier_request = create_barrier_request( MY_TRANSACTION_ID );

  assert_int_equal( validate_openflow_message( barrier_request ), 0 );

  free_buffer( barrier_request );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_BARRIER_REPLY_message() {
  buffer *barrier_reply = create_barrier_reply( MY_TRANSACTION_ID );

  assert_int_equal( validate_openflow_message( barrier_reply ), 0 );

  free_buffer( barrier_reply );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_QUEUE_GET_CONFIG_REQUEST_message() {
  uint16_t port = 1;

  buffer *queue_get_config_request = create_queue_get_config_request( MY_TRANSACTION_ID, port );

  assert_int_equal( validate_openflow_message( queue_get_config_request ), 0 );

  free_buffer( queue_get_config_request );
}


static void
test_validate_openflow_message_succeeds_with_valid_OFPT_QUEUE_GET_CONFIG_REPLY_message() {
  size_t queue_len;
  uint16_t port = 1;
  list_element *list;
  struct ofp_packet_queue *queue[ 2 ];

  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;
  struct ofp_queue_prop_header *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( &list );
  append_to_tail( &list, queue[ 0 ] );
  append_to_tail( &list, queue[ 1 ] );
  buffer *queue_get_config_reply = create_queue_get_config_reply( MY_TRANSACTION_ID, port, list );

  assert_int_equal( validate_openflow_message( queue_get_config_reply ), 0 );

  xfree( queue[ 0 ] );
  xfree( queue[ 1 ] );
  delete_list( list );
  free_buffer( queue_get_config_reply );
}


static void
test_validate_openflow_message_fails_with_undefined_type_message() {
  uint8_t dummy_type = UINT8_MAX;

  buffer *undefined_type = create_dummy_data( sizeof( struct ofp_stats_request ) );
  struct ofp_stats_request *stats_request = ( struct ofp_stats_request * ) undefined_type->data;
  stats_request->header.type = dummy_type;

  assert_int_equal( validate_openflow_message( undefined_type ), ERROR_UNDEFINED_TYPE );

  free_buffer( undefined_type );
}


static void
test_validate_openflow_message_fails_if_message_is_NULL() {
  expect_assert_failure( validate_openflow_message( NULL ) );
}


static void
test_validate_openflow_message_fails_if_data_is_NULL() {
  buffer *buf = alloc_buffer( );

  expect_assert_failure( validate_openflow_message( buf ) );

  free_buffer( buf );
}


/********************************************************************************
 * valid_openflow_message() tests.
 ********************************************************************************/

static void
test_valid_openflow_message() {
  buffer *hello = create_hello( MY_TRANSACTION_ID );

  assert_int_equal( valid_openflow_message( hello ), true );

  free_buffer( hello );
}


static void
test_valid_openflow_message_fails_with_undefined_type_message() {
  uint8_t dummy_type = UINT8_MAX;

  buffer *undefined_type = create_dummy_data( sizeof( struct ofp_stats_request ) );
  struct ofp_stats_request *stats_request = ( struct ofp_stats_request * ) undefined_type->data;
  stats_request->header.type = dummy_type;

  assert_int_equal( valid_openflow_message( undefined_type ), false );

  free_buffer( undefined_type );
}


/********************************************************************************
 * get_error_type_and_code() tests.
 ********************************************************************************/

static void
test_get_error_type_and_code_succeeds_with_OFPT_ECHO_REQUEST_and_ERROR_UNSUPPORTED_VERSION() {
  uint16_t error_type = 0;
  uint16_t error_code = 0;

  assert_int_equal( get_error_type_and_code( OFPT_ECHO_REQUEST, ERROR_UNSUPPORTED_VERSION, &error_type, &error_code ), true );

  assert_int_equal( error_type, OFPET_BAD_REQUEST );
  assert_int_equal( error_code, OFPBRC_BAD_VERSION );
}


static void
test_get_error_type_and_code_succeeds_with_invalid_type_and_ERROR_UNSUPPORTED_VERSION() {
  uint16_t error_type = 0;
  uint16_t error_code = 0;
  uint8_t dummy_type = 56;

  assert_int_equal( get_error_type_and_code( dummy_type, ERROR_UNSUPPORTED_VERSION, &error_type, &error_code ), true );

  assert_int_equal( error_type, OFPET_BAD_REQUEST );
  assert_int_equal( error_code, OFPBRC_BAD_TYPE );
}


static void
test_get_error_type_and_code_fails_with_OFPT_ECHO_REQUEST_and_ERROR_TOO_SHORT_ACTION_NW_SRC() {
  uint16_t error_type = 0;
  uint16_t error_code = 0;

  assert_int_equal( get_error_type_and_code( OFPT_ECHO_REQUEST, ERROR_TOO_SHORT_ACTION_NW_SRC, &error_type, &error_code ), false );
}


/********************************************************************************
 * set_match_from_packet() tests.
 ********************************************************************************/

const char macda[] = {
    ( char ) 0xff, ( char ) 0xff, ( char ) 0xff, ( char ) 0xff, ( char ) 0xff, ( char ) 0xff
};
const char macsa[] = {
    ( char ) 0x00, ( char ) 0xd0, ( char ) 0x09, ( char ) 0x20, ( char ) 0x09, ( char ) 0xF7
};
const char snap_data[] = {
    ( char ) 0xaa, ( char ) 0xaa, ( char ) 0x03, ( char ) 0x00, ( char ) 0x00, ( char ) 0x00, ( char ) 0x08, ( char ) 0x00
};

const uint16_t src_port = 1024;
const uint16_t dst_port = 2048;
const size_t ipv4_length = sizeof( ether_header_t ) + sizeof( ipv4_header_t );


static buffer *
setup_ether_packet( size_t length, uint16_t type ) {
  size_t l2_length = sizeof( ether_header_t );
  if ( type == ETH_ETHTYPE_TPID ) {
    length += sizeof( vlantag_header_t );
    l2_length += sizeof( vlantag_header_t );
  }

  /* Create the packet for test. */
  buffer *buf = alloc_buffer_with_length( length );
  append_back_buffer( buf, length );

  ether_header_t *ether = buf->data;
  ether->type = htons( type );
  memcpy( ( char * ) ether->macda, macda, ETH_ADDRLEN );
  memcpy( ( char * ) ether->macsa, macsa, ETH_ADDRLEN );

  vlantag_header_t *vtag = ( vlantag_header_t * ) ( ether + 1 );
  if ( type == ETH_ETHTYPE_TPID ) {
    vtag->tci = htons( 20483 ); // prio(3bit):010,cfi(1bit):1,vid(12bit):000000000011
  }

  /* Create the pakcet_info data for verification. */
  if ( buf->user_data == NULL ) {
    calloc_packet_info( buf );
  }
  packet_info *packet_info0 = buf->user_data;
  memcpy( packet_info0->eth_macda, macda, ETH_ADDRLEN );
  memcpy( packet_info0->eth_macsa, macsa, ETH_ADDRLEN );
  packet_info0->eth_type = type;
  packet_info0->vlan_tci = 20483;
  packet_info0->vlan_tpid = type;
  packet_info0->vlan_prio = 2;
  packet_info0->vlan_cfi = 1;
  packet_info0->vlan_vid = 3;
  packet_info0->format |= ETH_DIX;

  packet_info0->l2_header = buf->data;
  if ( type == ETH_ETHTYPE_TPID ) {
    packet_info0->l3_header = ( void * ) ( vtag + 1 );
    packet_info0->format |= ETH_8021Q;
  } 
  else { 
    packet_info0->l3_header = ( void * ) ( ether + 1 );
  }

  return buf;
}


static buffer *
setup_ipv4_packet( size_t length, uint16_t type ) {
  buffer *buf = setup_ether_packet( length, type );
  packet_info *packet_info0 = buf->user_data;

  /* Fill arp values into the test packet. */
  if ( type == ETH_ETHTYPE_TPID ) {
    ether_header_t *ether = packet_info0->l2_header;
    vlantag_header_t *vtag = ( vlantag_header_t * ) ( ether + 1 );
    vtag->type = htons( ETH_ETHTYPE_IPV4 );
  }

  ipv4_header_t *ipv4 = packet_info0->l3_header;
  ipv4->version = IPVERSION;
  ipv4->ihl = sizeof( ipv4_header_t ) / 4;
  ipv4->tos = 0;
  ipv4->tot_len = htons( sizeof( ipv4_header_t ) );
  ipv4->ttl = 0;
  ipv4->check = 0;
  ipv4->saddr = htonl( 0xC0A80067 );
  ipv4->daddr = htonl( 0xC0A80036 );
  ipv4->frag_off = htons( 0 );
  packet_info0->l4_header = ( void * ) ( ipv4 + 1 );

  switch ( type ) {
  case IPPROTO_ICMP:
    ipv4->protocol = ( uint8_t ) IPPROTO_ICMP;    
    icmp_header_t *icmpv4 = packet_info0->l4_header;
    icmpv4->type = ICMP_TYPE_UNREACH;
    icmpv4->code = ICMP_CODE_PORTUNREACH;
    break;

  case IPPROTO_UDP:
    ipv4->protocol = ( uint8_t ) IPPROTO_UDP;
    udp_header_t *udp = packet_info0->l4_header;
    udp->src_port = ntohs( src_port );
    udp->dst_port = ntohs( dst_port );
    break;
 
  case IPPROTO_TCP:
    ipv4->protocol = ( uint8_t ) IPPROTO_TCP;
    tcp_header_t *tcp = packet_info0->l4_header;
    tcp->src_port = ntohs( src_port );
    tcp->dst_port = ntohs( dst_port );
    break;

  default:
    break;
  }

  /* Fill ipv4/icmp/udp values into the packet_info data for verification. */
  packet_info0->eth_type = ETH_ETHTYPE_IPV4;
  packet_info0->ipv4_version = IPVERSION;
  packet_info0->ipv4_ihl = sizeof( ipv4_header_t ) / 4;
  packet_info0->ipv4_tos = 0;
  packet_info0->ipv4_tot_len = sizeof( ipv4_header_t );
  packet_info0->ipv4_ttl = 0;
  packet_info0->ipv4_checksum = 0;
  packet_info0->ipv4_saddr = 0xC0A80067;
  packet_info0->ipv4_daddr = 0xC0A80036;
  packet_info0->ipv4_frag_off = 0;
  packet_info0->ipv4_protocol = ( uint8_t ) type;
  packet_info0->format |= NW_IPV4;

  switch ( type ) {
  case IPPROTO_ICMP:
    packet_info0->icmpv4_type = ICMP_TYPE_UNREACH;
    packet_info0->icmpv4_code = ICMP_CODE_PORTUNREACH;
    packet_info0->format |= NW_ICMPV4;
    break;

  case IPPROTO_UDP:
    packet_info0->udp_src_port = src_port;
    packet_info0->udp_dst_port = dst_port;
    packet_info0->format |= TP_UDP;
    break;

  case IPPROTO_TCP:
    packet_info0->tcp_src_port = src_port;
    packet_info0->tcp_dst_port = dst_port;
    packet_info0->format |= TP_TCP;
    break;

  default:
    break;
  }
  
  return buf;
}


static buffer *
setup_arp_packet( uint16_t type ) {
  buffer *buf = setup_ether_packet( sizeof( ether_header_t ) + sizeof( arp_header_t ), type );
  packet_info *packet_info0 = buf->user_data;
  
  /* Fill arp values into the test packet. */
  if ( type == ETH_ETHTYPE_TPID ) {
    ether_header_t *ether = packet_info0->l2_header;
    vlantag_header_t *vtag = ( vlantag_header_t * ) ( ether + 1 );
    vtag->type = htons( ETH_ETHTYPE_ARP );
  }
  arp_header_t *arp = packet_info0->l3_header;
  arp->ar_hrd = htons( ARPHRD_ETHER );
  arp->ar_pro = htons( ETH_ETHTYPE_IPV4 );
  arp->ar_hln = ETH_ADDRLEN;
  arp->ar_pln = IPV4_ADDRLEN;
  arp->ar_op = htons( ARPOP_REPLY );
  arp->sha[ 0 ] = 0x00;
  arp->sha[ 1 ] = 0x01;
  arp->sha[ 2 ] = 0x02;
  arp->sha[ 3 ] = 0x03;
  arp->sha[ 4 ] = 0x04;
  arp->sha[ 5 ] = 0x05;
  arp->sip = htonl( 0x01020304 );
  arp->tha[ 0 ] = 0x06;
  arp->tha[ 1 ] = 0x07;
  arp->tha[ 2 ] = 0x08;
  arp->tha[ 3 ] = 0x09;
  arp->tha[ 4 ] = 0x0a;
  arp->tha[ 5 ] = 0x0b;
  arp->tip = htonl( 0x05060708 );

  /* Fill arp values into the packet_info data for verification. */
  packet_info0->eth_type = ETH_ETHTYPE_ARP;
  packet_info0->arp_ar_hrd = ARPHRD_ETHER;
  packet_info0->arp_ar_pro = ETH_ETHTYPE_IPV4;
  packet_info0->arp_ar_hln = ETH_ADDRLEN;
  packet_info0->arp_ar_pln = IPV4_ADDRLEN;
  packet_info0->arp_ar_op = ARPOP_REPLY;
  packet_info0->arp_sha[ 0 ] = 0x00;
  packet_info0->arp_sha[ 1 ] = 0x01;
  packet_info0->arp_sha[ 2 ] = 0x02;
  packet_info0->arp_sha[ 3 ] = 0x03;
  packet_info0->arp_sha[ 4 ] = 0x04;
  packet_info0->arp_sha[ 5 ] = 0x05;
  packet_info0->arp_spa = 0x01020304;
  packet_info0->arp_tha[ 0 ] = 0x06;
  packet_info0->arp_tha[ 1 ] = 0x07;
  packet_info0->arp_tha[ 2 ] = 0x08;
  packet_info0->arp_tha[ 3 ] = 0x09;
  packet_info0->arp_tha[ 4 ] = 0x0a;
  packet_info0->arp_tha[ 5 ] = 0x0b;
  packet_info0->arp_tpa = 0x05060708;
  packet_info0->format |= NW_ARP;

  return buf;
}


static buffer *
setup_snap_packet( uint16_t type ) {
  buffer *buf = setup_ether_packet( sizeof( ether_header_t ) + sizeof( snap_header_t ), type );
  packet_info *packet_info0 = buf->user_data;

  size_t length = sizeof( ether_header_t ) + sizeof( snap_header_t );
  ether_header_t *ether = packet_info0->l2_header;
  if ( type == ETH_ETHTYPE_TPID ) {
    length += sizeof( vlantag_header_t );
    vlantag_header_t *vtag = ( void * ) ( ether + 1 );
    vtag->type = htons( ( uint16_t ) length );
  }  
  else {
    ether->type = htons( ( uint16_t ) length );
  }

  snap_header_t *snap = ( snap_header_t * ) packet_info0->l3_header;
  memcpy( ( char * ) snap, snap_data, sizeof( snap_header_t ) );

  return buf;
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_tag_and_wildcards_is_zero() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_TPID );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, packet_info0->vlan_vid );
  assert_int_equal( match.dl_vlan_pcp, packet_info0->vlan_prio );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, ntohs( arp->ar_op ) & ARP_OP_MASK );
  assert_int_equal( ( int ) match.nw_src, ( int ) ntohl( arp->sip ) );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ntohl( arp->tip ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_zero() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, ntohs( arp->ar_op ) & ARP_OP_MASK );
  assert_int_equal( ( int ) match.nw_src, ( int ) ntohl( arp->sip ) );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ntohl( arp->tip ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_IN_PORT() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_IN_PORT, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, OFPFW_IN_PORT );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, ntohs( arp->ar_op ) & ARP_OP_MASK );
  assert_int_equal( ( int ) match.nw_src, ( int ) ntohl( arp->sip ) );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ntohl( arp->tip ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_DL_VLAN() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_VLAN, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, OFPFW_DL_VLAN );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, ntohs( arp->ar_op ) & ARP_OP_MASK );
  assert_int_equal( ( int ) match.nw_src, ( int ) ntohl( arp->sip ) );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ntohl( arp->tip ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_DL_SRC() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_SRC, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, OFPFW_DL_SRC );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, ntohs( arp->ar_op ) & ARP_OP_MASK );
  assert_int_equal( ( int ) match.nw_src, ( int ) ntohl( arp->sip ) );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ntohl( arp->tip ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_DL_DST() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_DST, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, OFPFW_DL_DST );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, ntohs( arp->ar_op ) & ARP_OP_MASK );
  assert_int_equal( ( int ) match.nw_src, ( int ) ntohl( arp->sip ) );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ntohl( arp->tip ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_DL_TYPE() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_TYPE, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  assert_int_equal( ( int ) match.wildcards, OFPFW_DL_TYPE );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_NW_PROTO() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_PROTO, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, OFPFW_NW_PROTO );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( ( int ) match.nw_src, ( int ) ntohl( arp->sip ) );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ntohl( arp->tip ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_TP_SRC() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_TP_SRC, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, OFPFW_TP_SRC );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, ntohs( arp->ar_op ) & ARP_OP_MASK );
  assert_int_equal( ( int ) match.nw_src, ( int ) ntohl( arp->sip ) );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ntohl( arp->tip ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_TP_DST() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_TP_DST, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, OFPFW_TP_DST );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, ntohs( arp->ar_op ) & ARP_OP_MASK );
  assert_int_equal( ( int ) match.nw_src, ( int ) ntohl( arp->sip ) );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ntohl( arp->tip ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_NW_SRC_ALL() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_SRC_ALL, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, OFPFW_NW_SRC_ALL );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, ntohs( arp->ar_op ) & ARP_OP_MASK );
  uint32_t ip_source_address_flag = ntohl( arp->sip ) & ( OFPFW_NW_SRC_ALL >> OFPFW_NW_SRC_SHIFT );
  assert_int_equal( ( int ) match.nw_src, ( int ) ip_source_address_flag );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ntohl( arp->tip ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_NW_DST_ALL() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_DST_ALL, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, OFPFW_NW_DST_ALL );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, ntohs( arp->ar_op ) & ARP_OP_MASK );
  assert_int_equal( ( int ) match.nw_src, ( int ) ntohl( arp->sip ) );
  uint32_t ip_destination_address_flag = ntohl( arp->tip ) & ( OFPFW_NW_DST_ALL >> OFPFW_NW_DST_SHIFT );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ip_destination_address_flag );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_DL_VLAN_PCP() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_VLAN_PCP, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, OFPFW_DL_VLAN_PCP );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, ntohs( arp->ar_op ) & ARP_OP_MASK );
  assert_int_equal( ( int ) match.nw_src, ( int ) ntohl( arp->sip ) );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ntohl( arp->tip ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_NW_TOS() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_TOS, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  arp_header_t *arp = packet_info0->l3_header;
  assert_int_equal( ( int ) match.wildcards, OFPFW_NW_TOS );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, ntohs( arp->ar_op ) & ARP_OP_MASK );
  assert_int_equal( ( int ) match.nw_src, ( int ) ntohl( arp->sip ) );
  assert_int_equal( ( int ) match.nw_dst, ( int ) ntohl( arp->tip ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_ALL() {
  buffer *buf = setup_arp_packet( ETH_ETHTYPE_ARP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_ALL, buf );

  assert_int_equal( ( int ) match.wildcards, OFPFW_ALL );
  assert_int_equal( match.in_port, 0 );
  assert_int_equal( match.dl_vlan, 0 );
  assert_int_equal( match.dl_type, 0 );
  assert_int_equal( match.nw_proto, 0 );
  assert_int_equal( ( int ) match.nw_src, 0 );
  assert_int_equal( ( int ) match.nw_dst, 0 );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_tag_and_wildcards_is_zero() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), ETH_ETHTYPE_TPID );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  assert_int_equal( match.in_port, expected_in_port );
  assert_int_equal( ( int ) match.wildcards, 0 );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, packet_info0->vlan_vid );
  assert_int_equal( match.dl_vlan_pcp, packet_info0->vlan_prio );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_zero() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  udp_header_t *udp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( udp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( udp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_IN_PORT() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_IN_PORT, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  udp_header_t *udp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_IN_PORT );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( udp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( udp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_DL_VLAN() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_VLAN, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  udp_header_t *udp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_DL_VLAN );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( udp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( udp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_DL_SRC() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_SRC, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  udp_header_t *udp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_DL_SRC );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( udp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( udp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_DL_DST() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_DST, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  udp_header_t *udp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_DL_DST );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( udp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( udp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_DL_TYPE() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_TYPE, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  assert_int_equal( match.wildcards, OFPFW_DL_TYPE );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_NW_PROTO() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_PROTO, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  assert_int_equal( match.wildcards, OFPFW_NW_PROTO );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_TP_SRC() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_TP_SRC, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  udp_header_t *udp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_TP_SRC );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_dst, ntohs( udp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_TP_DST() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_TP_DST, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  udp_header_t *udp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_TP_DST );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( udp->src_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_NW_SRC_ALL() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_SRC_ALL, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  udp_header_t *udp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_NW_SRC_ALL );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  uint32_t ip_source_address_flag = ntohl( ipv4->saddr ) & ( OFPFW_NW_SRC_ALL >> OFPFW_NW_SRC_SHIFT );
  assert_int_equal( match.nw_src, ip_source_address_flag );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( udp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( udp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_NW_DST_ALL() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_DST_ALL, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  udp_header_t *udp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_NW_DST_ALL );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  uint32_t ip_destination_address_flag = ntohl( ipv4->daddr ) & ( OFPFW_NW_DST_ALL >> OFPFW_NW_DST_SHIFT );
  assert_int_equal( match.nw_dst, ip_destination_address_flag );
  assert_int_equal( match.tp_src, ntohs( udp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( udp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_DL_VLAN_PCP() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_VLAN_PCP, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  udp_header_t *udp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_DL_VLAN_PCP );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( udp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( udp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_NW_TOS() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_TOS, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  udp_header_t *udp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_NW_TOS );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( udp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( udp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_ALL() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( udp_header_t ), IPPROTO_UDP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_ALL, buf );

  assert_int_equal( match.wildcards, OFPFW_ALL );
  assert_int_equal( match.in_port, 0 );
  assert_int_equal( match.dl_type, 0 );
  assert_int_equal( match.nw_tos, 0 );
  assert_int_equal( match.nw_proto, 0 );
  assert_int_equal( match.nw_src, 0 );
  assert_int_equal( match.nw_dst, 0 );
  assert_int_equal( match.tp_src, 0 );
  assert_int_equal( match.tp_dst, 0 );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_tag_and_wildcards_is_zero() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), ETH_ETHTYPE_TPID );
  packet_info *packet_info0 = buf->user_data;

  /* Add a tcp data into the test packet */
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  ipv4->protocol = IPPROTO_TCP;
  tcp_header_t *tcp = packet_info0->l4_header;
  tcp->src_port = ntohs( src_port );
  tcp->dst_port = ntohs( dst_port );

  /* Add the tcp data into the packet_info data for verification. */
  packet_info0->ipv4_protocol = IPPROTO_TCP;
  packet_info0->tcp_src_port = src_port;
  packet_info0->tcp_dst_port = dst_port;
  packet_info0->format |= TP_TCP;
  
  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  ether_header_t *ether = packet_info0->l2_header;
  assert_int_equal( match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, packet_info0->vlan_vid );
  assert_int_equal( match.dl_vlan_pcp, packet_info0->vlan_prio );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_zero() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  tcp_header_t *tcp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( tcp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( tcp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_IN_PORT() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_IN_PORT, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  tcp_header_t *tcp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_IN_PORT );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( tcp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( tcp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_DL_VLAN() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_VLAN, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  tcp_header_t *tcp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_DL_VLAN );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( tcp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( tcp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_DL_SRC() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_SRC, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  tcp_header_t *tcp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_DL_SRC );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( tcp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( tcp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_DL_DST() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_DST, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  tcp_header_t *tcp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_DL_DST );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( tcp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( tcp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_DL_TYPE() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_TYPE, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  assert_int_equal( match.wildcards, OFPFW_DL_TYPE );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_NW_PROTO() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_PROTO, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  assert_int_equal( match.wildcards, OFPFW_NW_PROTO );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_TP_SRC() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_TP_SRC, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  tcp_header_t *tcp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_TP_SRC );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_dst, ntohs( tcp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_TP_DST() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_TP_DST, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  tcp_header_t *tcp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_TP_DST );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( tcp->src_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_NW_SRC_ALL() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_SRC_ALL, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  tcp_header_t *tcp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_NW_SRC_ALL );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  uint32_t ip_source_address_flag = ntohl( ipv4->saddr ) & ( OFPFW_NW_SRC_ALL >> OFPFW_NW_SRC_SHIFT );
  assert_int_equal( match.nw_src, ip_source_address_flag );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( tcp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( tcp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_NW_DST_ALL() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_DST_ALL, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  tcp_header_t *tcp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_NW_DST_ALL );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  uint32_t ip_destination_address_flag = ntohl( ipv4->daddr ) & ( OFPFW_NW_DST_ALL >> OFPFW_NW_DST_SHIFT );
  assert_int_equal( match.nw_dst, ip_destination_address_flag );
  assert_int_equal( match.tp_src, ntohs( tcp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( tcp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_DL_VLAN_PCP() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_VLAN_PCP, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  tcp_header_t *tcp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_DL_VLAN_PCP );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( tcp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( tcp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_NW_TOS() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_TOS, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  tcp_header_t *tcp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_NW_TOS );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.tp_src, ntohs( tcp->src_port ) );
  assert_int_equal( match.tp_dst, ntohs( tcp->dst_port ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_ALL() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( tcp_header_t ), IPPROTO_TCP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_ALL, buf );

  assert_int_equal( match.wildcards, OFPFW_ALL );
  assert_int_equal( match.in_port, 0 );
  assert_int_equal( match.dl_type, 0 );
  assert_int_equal( match.nw_tos, 0 );
  assert_int_equal( match.nw_proto, 0 );
  assert_int_equal( match.nw_src, 0 );
  assert_int_equal( match.nw_dst, 0 );
  assert_int_equal( match.tp_src, 0 );
  assert_int_equal( match.tp_dst, 0 );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_tag_and_wildcards_is_zero() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), ETH_ETHTYPE_TPID );
  packet_info *packet_info0 = buf->user_data;

  /* Add a icmp data into the test packet. */
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  ipv4->protocol = IPPROTO_ICMP;
  icmp_header_t *icmpv4 = packet_info0->l4_header;    
  icmpv4->type = ICMP_TYPE_UNREACH;
  icmpv4->code = ICMP_CODE_PORTUNREACH;
  /* Add the icmp data into the packet_info data for verification. */
  packet_info0->ipv4_protocol = IPPROTO_ICMP;
  packet_info0->icmpv4_type = ICMP_TYPE_UNREACH;
  packet_info0->icmpv4_code = ICMP_CODE_PORTUNREACH;
  packet_info0->format |= NW_ICMPV4;

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  ether_header_t *ether = packet_info0->l2_header;
  assert_int_equal( match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, packet_info0->vlan_vid );
  assert_int_equal( match.dl_vlan_pcp, packet_info0->vlan_prio );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_zero() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  icmp_header_t *icmp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.icmp_type, icmp->type );
  assert_int_equal( match.icmp_code, icmp->code );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_IN_PORT() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_IN_PORT, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  icmp_header_t *icmp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_IN_PORT );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.icmp_type, icmp->type );
  assert_int_equal( match.icmp_code, icmp->code );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_DL_VLAN() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_VLAN, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  icmp_header_t *icmp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_DL_VLAN );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.icmp_type, icmp->type );
  assert_int_equal( match.icmp_code, icmp->code );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_DL_SRC() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_SRC, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  icmp_header_t *icmp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_DL_SRC );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.icmp_type, icmp->type );
  assert_int_equal( match.icmp_code, icmp->code );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_DL_DST() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_DST, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  icmp_header_t *icmp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_DL_DST );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.icmp_type, icmp->type );
  assert_int_equal( match.icmp_code, icmp->code );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_DL_TYPE() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_TYPE, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  assert_int_equal( match.wildcards, OFPFW_DL_TYPE );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_NW_PROTO() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_PROTO, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  assert_int_equal( match.wildcards, OFPFW_NW_PROTO );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_TP_SRC() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_TP_SRC, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  icmp_header_t *icmp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_TP_SRC );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.icmp_code, icmp->code );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_TP_DST() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_TP_DST, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  icmp_header_t *icmp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_TP_DST );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.icmp_type, icmp->type );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_NW_SRC_ALL() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_SRC_ALL, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  icmp_header_t *icmp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_NW_SRC_ALL );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  uint32_t ip_source_address_flag = ntohl( ipv4->saddr ) & ( OFPFW_NW_SRC_ALL >> OFPFW_NW_SRC_SHIFT );
  assert_int_equal( match.nw_src, ip_source_address_flag );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.icmp_type, icmp->type );
  assert_int_equal( match.icmp_code, icmp->code );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_NW_DST_ALL() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_DST_ALL, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  icmp_header_t *icmp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_NW_DST_ALL );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  uint32_t ip_destination_address_flag = ntohl( ipv4->daddr ) & ( OFPFW_NW_DST_ALL >> OFPFW_NW_DST_SHIFT );
  assert_int_equal( match.nw_dst, ip_destination_address_flag );
  assert_int_equal( match.icmp_type, icmp->type );
  assert_int_equal( match.icmp_code, icmp->code );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_DL_VLAN_PCP() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_DL_VLAN_PCP, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  icmp_header_t *icmp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_DL_VLAN_PCP );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_tos, ipv4->tos );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.icmp_type, icmp->type );
  assert_int_equal( match.icmp_code, icmp->code );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_NW_TOS() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_NW_TOS, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  ipv4_header_t *ipv4 = packet_info0->l3_header;
  icmp_header_t *icmp = packet_info0->l4_header;
  assert_int_equal( match.wildcards, OFPFW_NW_TOS );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );
  assert_int_equal( match.nw_proto, packet_info0->ipv4_protocol );
  assert_int_equal( match.nw_src, ntohl( ipv4->saddr ) );
  assert_int_equal( match.nw_dst, ntohl( ipv4->daddr ) );
  assert_int_equal( match.icmp_type, icmp->type );
  assert_int_equal( match.icmp_code, icmp->code );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_ALL() {
  buffer *buf = setup_ipv4_packet( ipv4_length + sizeof( icmp_header_t ), IPPROTO_ICMP );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, OFPFW_ALL, buf );

  assert_int_equal( match.wildcards, OFPFW_ALL );
  assert_int_equal( match.in_port, 0 );
  assert_int_equal( match.dl_type, 0 );
  assert_int_equal( match.nw_tos, 0 );
  assert_int_equal( match.nw_proto, 0 );
  assert_int_equal( match.nw_src, 0 );
  assert_int_equal( match.nw_dst, 0 );
  assert_int_equal( match.tp_src, 0 );
  assert_int_equal( match.tp_dst, 0 );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_snap_tag_and_wildcards_is_zero() {
  buffer *buf = setup_snap_packet( ETH_ETHTYPE_TPID );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  assert_int_equal( match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, packet_info0->vlan_vid );
  assert_int_equal( match.dl_vlan_pcp, packet_info0->vlan_prio );
  assert_int_equal( match.dl_type, packet_info0->eth_type );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_netbios_tag_and_wildcards_is_zero() {
  buffer *buf = setup_snap_packet( ETH_ETHTYPE_TPID );
  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  vlantag_header_t *vtag = ( vlantag_header_t * ) ( ether + 1 );

  snap_header_t *snap = ( snap_header_t * ) ( vtag + 1 );
  snap->llc[ 0 ] = 0xF0;
  snap->llc[ 1 ] = 0xF0;

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  assert_int_equal( match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, packet_info0->vlan_vid );
  assert_int_equal( match.dl_vlan_pcp, packet_info0->vlan_prio );
  assert_int_equal( match.dl_type, packet_info0->eth_type );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_not_llc_tag_and_wildcards_is_zero() {
  buffer *buf = setup_snap_packet( ETH_ETHTYPE_TPID );
  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  vlantag_header_t *vtag = ( vlantag_header_t * ) ( ether + 1 );

  snap_header_t *snap = ( snap_header_t * ) ( vtag + 1 );
  snap->llc[ 0 ] = 0xFF;
  snap->llc[ 1 ] = 0xFF;

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  assert_int_equal( match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, packet_info0->vlan_vid );
  assert_int_equal( match.dl_vlan_pcp, packet_info0->vlan_prio );
  assert_int_equal( match.dl_type, packet_info0->eth_type );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_snap_and_wildcards_is_zero() {
  buffer *buf = setup_snap_packet( 0 );

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;
  assert_int_equal( match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_netbios_and_wildcards_is_zero() {
  buffer *buf = setup_snap_packet( 0 );
  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;

  snap_header_t *snap = ( snap_header_t * ) ( ether + 1 );
  snap->llc[ 0 ] = 0xF0;
  snap->llc[ 1 ] = 0xF0;

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  assert_int_equal( match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );

  free_buffer( buf );
}


static void
test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_not_llc_and_wildcards_is_zero() {
  buffer *buf = setup_snap_packet( 1 );
  packet_info *packet_info0 = buf->user_data;
  ether_header_t *ether = packet_info0->l2_header;

  snap_header_t *snap = ( snap_header_t * ) ( ether + 1 );
  snap->llc[ 0 ] = 0x00;
  snap->llc[ 1 ] = 0x00;

  uint16_t expected_in_port = 1;
  struct ofp_match match;
  set_match_from_packet( &match, expected_in_port, 0, buf );

  assert_int_equal( match.wildcards, 0 );
  assert_int_equal( match.in_port, expected_in_port );
  assert_memory_equal( match.dl_src, ether->macsa, ETH_ADDRLEN );
  assert_memory_equal( match.dl_dst, ether->macda, ETH_ADDRLEN );
  assert_int_equal( match.dl_vlan, UINT16_MAX );
  assert_int_equal( match.dl_type, packet_info0->eth_type );

  free_buffer( buf );
}


static void
test_set_match_from_packet_fails_if_packet_data_is_NULL() {
  struct ofp_match match;
  expect_assert_failure( set_match_from_packet( &match, 1, 0, NULL ) );
}


static void
test_set_match_from_packet_fails_if_packet_is_not_parsed_yet() {
  struct ofp_match match;
  buffer *buf = alloc_buffer( );

  expect_assert_failure( set_match_from_packet( &match, 1, 0, buf ) );

  free_buffer( buf );
}


/********************************************************************************
 * Run tests.
 ********************************************************************************/

int
main() {
  const UnitTest tests[] = {
    unit_test( test_init_openflow_message ),

    unit_test_setup_teardown( test_get_transaction_id, init, teardown ),
    unit_test_setup_teardown( test_get_transaction_id_if_id_overflows, init, teardown ),
    unit_test_setup_teardown( test_get_cookie, init, teardown ),
    unit_test_setup_teardown( test_get_cookie_if_cookie_overflows, init, teardown ),

    unit_test_setup_teardown( test_create_hello, init, teardown ),
    unit_test_setup_teardown( test_validate_hello, init, teardown ),
    unit_test_setup_teardown( test_validate_hello_fails_with_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_hello_fails_with_non_hello_message, init, teardown ),

    unit_test_setup_teardown( test_create_error, init, teardown ),
    unit_test_setup_teardown( test_create_error_without_data, init, teardown ),

    unit_test_setup_teardown( test_create_echo_request, init, teardown ),
    unit_test_setup_teardown( test_create_echo_request_without_data, init, teardown ),
    unit_test_setup_teardown( test_validate_echo_request, init, teardown ),
    unit_test_setup_teardown( test_validate_echo_request_fails_with_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_echo_request_fails_with_non_echo_request_message, init, teardown ),

    unit_test_setup_teardown( test_create_echo_reply, init, teardown ),
    unit_test_setup_teardown( test_create_echo_reply_without_data, init, teardown ),
    unit_test_setup_teardown( test_validate_echo_reply, init, teardown ),
    unit_test_setup_teardown( test_validate_echo_reply_fails_with_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_echo_reply_fails_with_non_echo_reply_message, init, teardown ),

    unit_test_setup_teardown( test_create_vendor, init, teardown ),
    unit_test_setup_teardown( test_create_vendor_without_data, init, teardown ),
    unit_test_setup_teardown( test_create_features_request, init, teardown ),
    unit_test_setup_teardown( test_create_get_config_request, init, teardown ),
    unit_test_setup_teardown( test_create_get_config_reply, init, teardown ),
    unit_test_setup_teardown( test_create_set_config, init, teardown ),
    unit_test_setup_teardown( test_create_flow_removed, init, teardown ),
    unit_test_setup_teardown( test_create_port_status, init, teardown ),
    unit_test_setup_teardown( test_create_port_mod, init, teardown ),
    unit_test_setup_teardown( test_create_and_delete_actions, init, teardown ),

    unit_test_setup_teardown( test_append_action_output, init, teardown ),
    unit_test_setup_teardown( test_append_action_set_vlan_vid, init, teardown ),
    unit_test_setup_teardown( test_append_action_set_vlan_pcp, init, teardown ),
    unit_test_setup_teardown( test_append_action_strip_vlan, init, teardown ),
    unit_test_setup_teardown( test_append_action_set_dl_src, init, teardown ),
    unit_test_setup_teardown( test_append_action_set_dl_dst, init, teardown ),
    unit_test_setup_teardown( test_append_action_set_nw_src, init, teardown ),
    unit_test_setup_teardown( test_append_action_set_nw_dst, init, teardown ),
    unit_test_setup_teardown( test_append_action_set_nw_tos, init, teardown ),
    unit_test_setup_teardown( test_append_action_set_tp_src, init, teardown ),
    unit_test_setup_teardown( test_append_action_set_tp_dst, init, teardown ),
    unit_test_setup_teardown( test_append_action_enqueue, init, teardown ),
    unit_test_setup_teardown( test_append_action_vendor, init, teardown ),
    unit_test_setup_teardown( test_append_action_vendor_without_data, init, teardown ),

    unit_test_setup_teardown( test_create_packet_out, init, teardown ),
    unit_test_setup_teardown( test_create_packet_out_without_actions, init, teardown ),
    unit_test_setup_teardown( test_create_flow_mod, init, teardown ),
    unit_test_setup_teardown( test_create_flow_stats_request, init, teardown ),
    unit_test_setup_teardown( test_create_flow_stats_reply, init, teardown ),

    unit_test_setup_teardown( test_validate_aggregate_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_aggregate_stats_request_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_aggregate_stats_request_fails_if_message_is_not_aggregate_stats_request, init, teardown ),

    unit_test_setup_teardown( test_create_aggregate_stats_request, init, teardown ),
    unit_test_setup_teardown( test_create_aggregate_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_create_port_stats_request, init, teardown ),
    unit_test_setup_teardown( test_create_port_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_create_queue_stats_request, init, teardown ),
    unit_test_setup_teardown( test_create_queue_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_create_stats_request, init, teardown ),
    unit_test_setup_teardown( test_create_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_create_desc_stats_request, init, teardown ),
    unit_test_setup_teardown( test_create_desc_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_create_table_stats_request, init, teardown ),
    unit_test_setup_teardown( test_create_table_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_create_barrier_request, init, teardown ),
    unit_test_setup_teardown( test_create_barrier_reply, init, teardown ),
    unit_test_setup_teardown( test_create_queue_get_config_request, init, teardown ),
    unit_test_setup_teardown( test_create_queue_get_config_reply, init, teardown ),
    unit_test_setup_teardown( test_create_vendor_stats_request, init, teardown ),
    unit_test_setup_teardown( test_create_vendor_stats_request_without_data, init, teardown ),
    unit_test_setup_teardown( test_create_vendor_stats_reply, init, teardown ),

    unit_test_setup_teardown( test_validate_error, init, teardown ),
    unit_test_setup_teardown( test_validate_vendor, init, teardown ),
    unit_test_setup_teardown( test_validate_vendor_without_data, init, teardown ),
    unit_test_setup_teardown( test_validate_vendor_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_vendor_fails_if_message_is_not_vendor_header, init, teardown ),

    unit_test_setup_teardown( test_validate_features_request, init, teardown ),
    unit_test_setup_teardown( test_validate_features_request_fails_with_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_features_request_fails_with_non_features_request_message, init, teardown ),
    unit_test_setup_teardown( test_validate_features_reply, init, teardown ),
    unit_test_setup_teardown( test_validate_get_config_request, init, teardown ),
    unit_test_setup_teardown( test_validate_get_config_request_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_get_config_request_fails_if_message_is_not_get_config_request, init, teardown ),
    unit_test_setup_teardown( test_validate_get_config_reply, init, teardown ),
    unit_test_setup_teardown( test_validate_set_config, init, teardown ),
    unit_test_setup_teardown( test_validate_set_config_fails_with_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_set_config_fails_with_non_set_config_message, init, teardown ),
    unit_test_setup_teardown( test_validate_packet_in, init, teardown ),
    unit_test_setup_teardown( test_validate_flow_removed, init, teardown ),
    unit_test_setup_teardown( test_validate_port_status, init, teardown ),
    unit_test_setup_teardown( test_validate_packet_out, init, teardown ),
    unit_test_setup_teardown( test_validate_packet_out_without_data, init, teardown ),
    unit_test_setup_teardown( test_validate_packet_out_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_packet_out_fails_if_message_is_not_packet_out, init, teardown ),
    unit_test_setup_teardown( test_validate_flow_mod, init, teardown ),
    unit_test_setup_teardown( test_validate_flow_mod_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_flow_mod_fails_if_message_is_not_flow_mod, init, teardown ),
    unit_test_setup_teardown( test_validate_port_mod, init, teardown ),
    unit_test_setup_teardown( test_validate_port_mod_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_port_mod_fails_if_message_is_not_port_mod, init, teardown ),
    unit_test_setup_teardown( test_validate_desc_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_desc_stats_request_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_desc_stats_request_fails_if_message_is_not_desc_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_desc_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_validate_flow_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_flow_stats_request_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_flow_stats_request_fails_if_message_is_not_flow_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_flow_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_validate_aggregate_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_validate_table_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_table_stats_request_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_table_stats_request_fails_if_message_is_not_table_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_table_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_validate_port_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_port_stats_request_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_port_stats_request_fails_if_message_is_not_port_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_port_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_validate_queue_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_queue_stats_request_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_queue_stats_request_fails_if_message_is_not_queue_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_queue_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_validate_vendor_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_vendor_stats_request_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_vendor_stats_request_fails_if_message_is_not_vendor_stats_request, init, teardown ),
    unit_test_setup_teardown( test_validate_vendor_stats_reply, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_request_sucseed_with_OFPST_DESC_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_request_sucseed_with_OFPST_FLOW_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_request_sucseed_with_OFPST_AGGREGATE_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_request_sucseed_with_OFPST_TABLE_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_request_sucseed_with_OFPST_PORT_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_request_sucseed_with_OFPST_QUEUE_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_request_sucseed_with_OFPST_VENDOR_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_request_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_request_fails_with_unsupported_stats_type, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_reply_with_OFPST_DESC_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_reply_with_OFPST_FLOW_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_reply_with_OFPST_AGGREGATE_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_reply_with_OFPST_TABLE_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_reply_with_OFPST_PORT_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_reply_with_OFPST_QUEUE_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_reply_with_OFPST_VENDOR_message, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_reply_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_stats_reply_fails_with_unsupported_stats_type, init, teardown ),
    unit_test_setup_teardown( test_validate_barrier_reply, init, teardown ),
    unit_test_setup_teardown( test_validate_queue_get_config_reply, init, teardown ),

    unit_test_setup_teardown( test_validate_action_output, init, teardown ),
    unit_test_setup_teardown( test_validate_action_output_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_output_fails_with_too_short_ofp_action_output, init, teardown ),
    unit_test_setup_teardown( test_validate_action_output_fails_with_too_long_ofp_action_output, init, teardown ),
    unit_test_setup_teardown( test_validate_action_output_fails_with_invalid_port_no, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_vlan_vid, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_vlan_vid_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_vlan_vid_fails_with_invalid_vlan_vid, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_vlan_vid_fails_with_too_short_ofp_action_vlan_vid, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_vlan_vid_fails_with_too_long_ofp_action_vlan_vid, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_vlan_pcp, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_vlan_pcp_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_vlan_pcp_fails_with_invalid_vlan_pcp, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_vlan_pcp_fails_with_too_short_ofp_action_vlan_pcp, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_vlan_pcp_fails_with_too_long_ofp_action_vlan_pcp, init, teardown ),
    unit_test_setup_teardown( test_validate_action_strip_vlan, init, teardown ),
    unit_test_setup_teardown( test_validate_action_strip_vlan_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_strip_vlan_fails_with_too_short_ofp_action_header, init, teardown ),
    unit_test_setup_teardown( test_validate_action_strip_vlan_fails_with_too_long_ofp_action_header, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_dl_src, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_dl_src_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_dl_src_fails_with_too_short_ofp_action_dl_addr, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_dl_src_fails_with_too_long_ofp_action_dl_addr, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_dl_dst, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_dl_dst_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_dl_dst_fails_with_too_short_ofp_action_dl_addr, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_dl_dst_fails_with_too_long_ofp_action_dl_addr, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_nw_src, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_nw_src_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_nw_src_fails_with_too_short_ofp_action_nw_addr, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_nw_src_fails_with_too_long_ofp_action_nw_addr, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_nw_dst, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_nw_dst_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_nw_dst_fails_with_too_short_ofp_action_nw_addr, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_nw_dst_fails_with_too_long_ofp_action_nw_addr, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_nw_tos, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_nw_tos_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_nw_tos_fails_with_too_short_ofp_action_nw_tos, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_nw_tos_fails_with_too_long_ofp_action_nw_tos, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_tp_src, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_tp_src_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_tp_src_fails_with_too_short_ofp_action_tp_port, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_tp_src_fails_with_too_long_ofp_action_tp_port, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_tp_dst, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_tp_dst_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_tp_dst_fails_with_too_short_ofp_action_tp_port, init, teardown ),
    unit_test_setup_teardown( test_validate_action_set_tp_dst_fails_with_too_long_ofp_action_tp_port, init, teardown ),
    unit_test_setup_teardown( test_validate_action_enqueue, init, teardown ),
    unit_test_setup_teardown( test_validate_action_enqueue_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_enqueue_fails_with_too_short_ofp_action_enqueue, init, teardown ),
    unit_test_setup_teardown( test_validate_action_enqueue_fails_with_too_long_ofp_action_enqueue, init, teardown ),
    unit_test_setup_teardown( test_validate_action_vendor, init, teardown ),
    unit_test_setup_teardown( test_validate_action_vendor_fails_with_invalid_action_type, init, teardown ),
    unit_test_setup_teardown( test_validate_action_vendor_fails_with_too_short_ofp_action_vendor_header, init, teardown ),

    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_HELLO_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_ERROR_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_ECHO_REQUEST_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_ECHO_REPLY_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_VENDOR_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_FEATURES_REQUEST_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_FEATURES_REPLY_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_GET_CONFIG_REQUEST_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_GET_CONFIG_REPLY_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_SET_CONFIG_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_PACKET_IN_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_FLOW_REMOVED_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_PORT_STATUS_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_PACKET_OUT_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_FLOW_MOD_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_PORT_MOD_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_STATS_REQUEST_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_STATS_REPLY_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_BARRIER_REQUEST_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_BARRIER_REPLY_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_QUEUE_GET_CONFIG_REQUEST_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_succeeds_with_valid_OFPT_QUEUE_GET_CONFIG_REPLY_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_fails_with_undefined_type_message, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_fails_if_message_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_validate_openflow_message_fails_if_data_is_NULL, init, teardown ),

    unit_test_setup_teardown( test_valid_openflow_message, init, teardown ),
    unit_test_setup_teardown( test_valid_openflow_message_fails_with_undefined_type_message, init, teardown ),

    unit_test_setup_teardown( test_get_error_type_and_code_succeeds_with_OFPT_ECHO_REQUEST_and_ERROR_UNSUPPORTED_VERSION, init, teardown ),
    unit_test_setup_teardown( test_get_error_type_and_code_succeeds_with_invalid_type_and_ERROR_UNSUPPORTED_VERSION, init, teardown ),
    unit_test_setup_teardown( test_get_error_type_and_code_fails_with_OFPT_ECHO_REQUEST_and_ERROR_TOO_SHORT_ACTION_NW_SRC, init, teardown ),

    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_tag_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_IN_PORT, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_DL_VLAN, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_DL_SRC, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_DL_DST, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_DL_TYPE, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_NW_PROTO, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_TP_SRC, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_TP_DST, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_NW_SRC_ALL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_NW_DST_ALL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_DL_VLAN_PCP, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_NW_TOS, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_arp_and_wildcards_is_OFPFW_ALL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_tag_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_IN_PORT, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_DL_VLAN, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_DL_SRC, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_DL_DST, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_DL_TYPE, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_NW_PROTO, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_TP_SRC, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_TP_DST, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_NW_SRC_ALL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_NW_DST_ALL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_DL_VLAN_PCP, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_NW_TOS, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_udp_and_wildcards_is_OFPFW_ALL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_tag_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_IN_PORT, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_DL_VLAN, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_DL_SRC, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_DL_DST, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_DL_TYPE, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_NW_PROTO, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_TP_SRC, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_TP_DST, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_NW_SRC_ALL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_NW_DST_ALL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_DL_VLAN_PCP, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_NW_TOS, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_and_wildcards_is_OFPFW_ALL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_tag_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_IN_PORT, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_DL_VLAN, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_DL_SRC, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_DL_DST, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_DL_TYPE, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_NW_PROTO, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_TP_SRC, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_TP_DST, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_NW_SRC_ALL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_NW_DST_ALL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_DL_VLAN_PCP, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_NW_TOS, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_and_wildcards_is_OFPFW_ALL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_snap_tag_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_snap_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_netbios_tag_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_netbios_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_not_llc_tag_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_not_llc_and_wildcards_is_zero, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_fails_if_packet_data_is_NULL, init, teardown ),
    unit_test_setup_teardown( test_set_match_from_packet_fails_if_packet_is_not_parsed_yet, init, teardown ),
  };
  return run_tests( tests );
}


/*
 * Local variables:
 * c-basic-offset: 2
 * indent-tabs-mode: nil
 * End:
 */