tests/pktact.py

"""
Test cases for testing actions taken on packets

See basic.py for other info.

It is recommended that these definitions be kept in their own
namespace as different groups of tests will likely define 
similar identifiers.

  The function test_set_init is called with a complete configuration
dictionary prior to the invocation of any tests from this file.

  The switch is actively attempting to contact the controller at the address
indicated oin oft_config

"""

import logging

import unittest

import oftest.controller as controller
import oftest.cstruct as ofp
import oftest.message as message
import oftest.dataplane as dataplane
import oftest.action as action
import oftest.parse as parse
import basic

from testutils import *

#@var port_map Local copy of the configuration map from OF port
# numbers to OS interfaces
pa_port_map = None
#@var pa_logger Local logger object
pa_logger = None
#@var pa_config Local copy of global configuration data
pa_config = None

def test_set_init(config):
    """
    Set up function for packet action test classes

    @param config The configuration dictionary; see oft
    """

    global pa_port_map
    global pa_logger
    global pa_config

    pa_logger = logging.getLogger("pkt_act")
    pa_logger.info("Initializing test set")
    pa_port_map = config["port_map"]
    pa_config = config

class DirectPacket(basic.SimpleDataPlane):
    """
    Send packet to single egress port

    Generate a packet
    Generate and install a matching flow
    Add action to direct the packet to an egress port
    Send the packet to ingress dataplane port
    Verify the packet is received at the egress port only
    """
    def runTest(self):
        global pa_port_map
        of_ports = pa_port_map.keys()
        of_ports.sort()
        self.assertTrue(len(of_ports) > 1, "Not enough ports for test")

        pkt = simple_tcp_packet()
        match = parse.packet_to_flow_match(pkt)
        match.wildcards &= ~ofp.OFPFW_IN_PORT
        self.assertTrue(match is not None, 
                        "Could not generate flow match from pkt")
        act = action.action_output()

        for idx in range(len(of_ports)):
            rc = delete_all_flows(self.controller, pa_logger)
            self.assertEqual(rc, 0, "Failed to delete all flows")

            ingress_port = of_ports[idx]
            egress_port = of_ports[(idx + 1) % len(of_ports)]
            pa_logger.info("Ingress " + str(ingress_port) + 
                        " to egress " + str(egress_port))

            match.in_port = ingress_port

            request = message.flow_mod()
            request.match = match
            request.buffer_id = 0xffffffff
            act.port = egress_port
            self.assertTrue(request.actions.add(act), "Could not add action")

            pa_logger.info("Inserting flow")
            rv = self.controller.message_send(request)
            self.assertTrue(rv != -1, "Error installing flow mod")
            do_barrier(self.controller)

            pa_logger.info("Sending packet to dp port " + 
                           str(ingress_port))
            self.dataplane.send(ingress_port, str(pkt))
            (rcv_port, rcv_pkt, pkt_time) = self.dataplane.poll(timeout=1)
            self.assertTrue(rcv_pkt is not None, "Did not receive packet")
            pa_logger.debug("Packet len " + str(len(rcv_pkt)) + " in on " + 
                         str(rcv_port))
            self.assertEqual(rcv_port, egress_port, "Unexpected receive port")
            self.assertEqual(str(pkt), str(rcv_pkt),
                             'Response packet does not match send packet')
            
        

