def receive_pkt_check(dp, pkt, yes_ports, no_ports, assert_if, logger,
config):
"""
Check for proper receive packets across all ports
@param dp The dataplane object
@param pkt Expected packet; may be None if yes_ports is empty
@param yes_ports Set or list of ports that should recieve packet
@param no_ports Set or list of ports that should not receive packet
@param assert_if Object that implements assertXXX
"""
exp_pkt_arg = None
if config and config["relax"]:
exp_pkt_arg = pkt
for ofport in yes_ports:
logger.debug("Checking for pkt on port " + str(ofport))
(rcv_port, rcv_pkt, pkt_time) = dp.poll(
port_number=ofport, timeout=1, exp_pkt=exp_pkt_arg)
assert_if.assertTrue(rcv_pkt is not None,
"Did not receive pkt on " + str(ofport))
if not dataplane.match_exp_pkt(pkt, rcv_pkt):
logger.debug("Sent %s" % format_packet(pkt))
logger.debug("Resp %s" % format_packet(rcv_pkt))
assert_if.assertTrue(dataplane.match_exp_pkt(pkt, rcv_pkt),
"Response packet does not match send packet " +
"on port " + str(ofport))
for ofport in no_ports:
logger.debug("Negative check for pkt on port " + str(ofport))
(rcv_port, rcv_pkt, pkt_time) = dp.poll(
port_number=ofport, timeout=1, exp_pkt=exp_pkt_arg)
assert_if.assertTrue(rcv_pkt is None,
"Unexpected pkt on port " + str(ofport))
def receive_pkt_check(dp, pkt, yes_ports, no_ports, assert_if):
"""
Check for proper receive packets across all ports
@param dp The dataplane object
@param pkt Expected packet; may be None if yes_ports is empty
@param yes_ports Set or list of ports that should recieve packet
@param no_ports Set or list of ports that should not receive packet
@param assert_if Object that implements assertXXX
"""
exp_pkt_arg = None
if config["relax"]:
exp_pkt_arg = pkt
for ofport in yes_ports:
logging.debug("Checking for pkt on port " + str(ofport))
(rcv_port, rcv_pkt, pkt_time) = dp.poll(port_number=ofport,
exp_pkt=exp_pkt_arg)
assert_if.assertTrue(rcv_pkt is not None,
"Did not receive pkt on " + str(ofport))
if not dataplane.match_exp_pkt(pkt, rcv_pkt):
logging.debug("Sent %s" % format_packet(pkt))
logging.debug("Resp %s" % format_packet(rcv_pkt))
assert_if.assertTrue(
dataplane.match_exp_pkt(pkt, rcv_pkt),
"Response packet does not match send packet " + "on port " +
str(ofport))
if len(no_ports) > 0:
time.sleep(1)
for ofport in no_ports:
logging.debug("Negative check for pkt on port " + str(ofport))
(rcv_port, rcv_pkt, pkt_time) = dp.poll(port_number=ofport,
timeout=1,
exp_pkt=exp_pkt_arg)
assert_if.assertTrue(rcv_pkt is None,
"Unexpected pkt on port " + str(ofport))
def runTest(self):
# Construct packet to send to dataplane
# Send packet to dataplane, once to each port
# Poll controller with expect message type packet in
rc = delete_all_flows(self.controller, basic_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
vid = test_param_get(self.config, 'vid', default=TEST_VID_DEFAULT)
for of_port in basic_port_map.keys():
for pkt, pt in [
(simple_tcp_packet(), "simple TCP packet"),
(simple_tcp_packet(dl_vlan_enable=True,
dl_vlan=vid,
pktlen=108), "simple tagged TCP packet"),
(simple_eth_packet(), "simple Ethernet packet"),
(simple_eth_packet(pktlen=40), "tiny Ethernet packet")
]:
basic_logger.info("PKT IN test with %s, port %s" %
(pt, of_port))
self.dataplane.send(of_port, str(pkt))
#@todo Check for unexpected messages?
count = 0
while True:
(response,
raw) = self.controller.poll(ofp.OFPT_PACKET_IN, 2)
if not response: # Timeout
break
if dataplane.match_exp_pkt(pkt,
response.data): # Got match
break
if not basic_config["relax"]: # Only one attempt to match
break
count += 1
if count > 10: # Too many tries
break
self.assertTrue(
response is not None,
'Packet in message not received on port ' + str(of_port))
if not dataplane.match_exp_pkt(pkt, response.data):
basic_logger.debug("Sent %s" % format_packet(pkt))
basic_logger.debug("Resp %s" %
format_packet(response.data))
self.assertTrue(
False, 'Response packet does not match send packet' +
' for port ' + str(of_port))
def runTest(self):
logging = get_logger()
logging.info("Running Grp20No70 Packet_Out test")
of_ports = config["port_map"].keys()
of_ports.sort()
#Clear Switch state
rc = delete_all_flows(self.controller)
self.assertEqual(rc, 0, "Failed to delete all flows")
logging.info("Sending a packet-out for each dataplane port")
logging.info("Expecting the packet on appropriate dataplane port")
for dp_port in of_ports:
for outpkt, opt in [
(simple_tcp_packet(), "simple TCP packet"),
(simple_eth_packet(), "simple Ethernet packet"),
(simple_eth_packet(pktlen=40), "tiny Ethernet packet")]:
msg = message.packet_out()
msg.in_port = ofp.OFPP_NONE
msg.data = str(outpkt)
act = action.action_output()
act.port = dp_port
self.assertTrue(msg.actions.add(act), 'Could not add action to msg')
logging.info("PacketOut to: port " + str(dp_port))
rv =self.controller.message_send(msg)
self.assertTrue(rv == 0, "Error sending out message")
error, _= self.controller.poll(exp_msg=ofp.OFPT_ERROR)
if error:
msg.in_port = ofp.OFPP_CONTROLLER
self.controller.message_send(msg)
error, _ =self.controller.poll(exp_msg=ofp.OFPT_ERROR)
self.assertIsNone(error, "Could Not send packet out message.got OFPT_ERROR")
logging.info("Packet out with in_port OFPP.CONTROLLER")
exp_pkt_arg = None
exp_port = None
if config["relax"]:
exp_pkt_arg = outpkt
exp_port = dp_port
(of_port, pkt, pkt_time) = self.dataplane.poll(timeout=2,
port_number=exp_port,
exp_pkt=exp_pkt_arg)
self.assertTrue(pkt is not None, 'Packet not received on the dataplane port')
logging.info("PacketOut: got %s pkt on port " % opt + str(of_port))
if of_port is not None:
self.assertEqual(of_port, dp_port, "Unexpected receive port")
if not dataplane.match_exp_pkt(outpkt, pkt):
logging.debug("Sent %s" % format_packet(outpkt))
logging.debug("Resp %s" % format_packet(
str(pkt)[:len(str(outpkt))]))
self.assertEqual(str(outpkt), str(pkt)[:len(str(outpkt))],
'Response packet does not match send packet')
def runTest(self):
# Construct packet to send to dataplane
# Send packet to dataplane, once to each port
# Poll controller with expect message type packet in
rc = delete_all_flows(self.controller, basic_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
vid = test_param_get(self.config, 'vid', default=TEST_VID_DEFAULT)
for of_port in basic_port_map.keys():
for pkt, pt in [
(simple_tcp_packet(), "simple TCP packet"),
(simple_tcp_packet(dl_vlan_enable=True,dl_vlan=vid,pktlen=108),
"simple tagged TCP packet"),
(simple_eth_packet(), "simple Ethernet packet"),
(simple_eth_packet(pktlen=40), "tiny Ethernet packet")]:
basic_logger.info("PKT IN test with %s, port %s" % (pt, of_port))
self.dataplane.send(of_port, str(pkt))
#@todo Check for unexpected messages?
count = 0
while True:
(response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN, 2)
if not response: # Timeout
break
if dataplane.match_exp_pkt(pkt, response.data): # Got match
break
if not basic_config["relax"]: # Only one attempt to match
break
count += 1
if count > 10: # Too many tries
break
self.assertTrue(response is not None,
'Packet in message not received on port ' +
str(of_port))
if not dataplane.match_exp_pkt(pkt, response.data):
basic_logger.debug("Sent %s" % format_packet(pkt))
basic_logger.debug("Resp %s" % format_packet(response.data))
self.assertTrue(False,
'Response packet does not match send packet' +
' for port ' + str(of_port))
def runTest(self):
# Construct packet to send to dataplane
# Send packet to dataplane
# Poll controller with expect message type packet in
rc = delete_all_flows(self.controller, basic_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
# These will get put into function
of_ports = basic_port_map.keys()
of_ports.sort()
for dp_port in of_ports:
for outpkt, opt in [
(simple_tcp_packet(), "simple TCP packet"),
(simple_eth_packet(), "simple Ethernet packet"),
(simple_eth_packet(pktlen=40), "tiny Ethernet packet")
]:
basic_logger.info("PKT OUT test with %s, port %s" %
(opt, dp_port))
msg = message.packet_out()
msg.data = str(outpkt)
act = action.action_output()
act.port = dp_port
self.assertTrue(msg.actions.add(act),
'Could not add action to msg')
basic_logger.info("PacketOut to: " + str(dp_port))
rv = self.controller.message_send(msg)
self.assertTrue(rv == 0, "Error sending out message")
exp_pkt_arg = None
exp_port = None
if basic_config["relax"]:
exp_pkt_arg = outpkt
exp_port = dp_port
(of_port, pkt,
pkt_time) = self.dataplane.poll(port_number=exp_port,
exp_pkt=exp_pkt_arg)
self.assertTrue(pkt is not None, 'Packet not received')
basic_logger.info("PacketOut: got pkt from " + str(of_port))
if of_port is not None:
self.assertEqual(of_port, dp_port,
"Unexpected receive port")
if not dataplane.match_exp_pkt(outpkt, pkt):
basic_logger.debug("Sent %s" % format_packet(outpkt))
basic_logger.debug(
"Resp %s" % format_packet(str(pkt)[:len(str(outpkt))]))
self.assertEqual(str(outpkt),
str(pkt)[:len(str(outpkt))],
'Response packet does not match send packet')
def runTest(self):
logging.info("Running Packet_Out test")
of_ports = config["port_map"].keys()
of_ports.sort()
#Clear Switch state
delete_all_flows(self.controller)
logging.info("Sending a packet-out for each dataplane port")
logging.info("Expecting the packet on appropriate dataplane port")
for dp_port in of_ports:
for outpkt, opt in [
(simple_tcp_packet(), "simple TCP packet"),
(simple_eth_packet(), "simple Ethernet packet"),
(simple_eth_packet(pktlen=40), "tiny Ethernet packet")
]:
msg = ofp.message.packet_out()
msg.data = str(outpkt)
act = ofp.action.output()
act.port = dp_port
msg.actions.append(act)
msg.buffer_id = 0xffffffff
logging.info("PacketOut to: " + str(dp_port))
self.controller.message_send(msg)
exp_pkt_arg = None
exp_port = None
if config["relax"]:
exp_pkt_arg = outpkt
exp_port = dp_port
(of_port, pkt,
pkt_time) = self.dataplane.poll(timeout=2,
port_number=exp_port,
exp_pkt=exp_pkt_arg)
self.assertTrue(pkt is not None, 'Packet not received')
logging.info("PacketOut: got pkt from " + str(of_port))
if of_port is not None:
self.assertEqual(of_port, dp_port,
"Unexpected receive port")
if not dataplane.match_exp_pkt(outpkt, pkt):
logging.debug("Sent %s" % format_packet(outpkt))
logging.debug("Resp %s" %
format_packet(str(pkt)[:len(str(outpkt))]))
self.assertEqual(str(outpkt),
str(pkt)[:len(str(outpkt))],
'Response packet does not match send packet')
def receive_pkt_check(dp, pkt, yes_ports, no_ports, assert_if):
"""
Check for proper receive packets across all ports
@param dp The dataplane object
@param pkt Expected packet; may be None if yes_ports is empty
@param yes_ports Set or list of ports that should recieve packet
@param no_ports Set or list of ports that should not receive packet
@param assert_if Object that implements assertXXX
"""
# Wait this long for packets that we don't expect to receive.
# 100ms is (rarely) too short for positive tests on slow
# switches but is definitely not too short for a negative test.
negative_timeout = 0.1
exp_pkt_arg = None
if config["relax"]:
exp_pkt_arg = pkt
for ofport in yes_ports:
logging.debug("Checking for pkt on port " + str(ofport))
(rcv_port, rcv_pkt, pkt_time) = dp.poll(
port_number=ofport, exp_pkt=exp_pkt_arg)
assert_if.assertTrue(rcv_pkt is not None,
"Did not receive pkt on " + str(ofport))
if not dataplane.match_exp_pkt(pkt, rcv_pkt):
logging.debug("Sent %s" % format_packet(pkt))
logging.debug("Resp %s" % format_packet(rcv_pkt))
assert_if.assertTrue(dataplane.match_exp_pkt(pkt, rcv_pkt),
"Response packet does not match send packet " +
"on port " + str(ofport))
if len(no_ports) > 0:
time.sleep(negative_timeout)
for ofport in no_ports:
logging.debug("Negative check for pkt on port " + str(ofport))
(rcv_port, rcv_pkt, pkt_time) = dp.poll(
port_number=ofport, timeout=0, exp_pkt=exp_pkt_arg)
assert_if.assertTrue(rcv_pkt is None,
"Unexpected pkt on port " + str(ofport))
def runTest(self):
of_logger.info("Running Packet_Out test")
of_ports = of_port_map.keys()
of_ports.sort()
#Clear Switch state
rc = delete_all_flows(self.controller, of_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
of_logger.info("Sending a packet-out for each dataplane port")
of_logger.info("Expecting the packet on appropriate dataplane port")
for dp_port in of_ports:
for outpkt, opt in [
(simple_tcp_packet(), "simple TCP packet"),
(simple_eth_packet(), "simple Ethernet packet"),
(simple_eth_packet(pktlen=40), "tiny Ethernet packet")]:
msg = message.packet_out()
msg.data = str(outpkt)
act = action.action_output()
act.port = dp_port
self.assertTrue(msg.actions.add(act), 'Could not add action to msg')
of_logger.info("PacketOut to: " + str(dp_port))
rv = self.controller.message_send(msg)
self.assertTrue(rv == 0, "Error sending out message")
exp_pkt_arg = None
exp_port = None
if of_config["relax"]:
exp_pkt_arg = outpkt
exp_port = dp_port
(of_port, pkt, pkt_time) = self.dataplane.poll(timeout=2,
port_number=exp_port,
exp_pkt=exp_pkt_arg)
self.assertTrue(pkt is not None, 'Packet not received')
of_logger.info("PacketOut: got pkt from " + str(of_port))
if of_port is not None:
self.assertEqual(of_port, dp_port, "Unexpected receive port")
if not dataplane.match_exp_pkt(outpkt, pkt):
of_logger.debug("Sent %s" % format_packet(outpkt))
of_logger.debug("Resp %s" % format_packet(
str(pkt)[:len(str(outpkt))]))
self.assertEqual(str(outpkt), str(pkt)[:len(str(outpkt))],
'Response packet does not match send packet')
def runTest(self):
# Construct packet to send to dataplane
# Send packet to dataplane
# Poll controller with expect message type packet in
delete_all_flows(self.controller)
# These will get put into function
of_ports = config["port_map"].keys()
of_ports.sort()
for dp_port in of_ports:
for outpkt, opt in [
(simple_tcp_packet(), "simple TCP packet"),
(simple_eth_packet(), "simple Ethernet packet"),
(simple_eth_packet(pktlen=40), "tiny Ethernet packet")
]:
logging.info("PKT OUT test with %s, port %s" % (opt, dp_port))
msg = ofp.message.packet_out(
in_port=ofp.OFPP_NONE,
data=str(outpkt),
actions=[ofp.action.output(port=dp_port)],
buffer_id=0xffffffff)
logging.info("PacketOut to: " + str(dp_port))
self.controller.message_send(msg)
exp_pkt_arg = None
exp_port = None
if config["relax"]:
exp_pkt_arg = outpkt
exp_port = dp_port
(of_port, pkt,
pkt_time) = self.dataplane.poll(port_number=exp_port,
exp_pkt=exp_pkt_arg)
self.assertTrue(pkt is not None, 'Packet not received')
logging.info("PacketOut: got pkt from " + str(of_port))
if of_port is not None:
self.assertEqual(of_port, dp_port,
"Unexpected receive port")
if not dataplane.match_exp_pkt(outpkt, pkt):
logging.debug("Sent %s" % format_packet(outpkt))
logging.debug("Resp %s" %
format_packet(str(pkt)[:len(str(outpkt))]))
self.assertEqual(str(outpkt),
str(pkt)[:len(str(outpkt))],
'Response packet does not match send packet')
def runTest(self):
logging.info("Running Packet_Out test")
of_ports = config["port_map"].keys()
of_ports.sort()
#Clear Switch state
delete_all_flows(self.controller)
logging.info("Sending a packet-out for each dataplane port")
logging.info("Expecting the packet on appropriate dataplane port")
for dp_port in of_ports:
for outpkt, opt in [
(simple_tcp_packet(), "simple TCP packet"),
(simple_eth_packet(), "simple Ethernet packet"),
(simple_eth_packet(pktlen=40), "tiny Ethernet packet")]:
msg = ofp.message.packet_out()
msg.data = str(outpkt)
act = ofp.action.output()
act.port = dp_port
msg.actions.append(act)
msg.buffer_id = 0xffffffff
logging.info("PacketOut to: " + str(dp_port))
self.controller.message_send(msg)
exp_pkt_arg = None
exp_port = None
if config["relax"]:
exp_pkt_arg = outpkt
exp_port = dp_port
(of_port, pkt, pkt_time) = self.dataplane.poll(timeout=2,
port_number=exp_port,
exp_pkt=exp_pkt_arg)
self.assertTrue(pkt is not None, 'Packet not received')
logging.info("PacketOut: got pkt from " + str(of_port))
if of_port is not None:
self.assertEqual(of_port, dp_port, "Unexpected receive port")
if not dataplane.match_exp_pkt(outpkt, pkt):
logging.debug("Sent %s" % format_packet(outpkt))
logging.debug("Resp %s" % format_packet(
str(pkt)[:len(str(outpkt))]))
self.assertEqual(str(outpkt), str(pkt)[:len(str(outpkt))],
'Response packet does not match send packet')
def runTest(self):
# Construct packet to send to dataplane
# Send packet to dataplane
# Poll controller with expect message type packet in
rc = delete_all_flows(self.controller)
self.assertEqual(rc, 0, "Failed to delete all flows")
# These will get put into function
of_ports = config["port_map"].keys()
of_ports.sort()
for dp_port in of_ports:
for outpkt, opt in [
(simple_tcp_packet(), "simple TCP packet"),
(simple_eth_packet(), "simple Ethernet packet"),
(simple_eth_packet(pktlen=40), "tiny Ethernet packet")]:
logging.info("PKT OUT test with %s, port %s" % (opt, dp_port))
msg = message.packet_out()
msg.in_port = ofp.OFPP_NONE
msg.data = str(outpkt)
act = action.action_output()
act.port = dp_port
self.assertTrue(msg.actions.add(act), 'Could not add action to msg')
logging.info("PacketOut to: " + str(dp_port))
rv = self.controller.message_send(msg)
self.assertTrue(rv == 0, "Error sending out message")
exp_pkt_arg = None
exp_port = None
if config["relax"]:
exp_pkt_arg = outpkt
exp_port = dp_port
(of_port, pkt, pkt_time) = self.dataplane.poll(port_number=exp_port,
exp_pkt=exp_pkt_arg)
self.assertTrue(pkt is not None, 'Packet not received')
logging.info("PacketOut: got pkt from " + str(of_port))
if of_port is not None:
self.assertEqual(of_port, dp_port, "Unexpected receive port")
if not dataplane.match_exp_pkt(outpkt, pkt):
logging.debug("Sent %s" % format_packet(outpkt))
logging.debug("Resp %s" % format_packet(
str(pkt)[:len(str(outpkt))]))
self.assertEqual(str(outpkt), str(pkt)[:len(str(outpkt))],
'Response packet does not match send packet')
def runTest(self):
delete_all_flows(self.controller)
do_barrier(self.controller)
for of_port in config["port_map"].keys():
pkt = simple_tcp_packet()
self.dataplane.send(of_port, str(pkt))
count = 0
while True:
(response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN)
if not response: # Timeout
break
if dataplane.match_exp_pkt(pkt, response.data): # Got match
break
if not config["relax"]: # Only one attempt to match
break
count += 1
if count > 10: # Too many tries
break
self.assertTrue(response is None,
'Packet in message received on port ' +
str(of_port))
def runTest(self):
delete_all_flows(self.controller)
do_barrier(self.controller)
for of_port in config["port_map"].keys():
pkt = simple_tcp_packet()
self.dataplane.send(of_port, str(pkt))
count = 0
while True:
(response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN)
if not response: # Timeout
break
if dataplane.match_exp_pkt(pkt, response.data): # Got match
break
if not config["relax"]: # Only one attempt to match
break
count += 1
if count > 10: # Too many tries
break
self.assertTrue(
response is None,
'Packet in message received on port ' + str(of_port))
def runTest(self):
rc = delete_all_flows(self.controller, basic_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
for of_port in basic_port_map.keys():
pkt = simple_tcp_packet()
self.dataplane.send(of_port, str(pkt))
count = 0
while True:
(response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN, 2)
if not response: # Timeout
break
if dataplane.match_exp_pkt(pkt, response.data): # Got match
break
if not basic_config["relax"]: # Only one attempt to match
break
count += 1
if count > 10: # Too many tries
break
self.assertTrue(
response is None,
'Packet in message received on port ' + str(of_port))
def runTest(self):
rc = delete_all_flows(self.controller, basic_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
for of_port in basic_port_map.keys():
pkt = simple_tcp_packet()
self.dataplane.send(of_port, str(pkt))
count = 0
while True:
(response, raw) = self.controller.poll(ofp.OFPT_PACKET_IN, 2)
if not response: # Timeout
break
if dataplane.match_exp_pkt(pkt, response.data): # Got match
break
if not basic_config["relax"]: # Only one attempt to match
break
count += 1
if count > 10: # Too many tries
break
self.assertTrue(response is None,
'Packet in message received on port ' +
str(of_port))
def runTest(self):
logging = get_logger()
logging.info("Running Grp20No70 Packet_Out test")
of_ports = config["port_map"].keys()
of_ports.sort()
#Clear Switch state
rc = delete_all_flows(self.controller)
self.assertEqual(rc, 0, "Failed to delete all flows")
logging.info("Sending a packet-out for each dataplane port")
logging.info("Expecting the packet on appropriate dataplane port")
for dp_port in of_ports:
for outpkt, opt in [
(simple_tcp_packet(), "simple TCP packet"),
(simple_eth_packet(), "simple Ethernet packet"),
(simple_eth_packet(pktlen=40), "tiny Ethernet packet")
]:
msg = message.packet_out()
msg.in_port = ofp.OFPP_NONE
msg.data = str(outpkt)
act = action.action_output()
act.port = dp_port
self.assertTrue(msg.actions.add(act),
'Could not add action to msg')
logging.info("PacketOut to: port " + str(dp_port))
rv = self.controller.message_send(msg)
self.assertTrue(rv == 0, "Error sending out message")
error, _ = self.controller.poll(exp_msg=ofp.OFPT_ERROR)
if error:
msg.in_port = ofp.OFPP_CONTROLLER
self.controller.message_send(msg)
error, _ = self.controller.poll(exp_msg=ofp.OFPT_ERROR)
self.assertIsNone(
error,
"Could Not send packet out message.got OFPT_ERROR")
logging.info("Packet out with in_port OFPP.CONTROLLER")
exp_pkt_arg = None
exp_port = None
if config["relax"]:
exp_pkt_arg = outpkt
exp_port = dp_port
(of_port, pkt,
pkt_time) = self.dataplane.poll(timeout=2,
port_number=exp_port,
exp_pkt=exp_pkt_arg)
self.assertTrue(pkt is not None,
'Packet not received on the dataplane port')
logging.info("PacketOut: got %s pkt on port " % opt +
str(of_port))
if of_port is not None:
self.assertEqual(of_port, dp_port,
"Unexpected receive port")
if not dataplane.match_exp_pkt(outpkt, pkt):
logging.debug("Sent %s" % format_packet(outpkt))
logging.debug("Resp %s" %
format_packet(str(pkt)[:len(str(outpkt))]))
self.assertEqual(str(outpkt),
str(pkt)[:len(str(outpkt))],
'Response packet does not match send packet')