trema 0.2.5 → 0.2.6

data/unittests/lib/message_queue_test.c

@@ -265,7 +265,7 @@ test_peek_message_if_queue_is_not_created() {
 
 static int count = 0;
 
-static void
+static bool
 test_foreach_message_queue_helper( buffer *message, void *user_data ) {
   const char *str = message->data;
   assert_string_equal( ( char * ) user_data, "user_data" );
@@ -280,6 +280,8 @@ test_foreach_message_queue_helper( buffer *message, void *user_data ) {
       assert_true( false );
       break;
   }
+
+  return true;
 }
 
 
@@ -323,11 +325,13 @@ test_foreach_message_queue() {
 }
 
 
-static void
+static bool
 test_foreach_message_queue_if_queue_is_empty_helper( buffer *message, void *user_data ) {
   UNUSED( message );
   UNUSED( user_data );
   assert_true( false );
+
+  return true;
 }
 
 

data/unittests/lib/messenger_test.c

@@ -124,8 +124,8 @@ static size_t message_buffer_remain_bytes( message_buffer *buf );
 
 static void delete_timer_callbacks( void );
 
-static messenger_context* insert_context( void *user_data );
-static messenger_context* get_context( uint32_t transaction_id );
+static messenger_context *insert_context( void *user_data );
+static messenger_context *get_context( uint32_t transaction_id );
 static void delete_context( messenger_context *context );
 static void delete_context_db( void );
 static void age_context_db( void * );
@@ -282,9 +282,25 @@ mock_debug( char *format, ... ) {
 }
 
 
+static bool check_warn = false;
+static void
+mock_warn_check( char *format, va_list args ) {
+  char message[ 1000 ];
+  vsnprintf( message, 1000, format, args );
+
+  check_expected( message );
+}
+
+
 void
 mock_warn( char *format, ... ) {
   UNUSED( format );
+  if ( check_warn ) {
+    va_list arg;
+    va_start( arg, format );
+    mock_warn_check( format, arg );
+    va_end( arg );
+  }
 }
 
 
@@ -325,6 +341,8 @@ reset_messenger() {
   finalized = false;
 
   execute_timer_events = mock_execute_timer_events;
+
+  check_warn = false;
 }
 
 
@@ -400,6 +418,138 @@ test_send_then_message_received_callback_is_called() {
 }
 
 
+static void callback_req_hello( const messenger_context_handle *handle, uint16_t tag, void *data, size_t len ) {
+  UNUSED( handle );
+  check_expected( tag );
+  check_expected( data );
+  check_expected( len );
+
+  send_reply_message( handle, 65534, "OLLEH", strlen("OLLEH")+1 );
+}
+
+
+static void callback_req_hello2( const messenger_context_handle *handle, uint16_t tag, void *data, size_t len ) {
+  UNUSED( handle );
+  UNUSED( tag );
+  UNUSED( data );
+  UNUSED( len );
+}
+
+
+static void callback_rep_hello_end( uint16_t tag, void *data, size_t len, void *user_data ) {
+  check_expected( tag );
+  check_expected( data );
+  check_expected( len );
+  check_expected( user_data );
+
+  stop_event_handler();
+  stop_messenger();
+}
+
+
+static void callback_rep_hello2( uint16_t tag, void *data, size_t len, void *user_data ) {
+  UNUSED( tag );
+  UNUSED( data );
+  UNUSED( len );
+  UNUSED( user_data );
+}
+
+
+static void
+test_send_then_message_requested_and_replied_callback_is_called() {
+  init_messenger( "/tmp" );
+
+  const char service_name[] = "Say HELLO";
+
+  expect_value( callback_req_hello, tag, 43556 );
+  expect_string( callback_req_hello, data, "HELLO" );
+  expect_value( callback_req_hello, len, 6 );
+  add_message_requested_callback( service_name, callback_req_hello );
+
+  expect_value( callback_rep_hello_end, tag, 65534 );
+  expect_string( callback_rep_hello_end, data, "OLLEH" );
+  expect_value( callback_rep_hello_end, len, 6 );
+  expect_value( callback_rep_hello_end, user_data, NULL );
+  add_message_replied_callback( service_name, callback_rep_hello_end );
+
+  send_request_message( service_name, service_name,  43556, "HELLO", strlen( "HELLO" ) + 1, NULL );
+
+  start_messenger();
+  start_event_handler();
+
+  delete_message_replied_callback( service_name, callback_rep_hello_end );
+  delete_message_requested_callback( service_name, callback_req_hello );
+  delete_send_queue( lookup_hash_entry( send_queues, service_name ) );
+
+  finalize_messenger();
+}
+
+
+static void
+test_double_add_message_requested_callback_prints_error_message() {
+  init_messenger( "/tmp" );
+
+
+  const char service_name[] = "Some Service";
+  char expected_mes[ 1024+1 ] = {};
+  snprintf( expected_mes, 1024, "Multiple message_requested/replied handler is not supported. ( service_name = %s, message_type = %#x, callback = %p )",
+           service_name, MESSAGE_TYPE_REQUEST, callback_req_hello2 );
+
+
+  check_warn = true;
+
+  assert_true( add_message_requested_callback( service_name, callback_req_hello ) );
+
+  expect_string( mock_warn_check, message, expected_mes );
+  assert_true( add_message_requested_callback( service_name, callback_req_hello2 ) );
+
+  check_warn = false;
+
+  finalize_messenger();
+}
+
+static void
+test_double_add_message_replied_callback_prints_error_message() {
+  init_messenger( "/tmp" );
+
+
+  const char service_name[] = "Some Service";
+  char expected_mes[ 1024+1 ] = {};
+  snprintf( expected_mes, 1024, "Multiple message_requested/replied handler is not supported. ( service_name = %s, message_type = %#x, callback = %p )",
+           service_name, MESSAGE_TYPE_REPLY, callback_rep_hello2 );
+
+
+  check_warn = true;
+
+  assert_true( add_message_replied_callback( service_name, callback_rep_hello_end ) );
+
+  expect_string( mock_warn_check, message, expected_mes );
+  assert_true( add_message_replied_callback( service_name, callback_rep_hello2 ) );
+
+  check_warn = false;
+
+  finalize_messenger();
+}
+
+
+static void
+test_add_1_message_requested_and_replied_callback_each_prints_no_error_message() {
+  init_messenger( "/tmp" );
+
+  const char service_name[] = "Some Service";
+
+  check_warn = true;
+
+  assert_true( add_message_requested_callback( service_name, callback_req_hello ) );
+
+  assert_true( add_message_replied_callback( service_name, callback_rep_hello_end ) );
+
+  check_warn = false;
+
+  finalize_messenger();
+}
+
+
 /********************************************************************************
  * Run tests.
  ********************************************************************************/
@@ -425,6 +575,21 @@ main() {
     unit_test_setup_teardown( test_send_then_message_received_callback_is_called,
                               reset_messenger,
                               reset_messenger ),
+    // Message request callback tests.
+    unit_test_setup_teardown( test_send_then_message_requested_and_replied_callback_is_called,
+                              reset_messenger,
+                              reset_messenger ),
+    // Message request duplicate registrationcallback tests.
+    unit_test_setup_teardown( test_double_add_message_requested_callback_prints_error_message,
+                              reset_messenger,
+                              reset_messenger ),
+    unit_test_setup_teardown( test_double_add_message_replied_callback_prints_error_message,
+                              reset_messenger,
+                              reset_messenger ),
+    unit_test_setup_teardown( test_add_1_message_requested_and_replied_callback_each_prints_no_error_message,
+                              reset_messenger,
+                              reset_messenger ),
+
   };
   return run_tests( tests );
 }