class DirectTwoPorts(basic.SimpleDataPlane):
    """
    Send packet to two egress ports

    Generate a packet
    Generate and install a matching flow
    Add action to direct the packet to two egress ports
    Send the packet to ingress dataplane port
    Verify the packet is received at the two egress ports
    """
    def runTest(self):
        global pa_port_map
        of_ports = pa_port_map.keys()
        of_ports.sort()
        self.assertTrue(len(of_ports) > 2, "Not enough ports for test")

        pkt = simple_tcp_packet()
        match = parse.packet_to_flow_match(pkt)
        match.wildcards &= ~ofp.OFPFW_IN_PORT
        self.assertTrue(match is not None, 
                        "Could not generate flow match from pkt")
        act = action.action_output()

        for idx in range(len(of_ports)):
            rc = delete_all_flows(self.controller, pa_logger)
            self.assertEqual(rc, 0, "Failed to delete all flows")

            ingress_port = of_ports[idx]
            egress_port1 = of_ports[(idx + 1) % len(of_ports)]
            egress_port2 = of_ports[(idx + 2) % len(of_ports)]
            pa_logger.info("Ingress " + str(ingress_port) + 
                           " to egress " + str(egress_port1) + " and " +
                           str(egress_port2))

            match.in_port = ingress_port

            request = message.flow_mod()
            request.match = match
            request.buffer_id = 0xffffffff
            act.port = egress_port1
            self.assertTrue(request.actions.add(act), "Could not add action1")
            act.port = egress_port2
            self.assertTrue(request.actions.add(act), "Could not add action2")
            # pa_logger.info(request.show())

            pa_logger.info("Inserting flow")
            rv = self.controller.message_send(request)
            self.assertTrue(rv != -1, "Error installing flow mod")
            do_barrier(self.controller)

            pa_logger.info("Sending packet to dp port " + 
                           str(ingress_port))
            self.dataplane.send(ingress_port, str(pkt))
            (rcv_port1, rcv_pkt1, pkt_time1) = self.dataplane.poll(timeout=1)
            (rcv_port2, rcv_pkt2, pkt_time2) = self.dataplane.poll(timeout=1)
            self.assertTrue(rcv_pkt1 is not None, "Did not receive packet 1")
            self.assertTrue(rcv_pkt2 is not None, "Did not receive packet 2")
            pa_logger.debug("Packet len " + str(len(rcv_pkt1)) + " in on " + 
                         str(rcv_port1))
            pa_logger.debug("Packet len " + str(len(rcv_pkt2)) + " in on " + 
                         str(rcv_port2))

            # Check if ports swapped
            if (rcv_port1 == egress_port2 and rcv_port2 == egress_port1):
                (rcv_port2, rcv_port1) = (rcv_port1, rcv_port2)
                (rcv_pkt2, rcv_pkt1) = (rcv_pkt1, rcv_pkt2)
            self.assertEqual(rcv_port1, egress_port1,
                             "Unexpected receive port 1")
            self.assertEqual(rcv_port2, egress_port2,
                             "Unexpected receive port 2")
            self.assertEqual(str(pkt), str(rcv_pkt1),
                             'Response packet does not match send packet 1')
            self.assertEqual(str(pkt), str(rcv_pkt2),
                             'Response packet does not match send packet 2')

class DirectMCNonIngress(basic.SimpleDataPlane):
    """
    Multicast to all non-ingress ports

    Generate a packet
    Generate and install a matching flow
    Add action to direct the packet to all non-ingress ports
    Send the packet to ingress dataplane port
    Verify the packet is received at all non-ingress ports

    Does not use the flood action
    """
    def runTest(self):
        global pa_port_map
        of_ports = pa_port_map.keys()
        of_ports.sort()
        self.assertTrue(len(of_ports) > 2, "Not enough ports for test")

        pkt = simple_tcp_packet()
        match = parse.packet_to_flow_match(pkt)
        match.wildcards &= ~ofp.OFPFW_IN_PORT
        self.assertTrue(match is not None, 
                        "Could not generate flow match from pkt")
        act = action.action_output()

        for idx in range(len(of_ports)):
            rc = delete_all_flows(self.controller, pa_logger)
            self.assertEqual(rc, 0, "Failed to delete all flows")

            ingress_port = of_ports[idx]
            pa_logger.info("Ingress " + str(ingress_port) + 
                           " all non-ingress ports")

            match.in_port = ingress_port

            request = message.flow_mod()
            request.match = match
            request.buffer_id = 0xffffffff
            for egr_idx in range(len(of_ports)):
                if egr_idx == idx:
                    continue
                egress_port = of_ports[egr_idx]
                act.port = egress_port
                self.assertTrue(request.actions.add(act), 
                                "Could not add output to " + str(egress_port))
            pa_logger.info(request.show())

            pa_logger.info("Inserting flow")
            rv = self.controller.message_send(request)
            self.assertTrue(rv != -1, "Error installing flow mod")
            do_barrier(self.controller)

            pa_logger.info("Sending packet to dp port " + 
                           str(ingress_port))
            self.dataplane.send(ingress_port, str(pkt))
            for egr_idx in range(len(of_ports)):
                if egr_idx == idx:
                    continue
                ofport = of_ports[egr_idx]
                (rcv_port, rcv_pkt, pkt_time) = self.dataplane.poll(
                    port_number=ofport, timeout=1)
                self.assertTrue(rcv_pkt is not None, 
                                "Did not receive packet port " + str(ofport))
                pa_logger.debug("Packet len " + str(len(rcv_pkt)) + " in on "
                                + str(rcv_port))

                self.assertEqual(str(pkt), str(rcv_pkt),
                             'Response packet does not match send packet ' +
                                 "on port " + str(ofport))

class DirectMC(basic.SimpleDataPlane):
    """
    Multicast to all ports including ingress

    Generate a packet
    Generate and install a matching flow
    Add action to direct the packet to all non-ingress ports
    Send the packet to ingress dataplane port
    Verify the packet is received at all ports

    Does not use the flood action
    """
    def runTest(self):
        global pa_port_map
        of_ports = pa_port_map.keys()
        of_ports.sort()
        self.assertTrue(len(of_ports) > 2, "Not enough ports for test")

        pkt = simple_tcp_packet()
        match = parse.packet_to_flow_match(pkt)
        match.wildcards &= ~ofp.OFPFW_IN_PORT
        self.assertTrue(match is not None, 
                        "Could not generate flow match from pkt")
        act = action.action_output()

        for idx in range(len(of_ports)):
            rc = delete_all_flows(self.controller, pa_logger)
            self.assertEqual(rc, 0, "Failed to delete all flows")

            ingress_port = of_ports[idx]
            pa_logger.info("Ingress " + str(ingress_port) + " to all ports")

            match.in_port = ingress_port

            request = message.flow_mod()
            request.match = match
            request.buffer_id = 0xffffffff
            for egr_idx in range(len(of_ports)):
                egress_port = of_ports[egr_idx]
                if egr_idx == idx:
                    act.port = ofp.OFPP_IN_PORT
                else:
                    act.port = egress_port
                self.assertTrue(request.actions.add(act), 
                                "Could not add output to " + str(egress_port))
            # pa_logger.info(request.show())

            pa_logger.info("Inserting flow")
            rv = self.controller.message_send(request)
            self.assertTrue(rv != -1, "Error installing flow mod")
            do_barrier(self.controller)

            pa_logger.info("Sending packet to dp port " + str(ingress_port))
            self.dataplane.send(ingress_port, str(pkt))
            for egr_idx in range(len(of_ports)):
                ofport = of_ports[egr_idx]
                (rcv_port, rcv_pkt, pkt_time) = self.dataplane.poll(
                    port_number=ofport, timeout=1)
                self.assertTrue(rcv_pkt is not None, 
                                "Did not receive packet port " + str(ofport))
                pa_logger.debug("Packet len " + str(len(rcv_pkt)) + " in on "
                                + str(rcv_port))

                self.assertEqual(str(pkt), str(rcv_pkt),
                             'Response packet does not match send packet ' +
                                 "on port " + str(ofport))