data/unittests/lib/openflow_application_interface_test.c

@@ -41,12 +41,6 @@
  * Helpers.
  ********************************************************************************/
 
-typedef struct {
-  char key[ STAT_KEY_LENGTH ];
-  uint64_t value;
-} stat_entry;
-
-
 extern bool openflow_application_interface_initialized;
 extern openflow_event_handlers_t event_handlers;
 extern char service_name[ MESSENGER_SERVICE_NAME_LENGTH ];
@@ -159,7 +153,7 @@ static bool packet_in_handler_called = false;
  * Mocks.
  ********************************************************************************/
 
-const char*
+const char *
 mock_get_trema_name() {
   return "TEST_SERVICE_NAME";
 }
@@ -286,12 +280,12 @@ mock_error_handler( uint64_t datapath_id, uint32_t transaction_id, uint16_t type
 
 static void
 mock_echo_reply_handler( uint64_t datapath_id, uint32_t transaction_id, const buffer *data,
-                         void *user_data ){
+                         void *user_data ) {
   void *data_uc;
 
   check_expected( &datapath_id );
   check_expected( transaction_id );
-  if( data != NULL ) {
+  if ( data != NULL ) {
     check_expected( data->length );
     check_expected( data->data );
   }
@@ -305,13 +299,13 @@ mock_echo_reply_handler( uint64_t datapath_id, uint32_t transaction_id, const bu
 
 static void
 mock_vendor_handler( uint64_t datapath_id, uint32_t transaction_id, uint32_t vendor,
-                     const buffer *data, void *user_data ){
+                     const buffer *data, void *user_data ) {
   void *data_uc;
 
   check_expected( &datapath_id );
   check_expected( transaction_id );
   check_expected( vendor );
-  if( data != NULL ) {
+  if ( data != NULL ) {
     check_expected( data->length );
     check_expected( data->data );
   }
@@ -1319,7 +1313,7 @@ test_send_openflow_message() {
   will_return( mock_send_message, true );
 
   ret = send_openflow_message( DATAPATH_ID, buffer );
-  
+
   assert_true( ret );
   stat_entry *stat = lookup_hash_entry( stats, "openflow_application_interface.hello_send_succeeded" );
   assert_int_equal( ( int ) stat->value, 1 );
@@ -1649,8 +1643,8 @@ test_handle_features_reply() {
   set_features_reply_handler( mock_features_reply_handler, USER_DATA );
   handle_features_reply( DATAPATH_ID, buffer );
 
-  xfree( phy_port[0] );
-  xfree( phy_port[1] );
+  xfree( phy_port[ 0 ] );
+  xfree( phy_port[ 1 ] );
   delete_list( ports );
   free_buffer( buffer );
 }
@@ -1733,8 +1727,8 @@ test_handle_features_reply_if_handler_is_not_registered() {
 
   handle_features_reply( DATAPATH_ID, buffer );
 
-  xfree( phy_port[0] );
-  xfree( phy_port[1] );
+  xfree( phy_port[ 0 ] );
+  xfree( phy_port[ 1 ] );
   delete_list( ports );
   free_buffer( buffer );
 }
@@ -2884,7 +2878,7 @@ test_handle_openflow_message() {
     data = alloc_buffer_with_length( 16 );
     append_back_buffer( data, 16 );
     memset( data->data, 'a', 16 );
-    
+
     buffer = create_error( TRANSACTION_ID, OFPET_HELLO_FAILED, OFPHFC_INCOMPATIBLE, data );
     append_front_buffer( buffer, sizeof( openflow_service_header_t ) );
     memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
@@ -2895,7 +2889,7 @@ test_handle_openflow_message() {
     expect_value( mock_error_handler, data->length, data->length );
     expect_memory( mock_error_handler, data->data, data->data, data->length );
     expect_memory( mock_error_handler, user_data, USER_DATA, USER_DATA_LEN );
-    
+
     set_error_handler( mock_error_handler, USER_DATA );
     handle_openflow_message( buffer->data, buffer->length );
 
@@ -2925,7 +2919,7 @@ test_handle_openflow_message() {
     expect_value( mock_vendor_handler, data->length, data->length );
     expect_memory( mock_vendor_handler, data->data, data->data, data->length );
     expect_memory( mock_vendor_handler, user_data, USER_DATA, USER_DATA_LEN );
-    
+
     set_vendor_handler( mock_vendor_handler, USER_DATA );
     handle_openflow_message( buffer->data, buffer->length );
 
@@ -2996,8 +2990,8 @@ test_handle_openflow_message() {
     stat = lookup_hash_entry( stats, "openflow_application_interface.features_reply_receive_succeeded" );
     assert_int_equal( ( int ) stat->value, 1 );
 
-    xfree( phy_port[0] );
-    xfree( phy_port[1] );
+    xfree( phy_port[ 0 ] );
+    xfree( phy_port[ 1 ] );
     delete_list( ports );
     free_buffer( buffer );
     xfree( delete_hash_entry( stats, "openflow_application_interface.features_reply_receive_succeeded" ) );
@@ -3312,7 +3306,7 @@ test_handle_openflow_message_with_malformed_message() {
   memcpy( buffer->data, &messenger_header, sizeof( openflow_service_header_t ) );
 
   handle_openflow_message( buffer->data, buffer->length );
-    
+
   free_buffer( buffer );
 }
 

data/unittests/lib/openflow_message_test.c

@@ -21,14 +21,14 @@
 
 
 #include <arpa/inet.h>
+#include <net/if_arp.h>
+#include <netinet/ip.h>
 #include <openflow.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <netinet/ip.h>
-#include <net/if_arp.h>
 #include "byteorder.h"
 #include "checks.h"
 #include "cmockery_trema.h"
@@ -1213,7 +1213,7 @@ static void
 test_append_action_vendor() {
   openflow_actions *actions = NULL;
   uint32_t vendor = 1;
-  buffer *body;
+  buffer *body = NULL;
   struct ofp_action_vendor_header *action_vendor;
   uint16_t length;
   bool ret;
@@ -1234,6 +1234,7 @@ test_append_action_vendor() {
   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_memory_equal( ( char * ) action_vendor + sizeof( struct ofp_action_vendor_header ), body->data, body->length );
 
   assert_int_equal( actions->n_actions, 1 );
 
@@ -2327,7 +2328,7 @@ test_create_vendor_stats_request() {
   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 ),
+  assert_memory_equal( ( char * ) stats + offsetof( struct ofp_stats_request, body ) + sizeof( uint32_t ),
                        body->data, body_length );
 
   free_buffer( body );
@@ -4454,13 +4455,14 @@ 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 ) );
+  struct ofp_action_vendor_header *action_vendor = xmalloc( sizeof( struct ofp_action_vendor_header ) + body->length );
+  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 );
+  assert_int_equal( validate_action_enqueue( ( struct ofp_action_enqueue * ) action_vendor ), ERROR_INVALID_ACTION_TYPE );
 
   free_buffer( body );
   delete_actions( actions );
+  xfree( action_vendor );
 }
 
 
@@ -4509,13 +4511,14 @@ 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 ) );
+  struct ofp_action_vendor_header *action_vendor_header = xmalloc( sizeof( struct ofp_action_vendor_header ) + body->length );
+  hton_action_vendor( action_vendor_header, ( struct ofp_action_vendor_header * ) ( actions->list->data ) );
 
-  assert_int_equal( validate_action_vendor( &action_vendor_header ), 0 );
+  assert_int_equal( validate_action_vendor( action_vendor_header ), 0 );
 
   free_buffer( body );
   delete_actions( actions );
+  xfree( action_vendor_header );
 }
 
 
@@ -4540,15 +4543,16 @@ 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 );
+  struct ofp_action_vendor_header *too_short_action_vendor_header = xmalloc( sizeof( struct ofp_action_vendor_header ) + body->length );
+  hton_action_vendor( too_short_action_vendor_header, ( struct ofp_action_vendor_header * ) ( actions->list->data ) );
   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 ) );
+  too_short_action_vendor_header->len = htons( too_short_action_length );
 
-  assert_int_equal( validate_action_vendor( &too_short_action_vendor_header ), ERROR_TOO_SHORT_ACTION_VENDOR );
+  assert_int_equal( validate_action_vendor( too_short_action_vendor_header ), ERROR_TOO_SHORT_ACTION_VENDOR );
 
   free_buffer( body );
-  delete_actions( ( openflow_actions * ) actions );
+  delete_actions( actions );
+  xfree( too_short_action_vendor_header );
 }
 
 
@@ -5047,8 +5051,8 @@ setup_ether_packet( size_t length, uint16_t type ) {
   if ( type == ETH_ETHTYPE_TPID ) {
     packet_info0->l3_header = ( void * ) ( vtag + 1 );
     packet_info0->format |= ETH_8021Q;
-  } 
-  else { 
+  }
+  else {
     packet_info0->l3_header = ( void * ) ( ether + 1 );
   }
 
@@ -5082,7 +5086,7 @@ setup_ipv4_packet( size_t length, uint16_t type ) {
 
   switch ( type ) {
   case IPPROTO_ICMP:
-    ipv4->protocol = ( uint8_t ) 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;
@@ -5094,7 +5098,7 @@ setup_ipv4_packet( size_t length, uint16_t type ) {
     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;
@@ -5142,7 +5146,7 @@ setup_ipv4_packet( size_t length, uint16_t type ) {
   default:
     break;
   }
-  
+
   return buf;
 }
 
@@ -5151,7 +5155,7 @@ 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;
@@ -5217,7 +5221,7 @@ setup_snap_packet( uint16_t type ) {
     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 );
   }
@@ -6015,7 +6019,7 @@ test_set_match_from_packet_succeeds_if_datatype_is_ipv4_tcp_tag_and_wildcards_is
   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 );
@@ -6424,7 +6428,7 @@ test_set_match_from_packet_succeeds_if_datatype_is_ipv4_icmp_tag_and_wildcards_i
   /* 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;    
+  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. */
@@ -6980,6 +6984,16 @@ test_set_match_from_packet_succeeds_if_datatype_is_ieee8023_not_llc_and_wildcard
 }
 
 
+static void
+test_set_match_from_packet_fails_if_match_is_NULL() {
+  buffer *buf = setup_arp_packet( ETH_ETHTYPE_TPID );
+
+  expect_assert_failure( set_match_from_packet( NULL, 1, 0, buf ) );
+
+  free_buffer( buf );
+}
+
+
 static void
 test_set_match_from_packet_fails_if_packet_data_is_NULL() {
   struct ofp_match match;
@@ -6998,6 +7012,666 @@ test_set_match_from_packet_fails_if_packet_is_not_parsed_yet() {
 }
 
 
+/********************************************************************************
+ * normalize_match() tests.
+ ********************************************************************************/
+
+#define NORMALIZED_OFPFW_ALL \
+  ( OFPFW_IN_PORT | OFPFW_DL_VLAN | OFPFW_DL_SRC | OFPFW_DL_DST | OFPFW_DL_TYPE | \
+    OFPFW_NW_PROTO | OFPFW_TP_SRC | OFPFW_TP_DST | OFPFW_NW_SRC_ALL | OFPFW_NW_DST_ALL | \
+    OFPFW_DL_VLAN_PCP | OFPFW_NW_TOS )
+
+
+const char all_zero_mac_addr[] = { 0, 0, 0, 0, 0, 0 };
+const char all_one_mac_addr[] = { ( char ) 0xff, ( char ) 0xff, ( char ) 0xff,
+                                  ( char ) 0xff, ( char ) 0xff, ( char ) 0xff };
+const char all_zero_pad1[] = { 0 };
+const char all_zero_pad2[] = { 0, 0 };
+
+
+static void
+setup_arp_match( struct ofp_match *match ) {
+  memset( match, 0xa8, sizeof( match ) );
+  match->wildcards = 0;
+  match->in_port = 1;
+  memcpy( match->dl_src, macsa, ETH_ADDRLEN );
+  memcpy( match->dl_dst, macda, ETH_ADDRLEN );
+  match->dl_vlan = UINT16_MAX;
+  match->dl_type = ETH_ETHTYPE_ARP;
+  match->nw_proto = ARP_OP_REQUEST;
+  match->nw_src = 0x01020304;
+  match->nw_dst = 0x05060708;
+}
+
+
+static void
+setup_icmp_match( struct ofp_match *match ) {
+  memset( match, 0xa8, sizeof( match ) );
+  match->wildcards = 0;
+  match->in_port = 1;
+  memcpy( match->dl_src, macsa, ETH_ADDRLEN );
+  memcpy( match->dl_dst, macda, ETH_ADDRLEN );
+  match->dl_vlan = UINT16_MAX;
+  match->dl_type = ETH_ETHTYPE_IPV4;
+  match->nw_tos = 0;
+  match->nw_proto = IPPROTO_ICMP;
+  match->nw_src = 0x01020304;
+  match->nw_dst = 0x05060708;
+  match->tp_src = ICMP_TYPE_UNREACH;
+  match->tp_dst = ICMP_CODE_PORTUNREACH;
+}
+
+
+static void
+setup_tcp_match( struct ofp_match *match ) {
+  memset( match, 0xa8, sizeof( match ) );
+  match->wildcards = 0;
+  match->in_port = 1;
+  memcpy( match->dl_src, macsa, ETH_ADDRLEN );
+  memcpy( match->dl_dst, macda, ETH_ADDRLEN );
+  match->dl_vlan = 1;
+  match->dl_vlan_pcp = 0xff;
+  match->dl_type = ETH_ETHTYPE_IPV4;
+  match->nw_tos = 0xff;
+  match->nw_proto = IPPROTO_TCP;
+  match->nw_src = 0x01020304;
+  match->nw_dst = 0x05060708;
+  match->tp_src = 0xa;
+  match->tp_dst = 0xb;
+}
+
+
+static void
+setup_udp_match( struct ofp_match *match ) {
+  memset( match, 0xa8, sizeof( match ) );
+  match->wildcards = 0;
+  match->in_port = 1;
+  memcpy( match->dl_src, macsa, ETH_ADDRLEN );
+  memcpy( match->dl_dst, macda, ETH_ADDRLEN );
+  match->dl_vlan = UINT16_MAX;
+  match->dl_vlan_pcp = 0xff;
+  match->dl_type = ETH_ETHTYPE_IPV4;
+  match->nw_tos = 0xff;
+  match->nw_proto = IPPROTO_UDP;
+  match->nw_src = 0x01020304;
+  match->nw_dst = 0x05060708;
+  match->tp_src = 0xa;
+  match->tp_dst = 0xb;
+}
+
+
+static void
+setup_invalid_match( struct ofp_match *match ) {
+  memset( match, 0xa8, sizeof( match ) );
+  match->wildcards = 0;
+  match->in_port = 1;
+  memcpy( match->dl_src, macsa, ETH_ADDRLEN );
+  memcpy( match->dl_dst, macda, ETH_ADDRLEN );
+  match->dl_vlan = UINT16_MAX;
+  match->dl_vlan_pcp = 0xff;
+  match->dl_type = UINT16_MAX;
+}
+
+
+static void
+test_normalize_match_succeeds_if_datatype_is_arp_and_wildcards_is_zero() {
+  struct ofp_match match;
+  setup_arp_match( &match );
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_DL_VLAN_PCP | OFPFW_NW_TOS | OFPFW_TP_SRC | OFPFW_TP_DST;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, UINT16_MAX );
+  assert_int_equal( match.dl_vlan_pcp, 0 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_ARP );
+  assert_int_equal( match.nw_tos, 0 );
+  assert_int_equal( match.nw_proto, ARP_OP_REQUEST );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0 );
+  assert_int_equal( ( int ) match.tp_dst, 0 );
+}
+
+
+static void
+test_normalize_match_succeeds_if_protocol_is_icmp_and_wildcards_is_zero() {
+  struct ofp_match match;
+  setup_icmp_match( &match );
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_DL_VLAN_PCP;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, UINT16_MAX );
+  assert_int_equal( match.dl_vlan_pcp, 0 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0 );
+  assert_int_equal( match.nw_proto, IPPROTO_ICMP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, ICMP_TYPE_UNREACH );
+  assert_int_equal( ( int ) match.tp_dst, ICMP_CODE_PORTUNREACH );
+}
+
+
+static void
+test_normalize_match_succeeds_if_protocol_is_tcp_and_wildcards_is_zero() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+
+  normalize_match( &match );
+
+  uint32_t wildcards = 0;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_protocol_is_udp_and_wildcards_is_zero() {
+  struct ofp_match match;
+  setup_udp_match( &match );
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_DL_VLAN_PCP;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, UINT16_MAX );
+  assert_int_equal( match.dl_vlan_pcp, 0 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_UDP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_packet_is_invalid_and_wildcards_is_zero() {
+  struct ofp_match match;
+  setup_invalid_match( &match );
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_DL_VLAN_PCP | OFPFW_NW_PROTO | OFPFW_NW_TOS | OFPFW_NW_SRC_ALL | OFPFW_NW_DST_ALL | OFPFW_TP_SRC | OFPFW_TP_DST;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, UINT16_MAX );
+  assert_int_equal( match.dl_vlan_pcp, 0 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, UINT16_MAX );
+  assert_int_equal( match.nw_tos, 0 );
+  assert_int_equal( match.nw_proto, 0 );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0 );
+  assert_int_equal( ( int ) match.nw_dst, 0 );
+  assert_int_equal( ( int ) match.tp_src, 0 );
+  assert_int_equal( ( int ) match.tp_dst, 0 );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_ALL() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_ALL;
+
+  normalize_match( &match );
+
+  assert_int_equal( ( int ) match.wildcards, NORMALIZED_OFPFW_ALL );
+  assert_int_equal( match.in_port, 0 );
+  assert_memory_equal( match.dl_src, all_zero_mac_addr, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, all_zero_mac_addr, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 0 );
+  assert_int_equal( match.dl_vlan_pcp, 0 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, 0 );
+  assert_int_equal( match.nw_tos, 0 );
+  assert_int_equal( match.nw_proto, 0 );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0 );
+  assert_int_equal( ( int ) match.nw_dst, 0 );
+  assert_int_equal( ( int ) match.tp_src, 0 );
+  assert_int_equal( ( int ) match.tp_dst, 0 );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_IN_PORT() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_IN_PORT;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_IN_PORT;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 0 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_DL_VLAN() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_DL_VLAN;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_DL_VLAN;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 0 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_DL_SRC() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_DL_SRC;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_DL_SRC;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, all_zero_mac_addr, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_DL_DST() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_DL_DST;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_DL_DST;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, all_zero_mac_addr, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_DL_TYPE() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_DL_TYPE;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_DL_TYPE | OFPFW_NW_PROTO | OFPFW_NW_TOS | OFPFW_NW_SRC_ALL | OFPFW_NW_DST_ALL | OFPFW_TP_SRC | OFPFW_TP_DST;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, 0 );
+  assert_int_equal( match.nw_tos, 0 );
+  assert_int_equal( match.nw_proto, 0 );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0 );
+  assert_int_equal( ( int ) match.nw_dst, 0 );
+  assert_int_equal( ( int ) match.tp_src, 0 );
+  assert_int_equal( ( int ) match.tp_dst, 0 );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_NW_PROTO() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_NW_PROTO;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_NW_PROTO;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, 0 );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_TP_SRC() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_TP_SRC;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_TP_SRC;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0 );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_TP_DST() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_TP_DST;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_TP_DST;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0 );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_NW_SRC_ALL() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_NW_SRC_ALL;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_NW_SRC_ALL;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_NW_DST_ALL() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_NW_DST_ALL;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_NW_DST_ALL;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_src_mask_len_is_24() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = 24 << OFPFW_NW_SRC_SHIFT;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = 24 << OFPFW_NW_SRC_SHIFT;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01000000 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_dst_mask_len_is_24() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = 24 << OFPFW_NW_DST_SHIFT;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = 24 << OFPFW_NW_DST_SHIFT;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05000000 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_DL_VLAN_PCP() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_DL_VLAN_PCP;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_DL_VLAN_PCP;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0xfc );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_succeeds_if_wildcards_is_OFPFW_NW_TOS() {
+  struct ofp_match match;
+  setup_tcp_match( &match );
+  match.wildcards = OFPFW_NW_TOS;
+
+  normalize_match( &match );
+
+  uint32_t wildcards = OFPFW_NW_TOS;
+
+  assert_int_equal( ( int ) match.wildcards, wildcards );
+  assert_int_equal( match.in_port, 1 );
+  assert_memory_equal( match.dl_src, macsa, ETH_ADDRLEN );
+  assert_memory_equal( match.dl_dst, macda, ETH_ADDRLEN );
+  assert_int_equal( match.dl_vlan, 1 );
+  assert_int_equal( match.dl_vlan_pcp, 0x7 );
+  assert_memory_equal( match.pad1, all_zero_pad1, sizeof( match.pad1 ) );
+  assert_int_equal( match.dl_type, ETH_ETHTYPE_IPV4 );
+  assert_int_equal( match.nw_tos, 0 );
+  assert_int_equal( match.nw_proto, IPPROTO_TCP );
+  assert_memory_equal( match.pad2, all_zero_pad2, sizeof( match.pad2 ) );
+  assert_int_equal( ( int ) match.nw_src, 0x01020304 );
+  assert_int_equal( ( int ) match.nw_dst, 0x05060708 );
+  assert_int_equal( ( int ) match.tp_src, 0xa );
+  assert_int_equal( ( int ) match.tp_dst, 0xb );
+}
+
+
+static void
+test_normalize_match_fails_if_match_is_NULL() {
+  expect_assert_failure( normalize_match( NULL ) );
+}
+
+
 /********************************************************************************
  * Run tests.
  ********************************************************************************/
@@ -7318,8 +7992,31 @@ main() {
     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_match_is_NULL, 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 ),
+
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_datatype_is_arp_and_wildcards_is_zero, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_protocol_is_icmp_and_wildcards_is_zero, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_protocol_is_tcp_and_wildcards_is_zero, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_protocol_is_udp_and_wildcards_is_zero, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_packet_is_invalid_and_wildcards_is_zero, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_ALL, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_IN_PORT, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_DL_VLAN, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_DL_SRC, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_DL_DST, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_DL_TYPE, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_NW_PROTO, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_TP_SRC, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_TP_DST, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_NW_SRC_ALL, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_NW_DST_ALL, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_src_mask_len_is_24, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_dst_mask_len_is_24, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_DL_VLAN_PCP, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_succeeds_if_wildcards_is_OFPFW_NW_TOS, init, teardown ),
+    unit_test_setup_teardown( test_normalize_match_fails_if_match_is_NULL, init, teardown ),
   };
   return run_tests( tests );
 }