class Flood(basic.SimpleDataPlane):
    """
    Flood to all ports except ingress

    Generate a packet
    Generate and install a matching flow
    Add action to flood the packet
    Send the packet to ingress dataplane port
    Verify the packet is received at all other ports
    """
    def runTest(self):
        global pa_port_map
        of_ports = pa_port_map.keys()
        of_ports.sort()
        self.assertTrue(len(of_ports) > 1, "Not enough ports for test")

        pkt = simple_tcp_packet()
        match = parse.packet_to_flow_match(pkt)
        match.wildcards &= ~ofp.OFPFW_IN_PORT
        self.assertTrue(match is not None, 
                        "Could not generate flow match from pkt")
        act = action.action_output()

        for idx in range(len(of_ports)):
            rc = delete_all_flows(self.controller, pa_logger)
            self.assertEqual(rc, 0, "Failed to delete all flows")

            ingress_port = of_ports[idx]
            pa_logger.info("Ingress " + str(ingress_port) + " to all ports")

            match.in_port = ingress_port

            request = message.flow_mod()
            request.match = match
            request.buffer_id = 0xffffffff
            act.port = ofp.OFPP_FLOOD
            self.assertTrue(request.actions.add(act), 
                            "Could not add flood port action")
            pa_logger.info(request.show())

            pa_logger.info("Inserting flow")
            rv = self.controller.message_send(request)
            self.assertTrue(rv != -1, "Error installing flow mod")
            do_barrier(self.controller)

            pa_logger.info("Sending packet to dp port " + str(ingress_port))
            self.dataplane.send(ingress_port, str(pkt))
            for egr_idx in range(len(of_ports)):
                if egr_idx == idx:
                    continue
                ofport = of_ports[egr_idx]
                (rcv_port, rcv_pkt, pkt_time) = self.dataplane.poll(
                    port_number=ofport, timeout=1)
                self.assertTrue(rcv_pkt is not None, 
                                "Did not receive packet port " + str(ofport))
                pa_logger.debug("Packet len " + str(len(rcv_pkt)) + " in on "
                                + str(rcv_port))

                self.assertEqual(str(pkt), str(rcv_pkt),
                             'Response packet does not match send packet ' +
                                 "on port " + str(ofport))


class FloodPlusIngress(basic.SimpleDataPlane):
    """
    Flood to all ports plus send to ingress port

    Generate a packet
    Generate and install a matching flow
    Add action to flood the packet
    Add action to send to ingress port
    Send the packet to ingress dataplane port
    Verify the packet is received at all other ports
    """
    def runTest(self):
        global pa_port_map
        of_ports = pa_port_map.keys()
        of_ports.sort()
        self.assertTrue(len(of_ports) > 1, "Not enough ports for test")

        pkt = simple_tcp_packet()
        match = parse.packet_to_flow_match(pkt)
        match.wildcards &= ~ofp.OFPFW_IN_PORT
        self.assertTrue(match is not None, 
                        "Could not generate flow match from pkt")
        act = action.action_output()

        for idx in range(len(of_ports)):
            rc = delete_all_flows(self.controller, pa_logger)
            self.assertEqual(rc, 0, "Failed to delete all flows")

            ingress_port = of_ports[idx]
            pa_logger.info("Ingress " + str(ingress_port) + " to all ports")

            match.in_port = ingress_port

            request = message.flow_mod()
            request.match = match
            request.buffer_id = 0xffffffff
            act.port = ofp.OFPP_FLOOD
            self.assertTrue(request.actions.add(act), 
                            "Could not add flood port action")
            act.port = ofp.OFPP_IN_PORT
            self.assertTrue(request.actions.add(act), 
                            "Could not add ingress port for output")
            pa_logger.info(request.show())

            pa_logger.info("Inserting flow")
            rv = self.controller.message_send(request)
            self.assertTrue(rv != -1, "Error installing flow mod")
            do_barrier(self.controller)

            pa_logger.info("Sending packet to dp port " + str(ingress_port))
            self.dataplane.send(ingress_port, str(pkt))
            for egr_idx in range(len(of_ports)):
                ofport = of_ports[egr_idx]
                (rcv_port, rcv_pkt, pkt_time) = self.dataplane.poll(
                    port_number=ofport, timeout=1)
                self.assertTrue(rcv_pkt is not None, 
                                "Did not receive packet port " + str(ofport))
                pa_logger.debug("Packet len " + str(len(rcv_pkt)) + " in on "
                                + str(rcv_port))

                self.assertEqual(str(pkt), str(rcv_pkt),
                             'Response packet does not match send packet ' +
                                 "on port " + str(ofport))

class All(basic.SimpleDataPlane):
    """
    Send to OFPP_ALL port

    Generate a packet
    Generate and install a matching flow
    Add action to forward to OFPP_ALL
    Send the packet to ingress dataplane port
    Verify the packet is received at all other ports
    """
    def runTest(self):
        global pa_port_map
        of_ports = pa_port_map.keys()
        of_ports.sort()
        self.assertTrue(len(of_ports) > 1, "Not enough ports for test")

        pkt = simple_tcp_packet()
        match = parse.packet_to_flow_match(pkt)
        match.wildcards &= ~ofp.OFPFW_IN_PORT
        self.assertTrue(match is not None, 
                        "Could not generate flow match from pkt")
        act = action.action_output()

        for idx in range(len(of_ports)):
            rc = delete_all_flows(self.controller, pa_logger)
            self.assertEqual(rc, 0, "Failed to delete all flows")

            ingress_port = of_ports[idx]
            pa_logger.info("Ingress " + str(ingress_port) + " to all ports")

            match.in_port = ingress_port

            request = message.flow_mod()
            request.match = match
            request.buffer_id = 0xffffffff
            act.port = ofp.OFPP_ALL
            self.assertTrue(request.actions.add(act), 
                            "Could not add ALL port action")
            pa_logger.info(request.show())

            pa_logger.info("Inserting flow")
            rv = self.controller.message_send(request)
            self.assertTrue(rv != -1, "Error installing flow mod")
            do_barrier(self.controller)

            pa_logger.info("Sending packet to dp port " + str(ingress_port))
            self.dataplane.send(ingress_port, str(pkt))
            for egr_idx in range(len(of_ports)):
                if egr_idx == idx:
                    continue
                ofport = of_ports[egr_idx]
                (rcv_port, rcv_pkt, pkt_time) = self.dataplane.poll(
                    port_number=ofport, timeout=1)
                self.assertTrue(rcv_pkt is not None, 
                                "Did not receive packet port " + str(ofport))
                pa_logger.debug("Packet len " + str(len(rcv_pkt)) + " in on "
                                + str(rcv_port))

                self.assertEqual(str(pkt), str(rcv_pkt),
                             'Response packet does not match send packet ' +
                                 "on port " + str(ofport))

class AllPlusIngress(basic.SimpleDataPlane):
    """
    Send to OFPP_ALL port and ingress port

    Generate a packet
    Generate and install a matching flow
    Add action to forward to OFPP_ALL
    Add action to forward to ingress port
    Send the packet to ingress dataplane port
    Verify the packet is received at all other ports
    """
    def runTest(self):
        global pa_port_map
        of_ports = pa_port_map.keys()
        of_ports.sort()
        self.assertTrue(len(of_ports) > 1, "Not enough ports for test")

        pkt = simple_tcp_packet()
        match = parse.packet_to_flow_match(pkt)
        match.wildcards &= ~ofp.OFPFW_IN_PORT
        self.assertTrue(match is not None, 
                        "Could not generate flow match from pkt")
        act = action.action_output()

        for idx in range(len(of_ports)):
            rc = delete_all_flows(self.controller, pa_logger)
            self.assertEqual(rc, 0, "Failed to delete all flows")

            ingress_port = of_ports[idx]
            pa_logger.info("Ingress " + str(ingress_port) + " to all ports")

            match.in_port = ingress_port

            request = message.flow_mod()
            request.match = match
            request.buffer_id = 0xffffffff
            act.port = ofp.OFPP_ALL
            self.assertTrue(request.actions.add(act), 
                            "Could not add ALL port action")
            act.port = ofp.OFPP_IN_PORT
            self.assertTrue(request.actions.add(act), 
                            "Could not add ingress port for output")
            pa_logger.info(request.show())

            pa_logger.info("Inserting flow")
            rv = self.controller.message_send(request)
            self.assertTrue(rv != -1, "Error installing flow mod")
            do_barrier(self.controller)

            pa_logger.info("Sending packet to dp port " + str(ingress_port))
            self.dataplane.send(ingress_port, str(pkt))
            for egr_idx in range(len(of_ports)):
                ofport = of_ports[egr_idx]
                (rcv_port, rcv_pkt, pkt_time) = self.dataplane.poll(
                    port_number=ofport, timeout=1)
                self.assertTrue(rcv_pkt is not None, 
                                "Did not receive packet port " + str(ofport))
                pa_logger.debug("Packet len " + str(len(rcv_pkt)) + " in on "
                                + str(rcv_port))

                self.assertEqual(str(pkt), str(rcv_pkt),
                             'Response packet does not match send packet ' +
                                 "on port " + str(ofport))

class SimpleExactMatch(basic.SimpleDataPlane):
    """
    Exercise exact matching for all ports

    Generate a packet
    Generate and install a matching flow without wildcard mask
    Add action to forward to a port
    Send the packet to the port
    Verify the packet is received at all other ports (one port at a time)
    Verify flow_expiration message is correct when command option is set
    """
    IP_ETHTYPE = 0x800
    TCP_PROTOCOL = 0x6
    UDP_PROTOCOL = 0x11

    def runTest(self):
        self.flowMatchTest()

    def flowMatchTest(self, wildcards=0, check_expire=False):
        global pa_port_map
        of_ports = pa_port_map.keys()
        of_ports.sort()
        self.assertTrue(len(of_ports) > 1, "Not enough ports for test")

        pkt = simple_tcp_packet()
        match = parse.packet_to_flow_match(pkt)
        self.assertTrue(match is not None,
                        "Could not generate flow match from pkt")
        match.dl_vlan = ofp.OFP_VLAN_NONE
        match.nw_proto = self.TCP_PROTOCOL
        match.wildcards = wildcards

        act = action.action_output()

        for idx in range(len(of_ports)):
            rc = delete_all_flows(self.controller, pa_logger)
            self.assertEqual(rc, 0, "Failed to delete all flows")

            ingress_port = of_ports[idx]
            pa_logger.info("Ingress " + str(ingress_port) + " to all the other ports")

            match.in_port = ingress_port

            request = message.flow_mod()
            request.match = match
            request.buffer_id = 0xffffffff
            #@todo Need UI to setup FLAGS parameter for flow_mod
            if(check_expire):
                request.flags |= ofp.OFPFF_SEND_FLOW_REM
                request.hard_timeout = 1

            for egr_idx in range(len(of_ports)):
                if egr_idx == idx:
                    continue
                act.port = of_ports[egr_idx]
                self.assertTrue(request.actions.add(act),
                                "Could not add output action")
                pa_logger.info(request.show())

                pa_logger.info("Inserting flow")
                rv = self.controller.message_send(request)
                self.assertTrue(rv != -1, "Error installing flow mod")
                do_barrier(self.controller)

                pa_logger.info("Sending packet to dp port " +str(ingress_port))
                self.dataplane.send(ingress_port, str(pkt))

                ofport = of_ports[egr_idx]
                (rcv_port, rcv_pkt, pkt_time) = self.dataplane.poll(
                port_number=ofport, timeout=1)
                self.assertTrue(rcv_pkt is not None,
                            "Did not receive packet port " + str(ofport))
                pa_logger.debug("Packet len " + str(len(rcv_pkt)) + " in on "
                            + str(rcv_port))

                self.assertEqual(str(pkt), str(rcv_pkt),
                    'Response packet does not match send packet ' +
                    "on port " + str(ofport))

                #@todo Need UI for enabling response-verification
                if(check_expire):
                    (response, raw) \
                        = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2)
                    self.assertTrue(response is not None,
                                    'Flow removed message not received')

                    req_match = request.match
                    res_match = response.match
                    if(req_match != res_match):
                        self.verifMatchField(req_match, res_match)

                    self.assertEqual(request.cookie, response.cookie,
                        self.matchErrStr('cookie'))
                    if (wildcards != 0):
                        self.assertEqual(request.priority, response.priority,
                            self.matchErrStr('priority'))
                    self.assertEqual(response.reason, ofp.OFPRR_HARD_TIMEOUT,
                        'Reason is not HARD TIMEOUT')
                    self.assertEqual(response.packet_count, 1,
                        'Packet count is not correct')
                    self.assertEqual(response.byte_count, len(pkt),
                        'Packet length is not correct')

    def verifMatchField(self, req_match, res_match):
        self.assertEqual(str(req_match.wildcards), str(res_match.wildcards),
            self.matchErrStr('wildcards'))
        self.assertEqual(str(req_match.in_port), str(res_match.in_port),
            self.matchErrStr('in_port'))
        self.assertEqual(str(req_match.dl_src), str(res_match.dl_src),
            self.matchErrStr('dl_src'))
        self.assertEqual(str(req_match.dl_dst), str(res_match.dl_dst),
            self.matchErrStr('dl_dst'))
        self.assertEqual(str(req_match.dl_vlan), str(res_match.dl_vlan),
            self.matchErrStr('dl_vlan'))
        self.assertEqual(str(req_match.dl_vlan_pcp), str(res_match.dl_vlan_pcp),
            self.matchErrStr('dl_vlan_pcp'))
        self.assertEqual(str(req_match.dl_type), str(res_match.dl_type),
            self.matchErrStr('dl_type'))
        if(not(req_match.wildcards & ofp.OFPFW_DL_TYPE)
           and (req_match.dl_type == self.IP_ETHERTYPE)):
            self.assertEqual(str(req_match.nw_tos), str(res_match.nw_tos),
                self.matchErrStr('nw_tos'))
            self.assertEqual(str(req_match.nw_proto), str(res_match.nw_proto),
                self.matchErrStr('nw_proto'))
            self.assertEqual(str(req_match.nw_src), str(res_match.nw_src),
                self.matchErrStr('nw_src'))
            self.assertEqual(str(req_match.nw_dst), str(res_match.nw_dst),
                self.matchErrStr('nw_dst'))
            if(not(req_match.wildcards & ofp.OFPFW_NW_PROTO)
               and ((req_match.nw_proto == self.TCP_PROTOCOL)
                    or (req_match.nw_proto == self.UDP_PROTOCOL))):
                self.assertEqual(str(req_match.tp_src), str(res_match.tp_src),
                    self.matchErrStr('tp_src'))
                self.assertEqual(str(req_match.tp_dst), str(res_match.tp_dst),
                    self.matchErrStr('tp_dst'))

    def matchErrStr(self, field):
        return ('Response Match_' + field + ' does not match send message')

class SingleWildcardMatch(SimpleExactMatch):
    """
    Exercise wildcard matching for all ports

    Generate a packet
    Generate and install a matching flow with wildcard mask
    Add action to forward to a port
    Send the packet to the port
    Verify the packet is received at all other ports (one port at a time)
    Verify flow_expiration message is correct when command option is set
    """
    def __init__(self):
        SimpleExactMatch.__init__(self)
        self.wildcards = [ofp.OFPFW_IN_PORT,
                          ofp.OFPFW_DL_VLAN,
                          ofp.OFPFW_DL_SRC,
                          ofp.OFPFW_DL_DST,
                          ofp.OFPFW_DL_TYPE,
                          ofp.OFPFW_NW_PROTO,
                          ofp.OFPFW_TP_SRC,
                          ofp.OFPFW_TP_DST,
                          0x3F << ofp.OFPFW_NW_SRC_SHIFT,
                          0x3F << ofp.OFPFW_NW_DST_SHIFT,
                          ofp.OFPFW_DL_VLAN_PCP,
                          ofp.OFPFW_NW_TOS]

    def runTest(self):
        for exec_wildcard in range(len(self.wildcards)):
            self.flowMatchTest(exec_wildcard)

class AllExceptOneWildcardMatch(SingleWildcardMatch):
    """
    Create All-execpt-one-field wildcard and exercise for all ports

    Generate a packet
    Generate and install a matching flow with wildcard all except one filed
    Add action to forward to a port
    Send the packet to the port
    Verify the packet is received at all other ports (one port at a time)
    Verify flow_expiration message is correct when command option is set
    """
    def runTest(self):
        for exec_wildcard in range(len(self.wildcards)):
            all_exp_one_wildcard = ofp.OFPFW_ALL ^ self.wildcards[exec_wildcard]
            self.flowMatchTest(all_exp_one_wildcard)

class AllWildcardMatch(SingleWildcardMatch):
    """
    Create Wildcard-all flow and exercise for all ports

    Generate a packet
    Generate and install a matching flow with wildcard-all
    Add action to forward to a port
    Send the packet to the port
    Verify the packet is received at all other ports (one port at a time)
    Verify flow_expiration message is correct when command option is set
    """
    def runTest(self):
        self.flowMatchTest(ofp.OFPFW_ALL)