--- /dev/null
+# Copyright (C) 2012 Nippon Telegraph and Telephone Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+import unittest
+import logging
+import six
+import socket
+from struct import *
+from nose.tools import *
+from ryu.ofproto.ofproto_v1_2_parser import *
+from ryu.ofproto import ofproto_v1_2_parser
+from ryu.ofproto import ofproto_v1_2
+from ryu.ofproto import ofproto_protocol
+from ryu.ofproto import ether
+from ryu.ofproto.ofproto_parser import MsgBase
+from ryu import utils
+from ryu.lib import addrconv
+from ryu.lib import pack_utils
+
+LOG = logging.getLogger('test_ofproto_v12')
+
+
+_Datapath = ofproto_protocol.ProtocolDesc(version=ofproto_v1_2.OFP_VERSION)
+
+
+class TestRegisterParser(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser._register_parser
+ """
+
+ class _OFPDummy(MsgBase):
+ def __init__(self, datapath):
+ self.dummy = 'dummy'
+
+ def parser(self):
+ return self.dummy
+
+ def test_cls_msg_type(self):
+ msg_type = 0xff
+ cls = self._OFPDummy(_Datapath)
+ cls.cls_msg_type = msg_type
+
+ res = ofproto_v1_2_parser._register_parser(cls)
+ res_parser = ofproto_v1_2_parser._MSG_PARSERS[msg_type]
+ del ofproto_v1_2_parser._MSG_PARSERS[msg_type]
+
+ eq_(res.cls_msg_type, msg_type)
+ ok_(res.dummy)
+ eq_(res_parser(), 'dummy')
+
+ @raises(AssertionError)
+ def test_cls_msg_type_none(self):
+ cls = OFPHello(_Datapath)
+ cls.cls_msg_type = None
+ ofproto_v1_2_parser._register_parser(cls)
+
+ @raises(AssertionError)
+ def test_cls_msg_type_already_registed(self):
+ cls = OFPHello(_Datapath)
+ ofproto_v1_2_parser._register_parser(cls)
+
+
+class TestMsgParser(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.msg_parser
+ """
+
+ def _test_msg_parser(self, xid, msg_len):
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_HELLO
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ c = msg_parser(_Datapath, version, msg_type, msg_len, xid, buf)
+
+ eq_(version, c.version)
+ eq_(msg_type, c.msg_type)
+ eq_(msg_len, c.msg_len)
+ eq_(xid, c.xid)
+
+ # buf
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ res = struct.unpack(fmt, c.buf)
+
+ eq_(version, res[0])
+ eq_(msg_type, res[1])
+ eq_(msg_len, res[2])
+ eq_(xid, res[3])
+
+ def test_parser_mid(self):
+ xid = 2147483648
+ msg_len = 8
+ self._test_msg_parser(xid, msg_len)
+
+ def test_parser_max(self):
+ xid = 4294967295
+ msg_len = 65535
+ self._test_msg_parser(xid, msg_len)
+
+ def test_parser_min(self):
+ xid = 0
+ msg_len = 0
+ self._test_msg_parser(xid, msg_len)
+
+
+class TestOFPHello(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPHello
+ """
+
+ def _test_parser(self, xid):
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_HELLO
+ msg_len = ofproto.OFP_HEADER_SIZE
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ res = OFPHello.parser(object, version, msg_type, msg_len, xid,
+ bytearray(buf))
+
+ eq_(version, res.version)
+ eq_(msg_type, res.msg_type)
+ eq_(msg_len, res.msg_len)
+ eq_(xid, res.xid)
+ eq_(six.binary_type(buf), six.binary_type(res.buf))
+
+ def test_parser_xid_min(self):
+ xid = 0
+ self._test_parser(xid)
+
+ def test_parser_xid_mid(self):
+ xid = 2183948390
+ self._test_parser(xid)
+
+ def test_parser_xid_max(self):
+ xid = 4294967295
+ self._test_parser(xid)
+
+ def test_serialize(self):
+ c = OFPHello(_Datapath)
+ c.serialize()
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_HELLO, c.msg_type)
+ eq_(0, c.xid)
+
+
+class TestOFPErrorMsg(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPErrorMsg
+ """
+
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_ERROR
+ msg_len = ofproto.OFP_ERROR_MSG_SIZE
+ xid = 2495926989
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ def test_init(self):
+ c = OFPErrorMsg(_Datapath)
+ eq_(c.code, None)
+ eq_(c.type, None)
+ eq_(c.data, None)
+
+ def _test_parser(self, type_, code, data=None):
+
+ # OFP_ERROR_MSG_PACK_STR = '!HH'
+ fmt = ofproto.OFP_ERROR_MSG_PACK_STR
+ buf = self.buf + pack(fmt, type_, code)
+
+ if data is not None:
+ buf += data
+
+ res = OFPErrorMsg.parser(object, self.version, self.msg_type,
+ self.msg_len, self.xid, buf)
+
+ eq_(res.version, self.version)
+ eq_(res.msg_type, self.msg_type)
+ eq_(res.msg_len, self.msg_len)
+ eq_(res.xid, self.xid)
+ eq_(res.type, type_)
+ eq_(res.code, code)
+
+ if data is not None:
+ eq_(res.data, data)
+
+ def test_parser_mid(self):
+ type_ = 32768
+ code = 32768
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_max(self):
+ type_ = 65534
+ code = 65535
+ data = b'Error Message.'.ljust(65523)
+ self._test_parser(type_, code, data)
+
+ def test_parser_min(self):
+ type_ = 0
+ code = 0
+ data = None
+ self._test_parser(type_, code, data)
+
+ def test_parser_p0_1(self):
+ type_ = ofproto.OFPET_HELLO_FAILED
+ code = ofproto.OFPHFC_EPERM
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_0(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_BAD_VERSION
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_1(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_BAD_TYPE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_2(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_BAD_STAT
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_3(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_BAD_EXPERIMENTER
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_4(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_BAD_EXP_TYPE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_5(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_EPERM
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_6(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_BAD_LEN
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_7(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_BUFFER_EMPTY
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_8(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_BUFFER_UNKNOWN
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_9(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_BAD_TABLE_ID
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_10(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_IS_SLAVE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_11(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_BAD_PORT
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p1_12(self):
+ type_ = ofproto.OFPET_BAD_REQUEST
+ code = ofproto.OFPBRC_BAD_PACKET
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_0(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_BAD_TYPE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_1(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_BAD_LEN
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_2(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_BAD_EXPERIMENTER
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_3(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_BAD_EXP_TYPE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_4(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_BAD_OUT_PORT
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_5(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_BAD_ARGUMENT
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_6(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_EPERM
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_7(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_TOO_MANY
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_8(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_BAD_QUEUE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_9(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_BAD_OUT_GROUP
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_10(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_MATCH_INCONSISTENT
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_11(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_UNSUPPORTED_ORDER
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_12(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_BAD_TAG
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_13(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_BAD_SET_TYPE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_14(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_BAD_SET_LEN
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p2_15(self):
+ type_ = ofproto.OFPET_BAD_ACTION
+ code = ofproto.OFPBAC_BAD_SET_ARGUMENT
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p3_0(self):
+ type_ = ofproto.OFPET_BAD_INSTRUCTION
+ code = ofproto.OFPBIC_UNKNOWN_INST
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p3_1(self):
+ type_ = ofproto.OFPET_BAD_INSTRUCTION
+ code = ofproto.OFPBIC_UNSUP_INST
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p3_2(self):
+ type_ = ofproto.OFPET_BAD_INSTRUCTION
+ code = ofproto.OFPBIC_BAD_TABLE_ID
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p3_3(self):
+ type_ = ofproto.OFPET_BAD_INSTRUCTION
+ code = ofproto.OFPBIC_UNSUP_METADATA
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p3_4(self):
+ type_ = ofproto.OFPET_BAD_INSTRUCTION
+ code = ofproto.OFPBIC_UNSUP_METADATA_MASK
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p3_5(self):
+ type_ = ofproto.OFPET_BAD_INSTRUCTION
+ code = ofproto.OFPBIC_BAD_EXPERIMENTER
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p3_6(self):
+ type_ = ofproto.OFPET_BAD_INSTRUCTION
+ code = ofproto.OFPBIC_BAD_EXP_TYPE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p3_7(self):
+ type_ = ofproto.OFPET_BAD_INSTRUCTION
+ code = ofproto.OFPBIC_BAD_LEN
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p3_8(self):
+ type_ = ofproto.OFPET_BAD_INSTRUCTION
+ code = ofproto.OFPBIC_EPERM
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p4_0(self):
+ type_ = ofproto.OFPET_BAD_MATCH
+ code = ofproto.OFPBMC_BAD_TYPE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p4_1(self):
+ type_ = ofproto.OFPET_BAD_MATCH
+ code = ofproto.OFPBMC_BAD_LEN
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p4_2(self):
+ type_ = ofproto.OFPET_BAD_MATCH
+ code = ofproto.OFPBMC_BAD_TAG
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p4_3(self):
+ type_ = ofproto.OFPET_BAD_MATCH
+ code = ofproto.OFPBMC_BAD_DL_ADDR_MASK
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p4_4(self):
+ type_ = ofproto.OFPET_BAD_MATCH
+ code = ofproto.OFPBMC_BAD_NW_ADDR_MASK
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p4_5(self):
+ type_ = ofproto.OFPET_BAD_MATCH
+ code = ofproto.OFPBMC_BAD_WILDCARDS
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p4_6(self):
+ type_ = ofproto.OFPET_BAD_MATCH
+ code = ofproto.OFPBMC_BAD_FIELD
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p4_7(self):
+ type_ = ofproto.OFPET_BAD_MATCH
+ code = ofproto.OFPBMC_BAD_VALUE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p4_8(self):
+ type_ = ofproto.OFPET_BAD_MATCH
+ code = ofproto.OFPBMC_BAD_MASK
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p4_9(self):
+ type_ = ofproto.OFPET_BAD_MATCH
+ code = ofproto.OFPBMC_BAD_PREREQ
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p4_10(self):
+ type_ = ofproto.OFPET_BAD_MATCH
+ code = ofproto.OFPBMC_DUP_FIELD
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p4_11(self):
+ type_ = ofproto.OFPET_BAD_MATCH
+ code = ofproto.OFPBMC_EPERM
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p5_0(self):
+ type_ = ofproto.OFPET_FLOW_MOD_FAILED
+ code = ofproto.OFPFMFC_UNKNOWN
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p5_1(self):
+ type_ = ofproto.OFPET_FLOW_MOD_FAILED
+ code = ofproto.OFPFMFC_TABLE_FULL
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p5_2(self):
+ type_ = ofproto.OFPET_FLOW_MOD_FAILED
+ code = ofproto.OFPFMFC_BAD_TABLE_ID
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p5_3(self):
+ type_ = ofproto.OFPET_FLOW_MOD_FAILED
+ code = ofproto.OFPFMFC_OVERLAP
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p5_4(self):
+ type_ = ofproto.OFPET_FLOW_MOD_FAILED
+ code = ofproto.OFPFMFC_EPERM
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p5_5(self):
+ type_ = ofproto.OFPET_FLOW_MOD_FAILED
+ code = ofproto.OFPFMFC_BAD_TIMEOUT
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p5_6(self):
+ type_ = ofproto.OFPET_FLOW_MOD_FAILED
+ code = ofproto.OFPFMFC_BAD_COMMAND
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p5_7(self):
+ type_ = ofproto.OFPET_FLOW_MOD_FAILED
+ code = ofproto.OFPFMFC_BAD_FLAGS
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_0(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_GROUP_EXISTS
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_1(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_INVALID_GROUP
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_2(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_WEIGHT_UNSUPPORTED
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_3(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_OUT_OF_GROUPS
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_4(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_OUT_OF_BUCKETS
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_5(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_CHAINING_UNSUPPORTED
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_6(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_WATCH_UNSUPPORTED
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_7(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_LOOP
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_8(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_UNKNOWN_GROUP
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_9(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_CHAINED_GROUP
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_10(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_BAD_TYPE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_11(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_BAD_COMMAND
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_12(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_BAD_BUCKET
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_13(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_BAD_WATCH
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p6_14(self):
+ type_ = ofproto.OFPET_GROUP_MOD_FAILED
+ code = ofproto.OFPGMFC_EPERM
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p7_0(self):
+ type_ = ofproto.OFPET_PORT_MOD_FAILED
+ code = ofproto.OFPPMFC_BAD_PORT
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p7_1(self):
+ type_ = ofproto.OFPET_PORT_MOD_FAILED
+ code = ofproto.OFPPMFC_BAD_HW_ADDR
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p7_2(self):
+ type_ = ofproto.OFPET_PORT_MOD_FAILED
+ code = ofproto.OFPPMFC_BAD_CONFIG
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p7_3(self):
+ type_ = ofproto.OFPET_PORT_MOD_FAILED
+ code = ofproto.OFPPMFC_BAD_ADVERTISE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p7_4(self):
+ type_ = ofproto.OFPET_PORT_MOD_FAILED
+ code = ofproto.OFPPMFC_EPERM
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p8_0(self):
+ type_ = ofproto.OFPET_TABLE_MOD_FAILED
+ code = ofproto.OFPTMFC_BAD_TABLE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p8_1(self):
+ type_ = ofproto.OFPET_TABLE_MOD_FAILED
+ code = ofproto.OFPTMFC_BAD_CONFIG
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p8_2(self):
+ type_ = ofproto.OFPET_TABLE_MOD_FAILED
+ code = ofproto.OFPTMFC_EPERM
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p9_0(self):
+ type_ = ofproto.OFPET_QUEUE_OP_FAILED
+ code = ofproto.OFPQOFC_BAD_PORT
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p9_1(self):
+ type_ = ofproto.OFPET_QUEUE_OP_FAILED
+ code = ofproto.OFPQOFC_BAD_QUEUE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p9_2(self):
+ type_ = ofproto.OFPET_QUEUE_OP_FAILED
+ code = ofproto.OFPQOFC_EPERM
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p10_0(self):
+ type_ = ofproto.OFPET_SWITCH_CONFIG_FAILED
+ code = ofproto.OFPSCFC_BAD_FLAGS
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p10_1(self):
+ type_ = ofproto.OFPET_SWITCH_CONFIG_FAILED
+ code = ofproto.OFPSCFC_BAD_LEN
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p10_2(self):
+ type_ = ofproto.OFPET_SWITCH_CONFIG_FAILED
+ code = ofproto.OFPSCFC_EPERM
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p11_0(self):
+ type_ = ofproto.OFPET_ROLE_REQUEST_FAILED
+ code = ofproto.OFPRRFC_STALE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p11_1(self):
+ type_ = ofproto.OFPET_ROLE_REQUEST_FAILED
+ code = ofproto.OFPRRFC_UNSUP
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_p11_2(self):
+ type_ = ofproto.OFPET_ROLE_REQUEST_FAILED
+ code = ofproto.OFPRRFC_BAD_ROLE
+ data = b'Error Message.'
+ self._test_parser(type_, code, data)
+
+ def test_parser_experimenter(self):
+ type_ = 0xffff
+ exp_type = 1
+ experimenter = 1
+ data = b'Error Experimenter Message.'
+
+ # OFP_ERROR_EXPERIMENTER_MSG_PACK_STR = '!HHI'
+ fmt = ofproto.OFP_ERROR_EXPERIMENTER_MSG_PACK_STR
+ buf = self.buf + pack(fmt, type_, exp_type, experimenter) \
+ + data
+
+ res = OFPErrorMsg.parser(object, self.version, self.msg_type,
+ self.msg_len, self.xid, buf)
+
+ eq_(res.version, self.version)
+ eq_(res.msg_type, self.msg_type)
+ eq_(res.msg_len, self.msg_len)
+ eq_(res.xid, self.xid)
+ eq_(res.type, type_)
+ eq_(res.exp_type, exp_type)
+ eq_(res.experimenter, experimenter)
+ eq_(res.data, data)
+
+ def _test_serialize(self, type_, code, data):
+ # OFP_ERROR_MSG_PACK_STR = '!HH'
+ fmt = ofproto.OFP_ERROR_MSG_PACK_STR
+ buf = self.buf + pack(fmt, type_, code) + data
+
+ # initialization
+ c = OFPErrorMsg(_Datapath)
+ c.type = type_
+ c.code = code
+ c.data = data
+
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_ERROR, c.msg_type)
+ eq_(0, c.xid)
+ eq_(len(buf), c.msg_len)
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + ofproto.OFP_ERROR_MSG_PACK_STR.replace('!', '') \
+ + str(len(c.data)) + 's'
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_ERROR)
+ eq_(res[2], len(buf))
+ eq_(res[3], 0)
+ eq_(res[4], type_)
+ eq_(res[5], code)
+ eq_(res[6], data)
+
+ def test_serialize_mid(self):
+ type_ = 32768
+ code = 32768
+ data = b'Error Message.'
+ self._test_serialize(type_, code, data)
+
+ def test_serialize_max(self):
+ type_ = 65534 # 65535 collides OFPET_EXPERIMENTER
+ code = 65535
+ data = b'Error Message.'.ljust(65523)
+ self._test_serialize(type_, code, data)
+
+ def test_serialize_min_except_data(self):
+ type_ = ofproto.OFPET_HELLO_FAILED
+ code = ofproto.OFPHFC_INCOMPATIBLE
+ data = b'Error Message.'
+ self._test_serialize(type_, code, data)
+
+ @raises(AssertionError)
+ def test_serialize_check_data(self):
+ c = OFPErrorMsg(_Datapath)
+ c.serialize()
+
+ def _test_serialize_p(self, type_, code):
+ self._test_serialize(type_, code, b'Error Message.')
+
+ def test_serialize_p0_1(self):
+ self._test_serialize_p(ofproto.OFPET_HELLO_FAILED,
+ ofproto.OFPHFC_EPERM)
+
+ def test_serialize_p1_0(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_BAD_VERSION)
+
+ def test_serialize_p1_1(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_BAD_TYPE)
+
+ def test_serialize_p1_2(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_BAD_STAT)
+
+ def test_serialize_p1_3(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_BAD_EXPERIMENTER)
+
+ def test_serialize_p1_4(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_BAD_EXP_TYPE)
+
+ def test_serialize_p1_5(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_EPERM)
+
+ def test_serialize_p1_6(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_BAD_LEN)
+
+ def test_serialize_p1_7(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_BUFFER_EMPTY)
+
+ def test_serialize_p1_8(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_BUFFER_UNKNOWN)
+
+ def test_serialize_p1_9(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_BAD_TABLE_ID)
+
+ def test_serialize_p1_10(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_IS_SLAVE)
+
+ def test_serialize_p1_11(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_BAD_PORT)
+
+ def test_serialize_p1_12(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_REQUEST,
+ ofproto.OFPBRC_BAD_PACKET)
+
+ def test_serialize_p2_0(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_BAD_TYPE)
+
+ def test_serialize_p2_1(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_BAD_LEN)
+
+ def test_serialize_p2_2(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_BAD_EXPERIMENTER)
+
+ def test_serialize_p2_3(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_BAD_EXP_TYPE)
+
+ def test_serialize_p2_4(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_BAD_OUT_PORT)
+
+ def test_serialize_p2_5(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_BAD_ARGUMENT)
+
+ def test_serialize_p2_6(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_EPERM)
+
+ def test_serialize_p2_7(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_TOO_MANY)
+
+ def test_serialize_p2_8(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_BAD_QUEUE)
+
+ def test_serialize_p2_9(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_BAD_OUT_GROUP)
+
+ def test_serialize_p2_10(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_MATCH_INCONSISTENT)
+
+ def test_serialize_p2_11(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_UNSUPPORTED_ORDER)
+
+ def test_serialize_p2_12(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_BAD_TAG)
+
+ def test_serialize_p2_13(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_BAD_SET_TYPE)
+
+ def test_serialize_p2_14(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_BAD_SET_LEN)
+
+ def test_serialize_p2_15(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_ACTION,
+ ofproto.OFPBAC_BAD_SET_ARGUMENT)
+
+ def test_serialize_p3_0(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_INSTRUCTION,
+ ofproto.OFPBIC_UNKNOWN_INST)
+
+ def test_serialize_p3_1(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_INSTRUCTION,
+ ofproto.OFPBIC_UNSUP_INST)
+
+ def test_serialize_p3_2(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_INSTRUCTION,
+ ofproto.OFPBIC_BAD_TABLE_ID)
+
+ def test_serialize_p3_3(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_INSTRUCTION,
+ ofproto.OFPBIC_UNSUP_METADATA)
+
+ def test_serialize_p3_4(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_INSTRUCTION,
+ ofproto.OFPBIC_UNSUP_METADATA_MASK)
+
+ def test_serialize_p3_5(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_INSTRUCTION,
+ ofproto.OFPBIC_BAD_EXPERIMENTER)
+
+ def test_serialize_p3_6(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_INSTRUCTION,
+ ofproto.OFPBIC_BAD_EXP_TYPE)
+
+ def test_serialize_p3_7(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_INSTRUCTION,
+ ofproto.OFPBIC_BAD_LEN)
+
+ def test_serialize_p3_8(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_INSTRUCTION,
+ ofproto.OFPBIC_EPERM)
+
+ def test_serialize_p4_0(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_MATCH,
+ ofproto.OFPBMC_BAD_TYPE)
+
+ def test_serialize_p4_1(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_MATCH,
+ ofproto.OFPBMC_BAD_LEN)
+
+ def test_serialize_p4_2(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_MATCH,
+ ofproto.OFPBMC_BAD_TAG)
+
+ def test_serialize_p4_3(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_MATCH,
+ ofproto.OFPBMC_BAD_DL_ADDR_MASK)
+
+ def test_serialize_p4_4(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_MATCH,
+ ofproto.OFPBMC_BAD_NW_ADDR_MASK)
+
+ def test_serialize_p4_5(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_MATCH,
+ ofproto.OFPBMC_BAD_WILDCARDS)
+
+ def test_serialize_p4_6(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_MATCH,
+ ofproto.OFPBMC_BAD_FIELD)
+
+ def test_serialize_p4_7(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_MATCH,
+ ofproto.OFPBMC_BAD_VALUE)
+
+ def test_serialize_p4_8(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_MATCH,
+ ofproto.OFPBMC_BAD_MASK)
+
+ def test_serialize_p4_9(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_MATCH,
+ ofproto.OFPBMC_BAD_PREREQ)
+
+ def test_serialize_p4_10(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_MATCH,
+ ofproto.OFPBMC_DUP_FIELD)
+
+ def test_serialize_p4_11(self):
+ self._test_serialize_p(ofproto.OFPET_BAD_MATCH,
+ ofproto.OFPBMC_EPERM)
+
+ def test_serialize_p5_0(self):
+ self._test_serialize_p(ofproto.OFPET_FLOW_MOD_FAILED,
+ ofproto.OFPFMFC_UNKNOWN)
+
+ def test_serialize_p5_1(self):
+ self._test_serialize_p(ofproto.OFPET_FLOW_MOD_FAILED,
+ ofproto.OFPFMFC_TABLE_FULL)
+
+ def test_serialize_p5_2(self):
+ self._test_serialize_p(ofproto.OFPET_FLOW_MOD_FAILED,
+ ofproto.OFPFMFC_BAD_TABLE_ID)
+
+ def test_serialize_p5_3(self):
+ self._test_serialize_p(ofproto.OFPET_FLOW_MOD_FAILED,
+ ofproto.OFPFMFC_OVERLAP)
+
+ def test_serialize_p5_4(self):
+ self._test_serialize_p(ofproto.OFPET_FLOW_MOD_FAILED,
+ ofproto.OFPFMFC_EPERM)
+
+ def test_serialize_p5_5(self):
+ self._test_serialize_p(ofproto.OFPET_FLOW_MOD_FAILED,
+ ofproto.OFPFMFC_BAD_TIMEOUT)
+
+ def test_serialize_p5_6(self):
+ self._test_serialize_p(ofproto.OFPET_FLOW_MOD_FAILED,
+ ofproto.OFPFMFC_BAD_COMMAND)
+
+ def test_serialize_p5_7(self):
+ self._test_serialize_p(ofproto.OFPET_FLOW_MOD_FAILED,
+ ofproto.OFPFMFC_BAD_FLAGS)
+
+ def test_serialize_p6_0(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_GROUP_EXISTS)
+
+ def test_serialize_p6_1(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_INVALID_GROUP)
+
+ def test_serialize_p6_2(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_WEIGHT_UNSUPPORTED)
+
+ def test_serialize_p6_3(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_OUT_OF_GROUPS)
+
+ def test_serialize_p6_4(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_OUT_OF_BUCKETS)
+
+ def test_serialize_p6_5(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_CHAINING_UNSUPPORTED)
+
+ def test_serialize_p6_6(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_WATCH_UNSUPPORTED)
+
+ def test_serialize_p6_7(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_LOOP)
+
+ def test_serialize_p6_8(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_UNKNOWN_GROUP)
+
+ def test_serialize_p6_9(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_CHAINED_GROUP)
+
+ def test_serialize_p6_10(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_BAD_TYPE)
+
+ def test_serialize_p6_11(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_BAD_COMMAND)
+
+ def test_serialize_p6_12(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_BAD_BUCKET)
+
+ def test_serialize_p6_13(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_BAD_WATCH)
+
+ def test_serialize_p6_14(self):
+ self._test_serialize_p(ofproto.OFPET_GROUP_MOD_FAILED,
+ ofproto.OFPGMFC_EPERM)
+
+ def test_serialize_p7_0(self):
+ self._test_serialize_p(ofproto.OFPET_PORT_MOD_FAILED,
+ ofproto.OFPPMFC_BAD_PORT)
+
+ def test_serialize_p7_1(self):
+ self._test_serialize_p(ofproto.OFPET_PORT_MOD_FAILED,
+ ofproto.OFPPMFC_BAD_HW_ADDR)
+
+ def test_serialize_p7_2(self):
+ self._test_serialize_p(ofproto.OFPET_PORT_MOD_FAILED,
+ ofproto.OFPPMFC_BAD_CONFIG)
+
+ def test_serialize_p7_3(self):
+ self._test_serialize_p(ofproto.OFPET_PORT_MOD_FAILED,
+ ofproto.OFPPMFC_BAD_ADVERTISE)
+
+ def test_serialize_p7_4(self):
+ self._test_serialize_p(ofproto.OFPET_PORT_MOD_FAILED,
+ ofproto.OFPPMFC_EPERM)
+
+ def test_serialize_p8_0(self):
+ self._test_serialize_p(ofproto.OFPET_TABLE_MOD_FAILED,
+ ofproto.OFPTMFC_BAD_TABLE)
+
+ def test_serialize_p8_1(self):
+ self._test_serialize_p(ofproto.OFPET_TABLE_MOD_FAILED,
+ ofproto.OFPTMFC_BAD_CONFIG)
+
+ def test_serialize_p8_2(self):
+ self._test_serialize_p(ofproto.OFPET_TABLE_MOD_FAILED,
+ ofproto.OFPTMFC_EPERM)
+
+ def test_serialize_p9_0(self):
+ self._test_serialize_p(ofproto.OFPET_QUEUE_OP_FAILED,
+ ofproto.OFPQOFC_BAD_PORT)
+
+ def test_serialize_p9_1(self):
+ self._test_serialize_p(ofproto.OFPET_QUEUE_OP_FAILED,
+ ofproto.OFPQOFC_BAD_QUEUE)
+
+ def test_serialize_p9_2(self):
+ self._test_serialize_p(ofproto.OFPET_QUEUE_OP_FAILED,
+ ofproto.OFPQOFC_EPERM)
+
+ def test_serialize_p10_0(self):
+ self._test_serialize_p(ofproto.OFPET_SWITCH_CONFIG_FAILED,
+ ofproto.OFPSCFC_BAD_FLAGS)
+
+ def test_serialize_p10_1(self):
+ self._test_serialize_p(ofproto.OFPET_SWITCH_CONFIG_FAILED,
+ ofproto.OFPSCFC_BAD_LEN)
+
+ def test_serialize_p10_2(self):
+ self._test_serialize_p(ofproto.OFPET_SWITCH_CONFIG_FAILED,
+ ofproto.OFPSCFC_EPERM)
+
+ def test_serialize_p11_0(self):
+ self._test_serialize_p(ofproto.OFPET_ROLE_REQUEST_FAILED,
+ ofproto.OFPRRFC_STALE)
+
+ def test_serialize_p11_1(self):
+ self._test_serialize_p(ofproto.OFPET_ROLE_REQUEST_FAILED,
+ ofproto.OFPRRFC_UNSUP)
+
+ def test_serialize_p11_2(self):
+ self._test_serialize_p(ofproto.OFPET_ROLE_REQUEST_FAILED,
+ ofproto.OFPRRFC_BAD_ROLE)
+
+
+class TestOFPErrorExperimenterMsg(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPErrorExperimenterMsg
+ """
+
+ def test_init(self):
+ c = OFPErrorExperimenterMsg(_Datapath)
+ eq_(c.type, 65535)
+ eq_(c.exp_type, None)
+ eq_(c.experimenter, None)
+ eq_(c.data, None)
+
+ def _test_parser(self, exp_type, experimenter, data=None):
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_ERROR
+ msg_len = ofproto.OFP_ERROR_MSG_SIZE
+ xid = 2495926989
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ # OFP_ERROR_EXPERIMENTER_MSG_PACK_STR = '!HHI'
+ type_ = 0xffff
+ fmt = ofproto.OFP_ERROR_EXPERIMENTER_MSG_PACK_STR
+ buf += pack(fmt, type_, exp_type, experimenter)
+
+ if data is not None:
+ buf += data
+
+ res = OFPErrorMsg.parser(
+ object, version, msg_type, msg_len, xid, buf)
+
+ eq_(res.version, version)
+ eq_(res.msg_type, msg_type)
+ eq_(res.msg_len, msg_len)
+ eq_(res.xid, xid)
+ eq_(res.type, type_)
+ eq_(res.exp_type, exp_type)
+ eq_(res.experimenter, experimenter)
+
+ if data is not None:
+ eq_(res.data, data)
+
+ def test_parser_mid(self):
+ exp_type = 32768
+ experimenter = 2147483648
+ data = b'Error Experimenter Message.'
+ self._test_parser(exp_type, experimenter, data)
+
+ def test_parser_max(self):
+ exp_type = 65535
+ experimenter = 4294967295
+ data = b'Error Experimenter Message.'.ljust(65519)
+ self._test_parser(exp_type, experimenter, data)
+
+ def test_parser_min(self):
+ exp_type = 0
+ experimenter = 0
+ self._test_parser(exp_type, experimenter)
+
+
+class TestOFPEchoRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPEchoRequest
+ """
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_ECHO_REQUEST
+ msg_len = ofproto.OFP_HEADER_SIZE
+ xid = 2495926989
+
+ def test_init(self):
+ c = OFPEchoRequest(_Datapath)
+ eq_(c.data, None)
+
+ def _test_parser(self, data=None):
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, self.version, self.msg_type,
+ self.msg_len, self.xid)
+
+ if data is not None:
+ buf += data
+
+ res = OFPEchoRequest.parser(object, self.version, self.msg_type,
+ self.msg_len, self.xid, buf)
+
+ eq_(res.version, self.version)
+ eq_(res.msg_type, self.msg_type)
+ eq_(res.msg_len, self.msg_len)
+ eq_(res.xid, self.xid)
+
+ if data is not None:
+ eq_(res.data, data)
+
+ def test_parser_mid(self):
+ data = b'Request Message.'
+ self._test_parser(data)
+
+ def test_parser_max(self):
+ data = b'Request Message.'.ljust(65527)
+ self._test_parser(data)
+
+ def test_parser_min(self):
+ data = None
+ self._test_parser(data)
+
+ def _test_serialize(self, data):
+ c = OFPEchoRequest(_Datapath)
+ c.data = data
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_ECHO_REQUEST, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+
+ if data is not None:
+ fmt += str(len(c.data)) + 's'
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_ECHO_REQUEST)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+
+ if data is not None:
+ eq_(res[4], data)
+
+ def test_serialize_mid(self):
+ data = b'Request Message.'
+ self._test_serialize(data)
+
+ def test_serialize_max(self):
+ data = b'Request Message.'.ljust(65527)
+ self._test_serialize(data)
+
+ def test_serialize_min(self):
+ data = None
+ self._test_serialize(data)
+
+
+class TestOFPEchoReply(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPEchoReply
+ """
+
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_ECHO_REPLY
+ msg_len = ofproto.OFP_HEADER_SIZE
+ xid = 2495926989
+
+ def test_init(self):
+ c = OFPEchoReply(_Datapath)
+ eq_(c.data, None)
+
+ def _test_parser(self, data):
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, self.version, self.msg_type,
+ self.msg_len, self.xid)
+
+ if data is not None:
+ buf += data
+
+ res = OFPEchoReply.parser(object, self.version, self.msg_type,
+ self.msg_len, self.xid, buf)
+
+ eq_(res.version, self.version)
+ eq_(res.msg_type, self.msg_type)
+ eq_(res.msg_len, self.msg_len)
+ eq_(res.xid, self.xid)
+
+ if data is not None:
+ eq_(res.data, data)
+
+ def test_parser_mid(self):
+ data = b'Reply Message.'
+ self._test_parser(data)
+
+ def test_parser_max(self):
+ data = b'Reply Message.'.ljust(65527)
+ self._test_parser(data)
+
+ def test_parser_min(self):
+ data = None
+ self._test_parser(data)
+
+ def _test_serialize(self, data):
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, self.version, self.msg_type,
+ self.msg_len, self.xid) + data
+
+ c = OFPEchoReply(_Datapath)
+ c.data = data
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_ECHO_REPLY, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + str(len(c.data)) + 's'
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_ECHO_REPLY)
+ eq_(res[2], len(buf))
+ eq_(res[3], 0)
+ eq_(res[4], data)
+
+ def test_serialize_mid(self):
+ data = b'Reply Message.'
+ self._test_serialize(data)
+
+ def test_serialize_max(self):
+ data = b'Reply Message.'.ljust(65527)
+ self._test_serialize(data)
+
+ @raises(AssertionError)
+ def test_serialize_check_data(self):
+ c = OFPEchoReply(_Datapath)
+ c.serialize()
+
+
+class TestOFPExperimenter(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPExperimenter
+ """
+
+ c = OFPExperimenter(_Datapath)
+
+ def _test_parser(self, xid, experimenter, exp_type):
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_EXPERIMENTER
+ msg_len = ofproto.OFP_EXPERIMENTER_HEADER_SIZE
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ # OFP_EXPERIMENTER_HEADER_PACK_STR
+ # '!II'...experimenter, exp_type
+ fmt = ofproto.OFP_EXPERIMENTER_HEADER_PACK_STR
+ buf += pack(fmt, experimenter, exp_type)
+
+ res = OFPExperimenter.parser(object, version, msg_type,
+ msg_len, xid, buf)
+
+ eq_(version, res.version)
+ eq_(msg_type, res.msg_type)
+ eq_(msg_len, res.msg_len)
+ eq_(xid, res.xid)
+ eq_(experimenter, res.experimenter)
+ eq_(exp_type, res.exp_type)
+
+ def test_parser_mid(self):
+ xid = 2495926989
+ experimenter = 2147483648
+ exp_type = 1
+ self._test_parser(xid, experimenter, exp_type)
+
+ def test_parser_max(self):
+ xid = 4294967295
+ experimenter = 4294967295
+ exp_type = 65535
+ self._test_parser(xid, experimenter, exp_type)
+
+ def test_parser_min(self):
+ xid = 0
+ experimenter = 0
+ exp_type = 0
+ self._test_parser(xid, experimenter, exp_type)
+
+
+class TestOFPPort(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPPort
+ """
+
+ def test_init(self):
+ # OFP_PORT_PACK_STR
+ # '!I4x6s2x16sIIIIIIII'... port_no, pad(4), hw_addr, pad(2),
+ # name, config, state, curr, advertised,
+ # peer, curr_speed, max_speed
+ port_no = 1119692796
+ hw_addr = 'c0:26:53:c4:29:e2'
+ name = b'name'.ljust(16)
+ config = 2226555987
+ state = 1678244809
+ curr = 2850556459
+ advertised = 2025421682
+ supported = 2120575149
+ peer = 2757463021
+ curr_speed = 2641353507
+ max_speed = 1797291672
+
+ fmt = ofproto.OFP_PORT_PACK_STR
+
+ c = OFPPort(port_no, hw_addr, name, config, state, curr,
+ advertised, supported, peer, curr_speed, max_speed)
+
+ eq_(port_no, c.port_no)
+ eq_(hw_addr, c.hw_addr)
+ eq_(name, c.name)
+ eq_(config, c.config)
+ eq_(state, c.state)
+ eq_(curr, c.curr)
+ eq_(advertised, c.advertised)
+ eq_(supported, c.supported)
+ eq_(peer, c.peer)
+ eq_(curr_speed, c.curr_speed)
+ eq_(max_speed, c.max_speed)
+
+ def _test_parser(self, port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed):
+ name = b'name'.ljust(16)
+ fmt = ofproto.OFP_PORT_PACK_STR
+ buf = pack(fmt, port_no, addrconv.mac.text_to_bin(hw_addr), name,
+ config, state, curr,
+ advertised, supported, peer, curr_speed, max_speed)
+
+ res = OFPPort.parser(buf, 0)
+
+ eq_(port_no, res.port_no)
+ eq_(hw_addr, res.hw_addr)
+ eq_(name, res.name)
+ eq_(config, res.config)
+ eq_(state, res.state)
+ eq_(curr, res.curr)
+ eq_(advertised, res.advertised)
+ eq_(supported, res.supported)
+ eq_(peer, res.peer)
+ eq_(curr_speed, res.curr_speed)
+ eq_(max_speed, res.max_speed)
+
+ def test_parser_mid(self):
+ port_no = 1119692796
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = 2226555987
+ state = 1678244809
+ curr = 2850556459
+ advertised = 2025421682
+ supported = 2120575149
+ peer = 2757463021
+ curr_speed = 2641353507
+ max_speed = 1797291672
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_max(self):
+ port_no = ofproto.OFPP_ANY
+ hw_addr = 'ff:ff:ff:ff:ff:ff'
+ config = 4294967295
+ state = 4294967295
+ curr = 4294967295
+ advertised = 4294967295
+ supported = 4294967295
+ peer = 4294967295
+ curr_speed = 4294967295
+ max_speed = 4294967295
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_min(self):
+ port_no = 0
+ hw_addr = '00:00:00:00:00:00'
+ config = 0
+ state = 0
+ curr = 0
+ advertised = 0
+ supported = 0
+ peer = 0
+ curr_speed = 0
+ max_speed = 0
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p1(self):
+ port_no = ofproto.OFPP_MAX
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_PORT_DOWN
+ state = ofproto.OFPPS_LINK_DOWN
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_10MB_HD
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p2(self):
+ port_no = ofproto.OFPP_IN_PORT
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_RECV
+ state = ofproto.OFPPS_BLOCKED
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_10MB_FD
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p3(self):
+ port_no = ofproto.OFPP_TABLE
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_FWD
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_100MB_HD
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p4(self):
+ port_no = ofproto.OFPP_NORMAL
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_100MB_FD
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p5(self):
+ port_no = ofproto.OFPP_FLOOD
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_1GB_HD
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p6(self):
+ port_no = ofproto.OFPP_ALL
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_1GB_FD
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p7(self):
+ port_no = ofproto.OFPP_CONTROLLER
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_10GB_FD
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p8(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_40GB_FD
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p9(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_100GB_FD
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p10(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_1TB_FD
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p11(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_OTHER
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p12(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_COPPER
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p13(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_FIBER
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p14(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_AUTONEG
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p15(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_PAUSE
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p16(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = 'c0:26:53:c4:29:e2'
+ config = ofproto.OFPPC_NO_PACKET_IN
+ state = ofproto.OFPPS_LIVE
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_PAUSE_ASYM
+ self._test_parser(port_no, hw_addr, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+
+class TestOFPFeaturesRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPFeaturesRequest
+ """
+
+ def test_serialize(self):
+ c = OFPFeaturesRequest(_Datapath)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_FEATURES_REQUEST, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_FEATURES_REQUEST)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+
+
+class TestOFPSwitchFeatures(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPSwitchFeatures
+ """
+
+ def _test_parser(self, xid, datapath_id, n_buffers,
+ n_tables, capabilities, reserved, port_cnt=0):
+
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_FEATURES_REPLY
+ msg_len = ofproto.OFP_SWITCH_FEATURES_SIZE \
+ + ofproto.OFP_PORT_SIZE * port_cnt
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ # OFP_SWITCH_FEATURES_PACK_STR
+ # '!QIB3xII'...datapath_id, n_buffers, n_tables,
+ # pad(3), capabilities, reserved
+
+ fmt = ofproto.OFP_SWITCH_FEATURES_PACK_STR
+ buf += pack(fmt, datapath_id, n_buffers, n_tables,
+ capabilities, reserved)
+
+ for i in range(port_cnt):
+ # OFP_PORT_PACK_STR
+ # '!I4x6s2x16sIIIIIIII'... port_no, pad(4), hw_addr, pad(2),
+ # name, config, state, curr, advertised,
+ # peer, curr_speed, max_speed
+ port_no = i
+
+ fmt = ofproto.OFP_PORT_PACK_STR
+ buf += pack(fmt, port_no, b'\x00' * 6, b'\x00' * 16, 0, 0, 0,
+ 0, 0, 0, 0, 0)
+
+ res = OFPSwitchFeatures.parser(object, version, msg_type,
+ msg_len, xid, buf)
+
+ eq_(res.version, version)
+ eq_(res.msg_type, msg_type)
+ eq_(res.msg_len, msg_len)
+ eq_(res.xid, xid)
+
+ eq_(res.datapath_id, datapath_id)
+ eq_(res.n_buffers, n_buffers)
+ eq_(res.n_tables, n_tables)
+ eq_(res.capabilities, capabilities)
+ eq_(res._reserved, reserved)
+
+ for i in range(port_cnt):
+ eq_(res.ports[i].port_no, i)
+
+ def test_parser_mid(self):
+ xid = 2495926989
+ datapath_id = 1270985291017894273
+ n_buffers = 2148849654
+ n_tables = 228
+ capabilities = 1766843586
+ reserved = 2013714700
+ port_cnt = 1
+
+ self._test_parser(xid, datapath_id, n_buffers, n_tables,
+ capabilities, reserved, port_cnt)
+
+ def test_parser_max(self):
+ xid = 4294967295
+ datapath_id = 18446744073709551615
+ n_buffers = 4294967295
+ n_tables = 255
+ capabilities = 4294967295
+ reserved = 4294967295
+ port_cnt = 1023
+
+ self._test_parser(xid, datapath_id, n_buffers, n_tables,
+ capabilities, reserved, port_cnt)
+
+ def test_parser_min(self):
+ xid = 0
+ datapath_id = 0
+ n_buffers = 0
+ n_tables = 0
+ capabilities = 0
+ reserved = 0
+ port_cnt = 0
+
+ self._test_parser(xid, datapath_id, n_buffers, n_tables,
+ capabilities, reserved, port_cnt)
+
+
+class TestOFPGetConfigRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPGetConfigRequest
+ """
+
+ def test_serialize(self):
+ c = OFPGetConfigRequest(_Datapath)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_GET_CONFIG_REQUEST, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_GET_CONFIG_REQUEST)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+
+
+class TestOFPGetConfigReply(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPGetConfigReply
+ """
+
+ def _test_parser(self, xid, flags, miss_send_len):
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_GET_CONFIG_REPLY
+ msg_len = ofproto.OFP_SWITCH_CONFIG_SIZE
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ # OFP_SWITCH_CONFIG_PACK_STR
+ # '!HH'...flags, miss_send_len
+ fmt = ofproto.OFP_SWITCH_CONFIG_PACK_STR
+ buf += pack(fmt, flags, miss_send_len)
+
+ res = OFPGetConfigReply.parser(object, version, msg_type,
+ msg_len, xid, buf)
+
+ eq_(version, res.version)
+ eq_(msg_type, res.msg_type)
+ eq_(msg_len, res.msg_len)
+ eq_(xid, res.xid)
+ eq_(flags, res.flags)
+ eq_(miss_send_len, res.miss_send_len)
+
+ def test_parser_mid(self):
+ xid = 3423224276
+ flags = 41186
+ miss_send_len = 13838
+ self._test_parser(xid, flags, miss_send_len)
+
+ def test_parser_max(self):
+ xid = 4294967295
+ flags = 65535
+ miss_send_len = 65535
+ self._test_parser(xid, flags, miss_send_len)
+
+ def test_parser_min(self):
+ xid = 0
+ flags = ofproto.OFPC_FRAG_NORMAL
+ miss_send_len = 0
+ self._test_parser(xid, flags, miss_send_len)
+
+ def test_parser_p1(self):
+ xid = 3423224276
+ flags = ofproto.OFPC_FRAG_DROP
+ miss_send_len = 13838
+ self._test_parser(xid, flags, miss_send_len)
+
+ def test_parser_p2(self):
+ xid = 3423224276
+ flags = ofproto.OFPC_FRAG_REASM
+ miss_send_len = 13838
+ self._test_parser(xid, flags, miss_send_len)
+
+ def test_parser_p3(self):
+ xid = 3423224276
+ flags = ofproto.OFPC_FRAG_MASK
+ miss_send_len = 13838
+ self._test_parser(xid, flags, miss_send_len)
+
+ def test_parser_p4(self):
+ xid = 3423224276
+ flags = ofproto.OFPC_INVALID_TTL_TO_CONTROLLER
+ miss_send_len = 13838
+ self._test_parser(xid, flags, miss_send_len)
+
+
+class TestOFPSetConfig(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPSetConfig
+ """
+
+ def test_init(self):
+ # OFP_SWITCH_CONFIG_PACK_STR
+ # '!HH'...flags, miss_send_len
+ flags = 41186
+ miss_send_len = 13838
+
+ c = OFPSetConfig(_Datapath, flags, miss_send_len)
+
+ eq_(flags, c.flags)
+ eq_(miss_send_len, c.miss_send_len)
+
+ def _test_serialize(self, flags, miss_send_len):
+ c = OFPSetConfig(_Datapath, flags, miss_send_len)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_SET_CONFIG, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + ofproto.OFP_SWITCH_CONFIG_PACK_STR.replace('!', '')
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_SET_CONFIG)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], flags)
+ eq_(res[5], miss_send_len)
+
+ def test_serialize_mid(self):
+ flags = 41186
+ miss_send_len = 13838
+ self._test_serialize(flags, miss_send_len)
+
+ def test_serialize_max(self):
+ flags = 65535
+ miss_send_len = 65535
+ self._test_serialize(flags, miss_send_len)
+
+ def test_serialize_min(self):
+ flags = ofproto.OFPC_FRAG_NORMAL
+ miss_send_len = 0
+ self._test_serialize(flags, miss_send_len)
+
+ def test_serialize_p1(self):
+ flags = ofproto.OFPC_FRAG_DROP
+ miss_send_len = 13838
+ self._test_serialize(flags, miss_send_len)
+
+ def test_serialize_p2(self):
+ flags = ofproto.OFPC_FRAG_REASM
+ miss_send_len = 13838
+ self._test_serialize(flags, miss_send_len)
+
+ def test_serialize_p3(self):
+ flags = ofproto.OFPC_FRAG_MASK
+ miss_send_len = 13838
+ self._test_serialize(flags, miss_send_len)
+
+ def test_serialize_p4(self):
+ flags = ofproto.OFPC_INVALID_TTL_TO_CONTROLLER
+ miss_send_len = 13838
+ self._test_serialize(flags, miss_send_len)
+
+ @raises(AssertionError)
+ def test_serialize_check_flags(self):
+ flags = None
+ miss_send_len = 13838
+ c = OFPSetConfig(_Datapath, flags, miss_send_len)
+ c.serialize()
+
+ @raises(AssertionError)
+ def test_serialize_check_miss_send_len(self):
+ flags = 41186
+ miss_send_len = None
+ c = OFPSetConfig(_Datapath, flags, miss_send_len)
+ c.serialize()
+
+
+class TestOFPPacketIn(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPPacketIn
+ """
+
+ def _test_parser(self, xid, buffer_id, total_len=0,
+ reason=0, table_id=0, data=None):
+ if data is None:
+ data = b''
+
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_PACKET_IN
+ msg_len = ofproto.OFP_PACKET_IN_SIZE + len(data)
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ # OFP_PACKET_IN_PACK_STR
+ fmt = ofproto.OFP_PACKET_IN_PACK_STR
+ buf += pack(fmt, buffer_id, total_len, reason, table_id)
+
+ # match
+ buf_match = bytearray()
+ match = OFPMatch()
+ match.serialize(buf_match, 0)
+ buf += six.binary_type(buf_match)
+
+ # data
+ buf += b'\x00' * 2
+ buf += data
+
+ res = OFPPacketIn.parser(object, version, msg_type, msg_len,
+ xid, buf)
+
+ eq_(version, res.version)
+ eq_(msg_type, res.msg_type)
+ eq_(msg_len, res.msg_len)
+ eq_(xid, res.xid)
+ eq_(buffer_id, res.buffer_id)
+ eq_(total_len, res.total_len)
+ eq_(reason, res.reason)
+ eq_(table_id, res.table_id)
+ ok_(hasattr(res, 'match'))
+ eq_(ofproto.OFPMT_OXM, res.match.type)
+
+ if data:
+ eq_(data[:total_len], res.data)
+
+ def test_data_is_total_len(self):
+ xid = 3423224276
+ buffer_id = 2926809324
+ reason = 128
+ table_id = 3
+ data = b'PacketIn'
+ total_len = len(data)
+ self._test_parser(xid, buffer_id, total_len, reason, table_id, data)
+
+ def test_data_is_not_total_len(self):
+ xid = 3423224276
+ buffer_id = 2926809324
+ reason = 128
+ table_id = 3
+ data = b'PacketIn'
+ total_len = len(data) - 1
+ self._test_parser(xid, buffer_id, total_len, reason, table_id, data)
+
+ def test_parser_max(self):
+ # 65535(!H max) - 24(without data) = 65511
+ xid = 4294967295
+ buffer_id = 4294967295
+ reason = 255
+ table_id = 255
+ data = b'data'.ljust(65511)
+ total_len = len(data)
+ self._test_parser(xid, buffer_id, total_len, reason, table_id, data)
+
+ def test_parser_min(self):
+ xid = 0
+ buffer_id = 0
+ reason = ofproto.OFPR_NO_MATCH
+ table_id = 0
+ total_len = 0
+ self._test_parser(xid, buffer_id, total_len, reason, table_id)
+
+ def test_parser_p1(self):
+ data = b'data'.ljust(8)
+ xid = 3423224276
+ buffer_id = 2926809324
+ total_len = len(data)
+ reason = ofproto.OFPR_ACTION
+ table_id = 3
+ self._test_parser(xid, buffer_id, total_len, reason, table_id, data)
+
+ def test_parser_p2(self):
+ data = b'data'.ljust(8)
+ xid = 3423224276
+ buffer_id = 2926809324
+ total_len = len(data)
+ reason = ofproto.OFPR_INVALID_TTL
+ table_id = 3
+ self._test_parser(xid, buffer_id, total_len, reason, table_id, data)
+
+
+class TestOFPFlowRemoved(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPFlowRemoved
+ """
+
+ def _test_parser(self, xid, cookie, priority,
+ reason, table_id, duration_sec,
+ duration_nsec, idle_timeout, hard_timeout,
+ packet_count, byte_count):
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_FLOW_REMOVED
+ msg_len = ofproto.OFP_FLOW_REMOVED_SIZE
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ # OFP_FLOW_REMOVED_PACK_STR0
+ # '!QHBBIIHHQQ' ...cookie, priority, reason, table_id,
+ # duration_sec, duration_nsec, idle_timeout,
+ # hard_timeout, packet_count, byte_count
+
+ fmt = ofproto.OFP_FLOW_REMOVED_PACK_STR0
+ buf += pack(fmt, cookie, priority, reason, table_id,
+ duration_sec, duration_nsec, idle_timeout,
+ hard_timeout, packet_count, byte_count)
+
+ # OFP_MATCH_PACK_STR
+ match = OFPMatch()
+ buf_match = bytearray()
+ match.serialize(buf_match, 0)
+
+ buf += six.binary_type(buf_match)
+
+ res = OFPFlowRemoved.parser(object, version, msg_type,
+ msg_len, xid, buf)
+
+ eq_(version, res.version)
+ eq_(msg_type, res.msg_type)
+ eq_(msg_len, res.msg_len)
+ eq_(xid, res.xid)
+ eq_(cookie, res.cookie)
+ eq_(priority, res.priority)
+ eq_(reason, res.reason)
+ eq_(table_id, res.table_id)
+ eq_(duration_sec, res.duration_sec)
+ eq_(duration_nsec, res.duration_nsec)
+ eq_(idle_timeout, res.idle_timeout)
+ eq_(hard_timeout, res.hard_timeout)
+ eq_(packet_count, res.packet_count)
+ eq_(byte_count, res.byte_count)
+ ok_(hasattr(res, 'match'))
+ eq_(ofproto.OFPMT_OXM, res.match.type)
+
+ def test_parser_mid(self):
+ xid = 3423224276
+ cookie = 178378173441633860
+ priority = 718
+ reason = 128
+ table_id = 169
+ duration_sec = 2250548154
+ duration_nsec = 2492776995
+ idle_timeout = 60284
+ hard_timeout = 60285
+ packet_count = 6489108735192644493
+ byte_count = 7334344481123449724
+ self._test_parser(xid, cookie, priority,
+ reason, table_id, duration_sec,
+ duration_nsec, idle_timeout, hard_timeout,
+ packet_count, byte_count)
+
+ def test_parser_max(self):
+ xid = 4294967295
+ cookie = 18446744073709551615
+ priority = 65535
+ reason = 255
+ table_id = 255
+ duration_sec = 4294967295
+ duration_nsec = 4294967295
+ idle_timeout = 65535
+ hard_timeout = 65535
+ packet_count = 18446744073709551615
+ byte_count = 18446744073709551615
+ self._test_parser(xid, cookie, priority,
+ reason, table_id, duration_sec,
+ duration_nsec, idle_timeout, hard_timeout,
+ packet_count, byte_count)
+
+ def test_parser_min(self):
+ xid = 0
+ cookie = 0
+ priority = 0
+ reason = ofproto.OFPRR_IDLE_TIMEOUT
+ table_id = 0
+ duration_sec = 0
+ duration_nsec = 0
+ idle_timeout = 0
+ hard_timeout = 0
+ packet_count = 0
+ byte_count = 0
+ self._test_parser(xid, cookie, priority,
+ reason, table_id, duration_sec,
+ duration_nsec, idle_timeout, hard_timeout,
+ packet_count, byte_count)
+
+ def test_parser_p1(self):
+ xid = 3423224276
+ cookie = 178378173441633860
+ priority = 718
+ reason = ofproto.OFPRR_HARD_TIMEOUT
+ table_id = 169
+ duration_sec = 2250548154
+ duration_nsec = 2492776995
+ idle_timeout = 60284
+ hard_timeout = 60285
+ packet_count = 6489108735192644493
+ byte_count = 7334344481123449724
+ self._test_parser(xid, cookie, priority,
+ reason, table_id, duration_sec,
+ duration_nsec, idle_timeout, hard_timeout,
+ packet_count, byte_count)
+
+ def test_parser_p2(self):
+ xid = 3423224276
+ cookie = 178378173441633860
+ priority = 718
+ reason = ofproto.OFPRR_DELETE
+ table_id = 169
+ duration_sec = 2250548154
+ duration_nsec = 2492776995
+ idle_timeout = 60284
+ hard_timeout = 60285
+ packet_count = 6489108735192644493
+ byte_count = 7334344481123449724
+ self._test_parser(xid, cookie, priority,
+ reason, table_id, duration_sec,
+ duration_nsec, idle_timeout, hard_timeout,
+ packet_count, byte_count)
+
+ def test_parser_p3(self):
+ xid = 3423224276
+ cookie = 178378173441633860
+ priority = 718
+ reason = ofproto.OFPRR_GROUP_DELETE
+ table_id = 169
+ duration_sec = 2250548154
+ duration_nsec = 2492776995
+ idle_timeout = 60284
+ hard_timeout = 60285
+ packet_count = 6489108735192644493
+ byte_count = 7334344481123449724
+ self._test_parser(xid, cookie, priority,
+ reason, table_id, duration_sec,
+ duration_nsec, idle_timeout, hard_timeout,
+ packet_count, byte_count)
+
+
+class TestOFPPortStatus(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPPortStatus
+ """
+
+ def _test_parser(self, xid, reason,
+ port_no, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed):
+
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_PORT_STATUS
+ msg_len = ofproto.OFP_PORT_STATUS_SIZE
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ # OFP_PORT_STATUS_PACK_STR = '!B7x' + _OFP_PORT_PACK_STR
+ # '!B7x'...reason, pad(7)
+ # OFP_PORT_PACK_STR
+ # '!I4x6s2x16sIIIIIIII'... port_no, pad(4), hw_addr, pad(2),
+ # name, config, state, curr, advertised,
+ # peer, curr_speed, max_speed
+ hw_addr = '80:ff:9a:e3:72:85'
+ name = b'name'.ljust(16)
+
+ fmt = ofproto.OFP_PORT_STATUS_PACK_STR
+ buf += pack(fmt, reason, port_no, addrconv.mac.text_to_bin(hw_addr),
+ name, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ res = OFPPortStatus.parser(object, version, msg_type, msg_len,
+ xid, buf)
+
+ eq_(reason, res.reason)
+ eq_(port_no, res.desc.port_no)
+ eq_(hw_addr, res.desc.hw_addr)
+ eq_(name, res.desc.name)
+ eq_(config, res.desc.config)
+ eq_(state, res.desc.state)
+ eq_(curr, res.desc.curr)
+ eq_(advertised, res.desc.advertised)
+ eq_(supported, res.desc.supported)
+ eq_(peer, res.desc.peer)
+ eq_(curr_speed, res.desc.curr_speed)
+ eq_(max_speed, res.desc.max_speed)
+
+ def test_parser_mid(self):
+ xid = 3423224276
+ reason = 128
+ port_no = 1119692796
+ config = 2226555987
+ state = 1678244809
+ curr = 2850556459
+ advertised = 2025421682
+ supported = 2120575149
+ peer = 2757463021
+ curr_speed = 2641353507
+ max_speed = 1797291672
+ self._test_parser(xid, reason,
+ port_no, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_max(self):
+ xid = 4294967295
+ reason = 255
+ port_no = ofproto.OFPP_ANY
+ config = 4294967295
+ state = 4294967295
+ curr = 4294967295
+ advertised = 4294967295
+ supported = 4294967295
+ peer = 4294967295
+ curr_speed = 4294967295
+ max_speed = 4294967295
+ self._test_parser(xid, reason,
+ port_no, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_min(self):
+ xid = 0
+ reason = 0
+ port_no = 0
+ config = 0
+ state = 0
+ curr = 0
+ advertised = 0
+ supported = 0
+ peer = 0
+ curr_speed = 0
+ max_speed = 0
+ self._test_parser(xid, reason,
+ port_no, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p1(self):
+ xid = 3423224276
+ reason = ofproto.OFPPR_DELETE
+ port_no = ofproto.OFPP_MAX
+ config = ofproto.OFPPC_PORT_DOWN
+ state = ofproto.OFPPS_LINK_DOWN
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_10MB_HD
+ self._test_parser(xid, reason,
+ port_no, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+ def test_parser_p2(self):
+ xid = 3423224276
+ reason = ofproto.OFPPR_MODIFY
+ port_no = ofproto.OFPP_MAX
+ config = ofproto.OFPPC_PORT_DOWN
+ state = ofproto.OFPPS_LINK_DOWN
+ curr = advertised = supported \
+ = peer = curr_speed = max_speed \
+ = ofproto.OFPPF_10MB_HD
+ self._test_parser(xid, reason,
+ port_no, config, state, curr, advertised,
+ supported, peer, curr_speed, max_speed)
+
+
+class TestOFPPacketOut(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPPacketOut
+ """
+
+ def _test_init(self, in_port):
+ buffer_id = 0xffffffff
+ data = b'Message'
+ out_port = 0x00002ae0
+ actions = [OFPActionOutput(out_port, 0)]
+
+ c = OFPPacketOut(_Datapath, buffer_id, in_port, actions, data)
+
+ eq_(buffer_id, c.buffer_id)
+ eq_(in_port, c.in_port)
+ eq_(0, c.actions_len)
+ eq_(data, c.data)
+ eq_(actions, c.actions)
+
+ def test_init(self):
+ in_port = 0x00040455
+ self._test_init(in_port)
+
+ @raises(AssertionError)
+ def test_init_check_in_port(self):
+ in_port = None
+ self._test_init(in_port)
+
+ def _test_serialize(self, buffer_id, in_port, action_cnt=0, data=None):
+ actions = []
+ for i in range(action_cnt):
+ actions.append(ofproto_v1_2_parser.OFPActionOutput(i, 0))
+
+ c = OFPPacketOut(_Datapath, buffer_id, in_port, actions, data)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_PACKET_OUT, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = ofproto.OFP_HEADER_PACK_STR \
+ + ofproto.OFP_PACKET_OUT_PACK_STR[1:] \
+ + ofproto.OFP_ACTION_OUTPUT_PACK_STR[1:] * action_cnt
+
+ if data is not None:
+ fmt += str(len(data)) + 's'
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_PACKET_OUT)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], buffer_id)
+ eq_(res[5], in_port)
+ eq_(res[6], ofproto.OFP_ACTION_OUTPUT_SIZE * action_cnt)
+
+ for i in range(action_cnt):
+ index = 7 + i * 4
+ eq_(res[index], ofproto.OFPAT_OUTPUT)
+ eq_(res[index + 1], ofproto.OFP_ACTION_OUTPUT_SIZE)
+ eq_(res[index + 2], i)
+ eq_(res[index + 3], 0)
+
+ if data:
+ eq_(res[-1], data)
+
+ def test_serialize_true(self):
+ buffer_id = 0xffffffff
+ in_port = 0x00040455
+ action_cnt = 2
+ data = b'Message'
+ self._test_serialize(buffer_id, in_port, action_cnt, data)
+
+ def test_serialize_none(self):
+ buffer_id = 0xffffffff
+ in_port = 0x00040455
+ self._test_serialize(buffer_id, in_port)
+
+ def test_serialize_max(self):
+ buffer_id = 0xffffffff
+ in_port = 4294967295
+ action_cnt = 1
+ data = b'Message'.ljust(65495)
+ self._test_serialize(buffer_id, in_port, action_cnt, data)
+
+ def test_serialize_min(self):
+ buffer_id = 0
+ in_port = 0
+ self._test_serialize(buffer_id, in_port)
+
+ def test_serialize_p1(self):
+ buffer_id = 2147483648
+ in_port = ofproto.OFPP_CONTROLLER
+ self._test_serialize(buffer_id, in_port)
+
+ @raises(AssertionError)
+ def test_serialize_check_buffer_id(self):
+ buffer_id = 2147483648
+ in_port = 1
+ action_cnt = 0
+ data = b'DATA'
+ self._test_serialize(buffer_id, in_port, action_cnt, data)
+
+
+class TestOFPFlowMod(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPFlowMod
+ """
+
+ def test_init(self):
+ # OFP_FLOW_MOD_PACK_STR0
+ # '!QQBBHHHIIIH2x'...cookie, cookie_mask, table_id, command,
+ # idle_timeout, hard_timeout, priority, buffer_id,
+ # out_port, out_group, flags
+ cookie = 2127614848199081640
+ cookie_mask = 2127614848199081641
+ table_id = 3
+ command = 0
+ idle_timeout = 62317
+ hard_timeout = 7365
+ priority = 40163
+ buffer_id = 4037115955
+ out_port = 65037
+ out_group = 6606
+ flags = 135
+ instructions = [OFPInstructionGotoTable(table_id)]
+
+ in_port = 1
+ match = OFPMatch()
+ match.set_in_port(in_port)
+
+ c = OFPFlowMod(_Datapath, cookie, cookie_mask, table_id, command,
+ idle_timeout, hard_timeout, priority, buffer_id,
+ out_port, out_group, flags, match, instructions)
+
+ eq_(cookie, c.cookie)
+ eq_(cookie_mask, c.cookie_mask)
+ eq_(table_id, c.table_id)
+ eq_(command, c.command)
+ eq_(idle_timeout, c.idle_timeout)
+ eq_(hard_timeout, c.hard_timeout)
+ eq_(priority, c.priority)
+ eq_(buffer_id, c.buffer_id)
+ eq_(out_port, c.out_port)
+ eq_(out_group, c.out_group)
+ eq_(flags, c.flags)
+ eq_(in_port, c.match._flow.in_port)
+ eq_(instructions[0], c.instructions[0])
+
+ def _test_serialize(self, cookie, cookie_mask, table_id,
+ command, idle_timeout, hard_timeout,
+ priority, buffer_id, out_port,
+ out_group, flags, inst_cnt=0):
+ dl_type = 0x0800
+ match = OFPMatch()
+ match.set_dl_type(dl_type)
+
+ insts = []
+ for i in range(inst_cnt):
+ insts.append(OFPInstructionGotoTable(i))
+
+ c = OFPFlowMod(_Datapath, cookie, cookie_mask, table_id, command,
+ idle_timeout, hard_timeout, priority, buffer_id,
+ out_port, out_group, flags, match, insts)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_FLOW_MOD, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = ofproto.OFP_HEADER_PACK_STR \
+ + ofproto.OFP_FLOW_MOD_PACK_STR0[1:] \
+ + 'HHHBB' \
+ + MTEthType.pack_str[1:] + '6x' \
+ + ofproto.OFP_INSTRUCTION_GOTO_TABLE_PACK_STR[1:] * inst_cnt
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_FLOW_MOD)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], cookie)
+ eq_(res[5], cookie_mask)
+ eq_(res[6], table_id)
+ eq_(res[7], command)
+ eq_(res[8], idle_timeout)
+ eq_(res[9], hard_timeout)
+ eq_(res[10], priority)
+ eq_(res[11], buffer_id)
+ eq_(res[12], out_port)
+ eq_(res[13], out_group)
+ eq_(res[14], flags)
+
+ # OFP_MATCH (type, length, class, [field, hashmask], n_byte, ip_proto)
+ eq_(res[15], ofproto.OFPMT_OXM)
+ eq_(res[16], 10) # OFP_MATCH_STR + MTEthType.pack_str
+ eq_(res[17], ofproto.OFPXMC_OPENFLOW_BASIC)
+ eq_(res[18] >> 1, ofproto.OFPXMT_OFB_ETH_TYPE)
+ eq_(res[18] & 0b0001, 0)
+ eq_(res[19], calcsize(MTEthType.pack_str))
+ eq_(res[20], dl_type)
+
+ # insts (type, length, table_id)
+ for i in range(inst_cnt):
+ index = 21 + 3 * i
+ eq_(res[index], ofproto.OFPIT_GOTO_TABLE)
+ eq_(res[index + 1], ofproto.OFP_INSTRUCTION_GOTO_TABLE_SIZE)
+ eq_(res[index + 2], i)
+
+ def test_serialize_mid(self):
+ cookie = 2127614848199081640
+ cookie_mask = 2127614848199081641
+ table_id = 3
+ command = 128
+ idle_timeout = 62317
+ hard_timeout = 7365
+ priority = 40163
+ buffer_id = 4037115955
+ out_port = 65037
+ out_group = 6606
+ flags = 135
+ inst_cnt = 1
+ self._test_serialize(cookie, cookie_mask, table_id,
+ command, idle_timeout, hard_timeout,
+ priority, buffer_id, out_port,
+ out_group, flags, inst_cnt)
+
+ def test_serialize_max(self):
+ cookie = 18446744073709551615
+ cookie_mask = 18446744073709551615
+ table_id = 255
+ command = 255
+ idle_timeout = 65535
+ hard_timeout = 65535
+ priority = 65535
+ buffer_id = 0xffffffff
+ out_port = 0xffffffff
+ out_group = 0xffffffff
+ flags = 65535
+ inst_cnt = 0xff
+ self._test_serialize(cookie, cookie_mask, table_id,
+ command, idle_timeout, hard_timeout,
+ priority, buffer_id, out_port,
+ out_group, flags, inst_cnt)
+
+ def test_serialize_min(self):
+ cookie = 0
+ cookie_mask = 0
+ table_id = 0
+ command = ofproto.OFPFC_ADD
+ idle_timeout = 0
+ hard_timeout = 0
+ priority = 0
+ buffer_id = 0
+ out_port = 0
+ out_group = 0
+ flags = 0
+ self._test_serialize(cookie, cookie_mask, table_id,
+ command, idle_timeout, hard_timeout,
+ priority, buffer_id, out_port,
+ out_group, flags)
+
+ def test_serialize_p1(self):
+ cookie = 2127614848199081640
+ cookie_mask = 2127614848199081641
+ table_id = 3
+ command = 1
+ idle_timeout = 62317
+ hard_timeout = 7365
+ priority = 40163
+ buffer_id = 4037115955
+ out_port = 65037
+ out_group = 6606
+ flags = 1 << 0
+ self._test_serialize(cookie, cookie_mask, table_id,
+ command, idle_timeout, hard_timeout,
+ priority, buffer_id, out_port,
+ out_group, flags)
+
+ def test_serialize_p2(self):
+ cookie = 2127614848199081640
+ cookie_mask = 2127614848199081641
+ table_id = 3
+ command = 2
+ idle_timeout = 62317
+ hard_timeout = 7365
+ priority = 40163
+ buffer_id = 4037115955
+ out_port = 65037
+ out_group = 6606
+ flags = 1 << 0
+ self._test_serialize(cookie, cookie_mask, table_id,
+ command, idle_timeout, hard_timeout,
+ priority, buffer_id, out_port,
+ out_group, flags)
+
+ def test_serialize_p3(self):
+ cookie = 2127614848199081640
+ cookie_mask = 2127614848199081641
+ table_id = 3
+ command = 3
+ idle_timeout = 62317
+ hard_timeout = 7365
+ priority = 40163
+ buffer_id = 4037115955
+ out_port = 65037
+ out_group = 6606
+ flags = 1 << 1
+ self._test_serialize(cookie, cookie_mask, table_id,
+ command, idle_timeout, hard_timeout,
+ priority, buffer_id, out_port,
+ out_group, flags)
+
+ def test_serialize_p4(self):
+ cookie = 2127614848199081640
+ cookie_mask = 2127614848199081641
+ table_id = 3
+ command = 4
+ idle_timeout = 62317
+ hard_timeout = 7365
+ priority = 40163
+ buffer_id = 4037115955
+ out_port = 65037
+ out_group = 6606
+ flags = 1 << 2
+ self._test_serialize(cookie, cookie_mask, table_id,
+ command, idle_timeout, hard_timeout,
+ priority, buffer_id, out_port,
+ out_group, flags)
+
+
+class TestOFPInstructionGotoTable(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPInstructionGotoTable
+ """
+
+ # OFP_INSTRUCTION_GOTO_TABLE_PACK_STR
+ # '!HHB3x'...type, len, table_id, pad(3)
+ type_ = ofproto.OFPIT_GOTO_TABLE
+ len_ = ofproto.OFP_INSTRUCTION_GOTO_TABLE_SIZE
+
+ fmt = ofproto.OFP_INSTRUCTION_GOTO_TABLE_PACK_STR
+
+ def test_init(self):
+ table_id = 3
+ c = OFPInstructionGotoTable(table_id)
+
+ eq_(self.type_, c.type)
+ eq_(self.len_, c.len)
+ eq_(table_id, c.table_id)
+
+ def _test_parser(self, table_id):
+ buf = pack(self.fmt, self.type_, self.len_, table_id)
+ res = OFPInstructionGotoTable.parser(buf, 0)
+
+ eq_(res.len, self.len_)
+ eq_(res.type, self.type_)
+ eq_(res.table_id, table_id)
+
+ def test_parser_mid(self):
+ self._test_parser(3)
+
+ def test_parser_max(self):
+ self._test_parser(255)
+
+ def test_parser_min(self):
+ self._test_parser(0)
+
+ def _test_serialize(self, table_id):
+ c = OFPInstructionGotoTable(table_id)
+
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+ eq_(res[2], table_id)
+
+ def test_serialize_mid(self):
+ self._test_serialize(3)
+
+ def test_serialize_max(self):
+ self._test_serialize(255)
+
+ def test_serialize_min(self):
+ self._test_serialize(0)
+
+
+class TestOFPInstructionWriteMetadata(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPInstructionWriteMetadata
+ """
+
+ # OFP_INSTRUCTION_WRITE_METADATA_PACK_STR
+ # '!HH4xQQ'...type, len, pad(4), metadata, metadata_mask
+ type_ = ofproto.OFPIT_WRITE_METADATA
+ len_ = ofproto.OFP_INSTRUCTION_WRITE_METADATA_SIZE
+ metadata = 0x1212121212121212
+ metadata_mask = 0xff00ff00ff00ff00
+
+ fmt = ofproto.OFP_INSTRUCTION_WRITE_METADATA_PACK_STR
+
+ def test_init(self):
+ c = OFPInstructionWriteMetadata(self.metadata,
+ self.metadata_mask)
+
+ eq_(self.type_, c.type)
+ eq_(self.len_, c.len)
+ eq_(self.metadata, c.metadata)
+ eq_(self.metadata_mask, c.metadata_mask)
+
+ def _test_parser(self, metadata, metadata_mask):
+ buf = pack(self.fmt, self.type_, self.len_,
+ metadata, metadata_mask)
+
+ res = OFPInstructionWriteMetadata.parser(buf, 0)
+ eq_(res.len, self.len_)
+ eq_(res.type, self.type_)
+ eq_(res.metadata, metadata)
+ eq_(res.metadata_mask, metadata_mask)
+
+ def test_parser_metadata_mid(self):
+ self._test_parser(self.metadata, self.metadata_mask)
+
+ def test_parser_metadata_max(self):
+ metadata = 0xffffffffffffffff
+ self._test_parser(metadata, self.metadata_mask)
+
+ def test_parser_metadata_min(self):
+ metadata = 0
+ self._test_parser(metadata, self.metadata_mask)
+
+ def test_parser_metadata_mask_max(self):
+ metadata_mask = 0xffffffffffffffff
+ self._test_parser(self.metadata, metadata_mask)
+
+ def test_parser_metadata_mask_min(self):
+ metadata_mask = 0
+ self._test_parser(self.metadata, metadata_mask)
+
+ def _test_serialize(self, metadata, metadata_mask):
+ c = OFPInstructionWriteMetadata(metadata,
+ metadata_mask)
+
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+ eq_(res[2], metadata)
+ eq_(res[3], metadata_mask)
+
+ def test_serialize_metadata_mid(self):
+ self._test_serialize(self.metadata, self.metadata_mask)
+
+ def test_serialize_metadata_max(self):
+ metadata = 0xffffffffffffffff
+ self._test_serialize(metadata, self.metadata_mask)
+
+ def test_serialize_metadata_min(self):
+ metadata = 0
+ self._test_serialize(metadata, self.metadata_mask)
+
+ def test_serialize_metadata_mask_max(self):
+ metadata_mask = 0xffffffffffffffff
+ self._test_serialize(self.metadata, metadata_mask)
+
+ def test_serialize_metadata_mask_min(self):
+ metadata_mask = 0
+ self._test_serialize(self.metadata, metadata_mask)
+
+
+class TestOFPInstructionActions(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPInstructionActions
+ """
+ # OFP_INSTRUCTION_ACTIONS_PACK_STR
+ # '!HH4x'...type, len, pad(4)
+ type_ = ofproto.OFPIT_WRITE_ACTIONS
+ len_ = ofproto.OFP_INSTRUCTION_ACTIONS_SIZE \
+ + ofproto.OFP_ACTION_OUTPUT_SIZE
+
+ fmt = ofproto.OFP_INSTRUCTION_ACTIONS_PACK_STR
+ buf = pack(fmt, type_, len_)
+
+ # OFP_ACTION (OFP_ACTION_OUTPUT)
+ port = 0x00002ae0
+ max_len = ofproto.OFP_ACTION_OUTPUT_SIZE
+ actions = [OFPActionOutput(port, max_len)]
+ buf_actions = bytearray()
+ actions[0].serialize(buf_actions, 0)
+
+ buf += six.binary_type(buf_actions)
+
+ def test_init(self):
+ c = OFPInstructionActions(self.type_, self.actions)
+
+ eq_(self.type_, c.type)
+ eq_(self.actions, c.actions)
+
+ def _test_parser(self, action_cnt):
+ # OFP_INSTRUCTION_ACTIONS_PACK_STR
+ # '!HH4x'...type, len, pad(4)
+ len_ = ofproto.OFP_INSTRUCTION_ACTIONS_SIZE \
+ + (ofproto.OFP_ACTION_OUTPUT_SIZE * action_cnt)
+
+ fmt = ofproto.OFP_INSTRUCTION_ACTIONS_PACK_STR
+ buf = pack(fmt, self.type_, len_)
+
+ actions = []
+ for a in range(action_cnt):
+ # OFP_ACTION (OFP_ACTION_OUTPUT)
+ port = a
+ action = OFPActionOutput(port, self.max_len)
+ actions.append(action)
+ buf_actions = bytearray()
+ actions[a].serialize(buf_actions, 0)
+ buf += six.binary_type(buf_actions)
+
+ res = OFPInstructionActions.parser(buf, 0)
+
+ # 8
+ eq_(res.len, len_)
+ eq_(res.type, self.type_)
+
+ # 8 + 16 * action_cnt < 65535 byte
+ # action_cnt <= 4095
+ for a in range(action_cnt):
+ eq_(res.actions[a].type, actions[a].type)
+ eq_(res.actions[a].len, actions[a].len)
+ eq_(res.actions[a].port, actions[a].port)
+ eq_(res.actions[a].max_len, actions[a].max_len)
+
+ def test_parser_mid(self):
+ self._test_parser(2047)
+
+ def test_parser_max(self):
+ self._test_parser(4095)
+
+ def test_parser_min(self):
+ self._test_parser(0)
+
+ def _test_serialize(self, action_cnt):
+ # OFP_INSTRUCTION_ACTIONS_PACK_STR
+ # '!HH4x'...type, len, pad(4)
+ len_ = ofproto.OFP_INSTRUCTION_ACTIONS_SIZE \
+ + (ofproto.OFP_ACTION_OUTPUT_SIZE * action_cnt)
+
+ actions = []
+ for a in range(action_cnt):
+ # OFP_ACTION (OFP_ACTION_OUTPUT)
+ port = a
+ action = OFPActionOutput(port, self.max_len)
+ actions.append(action)
+
+ c = OFPInstructionActions(self.type_, actions)
+
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ fmt = '!' \
+ + ofproto.OFP_INSTRUCTION_ACTIONS_PACK_STR.replace('!', '')
+
+ for a in range(action_cnt):
+ fmt += ofproto.OFP_ACTION_OUTPUT_PACK_STR.replace('!', '')
+ res = struct.unpack(fmt, six.binary_type(buf))
+
+ eq_(res[0], self.type_)
+ eq_(res[1], len_)
+
+ for a in range(action_cnt):
+ d = 2 + a * 4
+ eq_(res[d], actions[a].type)
+ eq_(res[d + 1], actions[a].len)
+ eq_(res[d + 2], actions[a].port)
+ eq_(res[d + 3], actions[a].max_len)
+
+ def test_serialize_mid(self):
+ self._test_serialize(2047)
+
+ def test_serialize_max(self):
+ self._test_serialize(4095)
+
+ def test_serialize_min(self):
+ self._test_serialize(0)
+
+
+class TestOFPActionHeader(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionHeader
+ """
+
+ def test_init(self):
+ # OFP_ACTION_HEADER_PACK_STR
+ # '!HH4x'...type, len, pad(4)
+ type_ = ofproto.OFPAT_OUTPUT
+ len_ = ofproto.OFP_ACTION_HEADER_SIZE
+
+ fmt = ofproto.OFP_ACTION_HEADER_PACK_STR
+ buf = pack(fmt, type_, len_)
+
+ c = OFPActionHeader(type_, len_)
+
+ eq_(type_, c.type)
+ eq_(len_, c.len)
+
+ def _test_serialize(self, type_, len_):
+ # OFP_ACTION_HEADER_PACK_STR
+ # '!HH4x'...type, len, pad(4)
+
+ fmt = ofproto.OFP_ACTION_HEADER_PACK_STR
+ buf = pack(fmt, type_, len_)
+
+ c = OFPActionHeader(type_, len_)
+
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ fmt = ofproto.OFP_ACTION_HEADER_PACK_STR
+ res = struct.unpack(fmt, six.binary_type(buf))
+
+ eq_(res[0], type_)
+ eq_(res[1], len_)
+
+ def test_serialize_mid(self):
+ type_ = 11
+ len_ = 8
+ self._test_serialize(type_, len_)
+
+ def test_serialize_max(self):
+ type_ = 0xffff
+ len_ = 0xffff
+ self._test_serialize(type_, len_)
+
+ def test_serialize_min(self):
+ type_ = 0
+ len_ = 0
+ self._test_serialize(type_, len_)
+
+
+class TestOFPActionOutput(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionOutput
+ """
+
+ # OFP_ACTION_OUTPUT_PACK_STR
+ # '!HHIH6x'...type, len, port, max_len, pad(6)
+ type_ = ofproto.OFPAT_OUTPUT
+ len_ = ofproto.OFP_ACTION_OUTPUT_SIZE
+
+ def test_init(self):
+ port = 6606
+ max_len = 1500
+ fmt = ofproto.OFP_ACTION_OUTPUT_PACK_STR
+ c = OFPActionOutput(port, max_len)
+ eq_(port, c.port)
+ eq_(max_len, c.max_len)
+
+ def _test_parser(self, port, max_len):
+ fmt = ofproto.OFP_ACTION_OUTPUT_PACK_STR
+ buf = pack(fmt, self.type_, self.len_, port, max_len)
+
+ c = OFPActionOutput(port, max_len)
+
+ res = c.parser(buf, 0)
+
+ eq_(res.len, self.len_)
+ eq_(res.type, self.type_)
+ eq_(res.port, port)
+ eq_(res.max_len, max_len)
+
+ def test_parser_mid(self):
+ port = 6606
+ max_len = 16
+ self._test_parser(port, max_len)
+
+ def test_parser_max(self):
+ port = 4294967295
+ max_len = 0xffff
+ self._test_parser(port, max_len)
+
+ def test_parser_min(self):
+ port = 0
+ max_len = 0
+ self._test_parser(port, max_len)
+
+ def test_parser_p1(self):
+ port = 6606
+ max_len = 0xffe5
+ self._test_parser(port, max_len)
+
+ def _test_serialize(self, port, max_len):
+ c = OFPActionOutput(port, max_len)
+
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ fmt = ofproto.OFP_ACTION_OUTPUT_PACK_STR
+ res = struct.unpack(fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+ eq_(res[2], port)
+ eq_(res[3], max_len)
+
+ def test_serialize_mid(self):
+ port = 6606
+ max_len = 16
+ self._test_serialize(port, max_len)
+
+ def test_serialize_max(self):
+ port = 4294967295
+ max_len = 0xffff
+ self._test_serialize(port, max_len)
+
+ def test_serialize_min(self):
+ port = 0
+ max_len = 0
+ self._test_serialize(port, max_len)
+
+ def test_serialize_p1(self):
+ port = 6606
+ max_len = 0xffe5
+ self._test_serialize(port, max_len)
+
+
+class TestOFPActionGroup(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionGroup
+ """
+
+ # OFP_ACTION_GROUP_PACK_STR
+ # '!HHI'...type, len, group_id
+ type_ = ofproto.OFPAT_GROUP
+ len_ = ofproto.OFP_ACTION_GROUP_SIZE
+ group_id = 6606
+
+ fmt = ofproto.OFP_ACTION_GROUP_PACK_STR
+
+ def test_init(self):
+ c = OFPActionGroup(self.group_id)
+ eq_(self.group_id, c.group_id)
+
+ def _test_parser(self, group_id):
+ buf = pack(self.fmt, self.type_, self.len_, group_id)
+
+ res = OFPActionGroup.parser(buf, 0)
+ eq_(res.len, self.len_)
+ eq_(res.type, self.type_)
+ eq_(res.group_id, group_id)
+
+ def test_parser_mid(self):
+ self._test_parser(self.group_id)
+
+ def test_parser_max(self):
+ self._test_parser(4294967295)
+
+ def test_parser_min(self):
+ self._test_parser(0)
+
+ def _test_serialize(self, group_id):
+ c = OFPActionGroup(group_id)
+
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+ eq_(res[2], group_id)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.group_id)
+
+ def test_serialize_max(self):
+ self._test_serialize(4294967295)
+
+ def test_serialize_min(self):
+ self._test_serialize(0)
+
+
+class TestOFPActionSetQueue(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionSetQueue
+ """
+
+ # OFP_ACTION_SET_QUEUE_PACK_STR
+ # '!HHI'...type, len, queue_id
+ type_ = ofproto.OFPAT_SET_QUEUE
+ len_ = ofproto.OFP_ACTION_SET_QUEUE_SIZE
+ queue_id = 6606
+
+ fmt = ofproto.OFP_ACTION_SET_QUEUE_PACK_STR
+
+ def test_init(self):
+ c = OFPActionSetQueue(self.queue_id)
+ eq_(self.queue_id, c.queue_id)
+
+ def _test_parser(self, queue_id):
+ buf = pack(self.fmt, self.type_, self.len_, queue_id)
+
+ res = OFPActionSetQueue.parser(buf, 0)
+ eq_(res.len, self.len_)
+ eq_(res.type, self.type_)
+ eq_(res.queue_id, queue_id)
+
+ def test_parser_mid(self):
+ self._test_parser(self.queue_id)
+
+ def test_parser_max(self):
+ self._test_parser(4294967295)
+
+ def test_parser_min(self):
+ self._test_parser(0)
+
+ def _test_serialize(self, queue_id):
+ c = OFPActionSetQueue(queue_id)
+
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+ eq_(res[2], queue_id)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.queue_id)
+
+ def test_serialize_max(self):
+ self._test_serialize(4294967295)
+
+ def test_serialize_min(self):
+ self._test_serialize(0)
+
+
+class TestOFPActionSetMplsTtl(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionSetMplsTtl
+ """
+
+ # OFP_ACTION_MPLS_TTL_PACK_STR
+ # '!HHB3x'...type, len, mpls_ttl, pad(3)
+ type_ = ofproto.OFPAT_SET_MPLS_TTL
+ len_ = ofproto.OFP_ACTION_MPLS_TTL_SIZE
+ mpls_ttl = 254
+
+ fmt = ofproto.OFP_ACTION_MPLS_TTL_PACK_STR
+
+ def test_init(self):
+ c = OFPActionSetMplsTtl(self.mpls_ttl)
+ eq_(self.mpls_ttl, c.mpls_ttl)
+
+ def _test_parser(self, mpls_ttl):
+ buf = pack(self.fmt, self.type_, self.len_, mpls_ttl)
+
+ res = OFPActionSetMplsTtl.parser(buf, 0)
+ eq_(res.len, self.len_)
+ eq_(res.type, self.type_)
+ eq_(res.mpls_ttl, mpls_ttl)
+
+ def test_parser_mid(self):
+ self._test_parser(self.mpls_ttl)
+
+ def test_parser_max(self):
+ self._test_parser(255)
+
+ def test_parser_min(self):
+ self._test_parser(0)
+
+ def _test_serialize(self, mpls_ttl):
+ c = OFPActionSetMplsTtl(mpls_ttl)
+
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+ eq_(res[2], mpls_ttl)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.mpls_ttl)
+
+ def test_serialize_max(self):
+ self._test_serialize(255)
+
+ def test_serialize_min(self):
+ self._test_serialize(0)
+
+
+class TestOFPActionDecMplsTtl(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionDecMplsTtl
+ """
+
+ type_ = ofproto.OFPAT_DEC_MPLS_TTL
+ len_ = ofproto.OFP_ACTION_MPLS_TTL_SIZE
+ fmt = ofproto.OFP_ACTION_HEADER_PACK_STR
+ buf = pack(fmt, type_, len_)
+ c = OFPActionDecMplsTtl()
+
+ def test_parser(self):
+ res = self.c.parser(self.buf, 0)
+
+ eq_(res.len, self.len_)
+ eq_(res.type, self.type_)
+
+ def test_serialize(self):
+ buf = bytearray()
+ self.c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+
+
+class TestOFPActionSetNwTtl(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionSetNwTtl
+ """
+
+ # OFP_ACTION_NW_TTL_PACK_STR
+ # '!HHB3x'...type, len, nw_ttl, pad(3)
+ type_ = ofproto.OFPAT_SET_NW_TTL
+ len_ = ofproto.OFP_ACTION_NW_TTL_SIZE
+ nw_ttl = 240
+
+ fmt = ofproto.OFP_ACTION_NW_TTL_PACK_STR
+
+ def test_init(self):
+ c = OFPActionSetNwTtl(self.nw_ttl)
+ eq_(self.nw_ttl, c.nw_ttl)
+
+ def _test_parser(self, nw_ttl):
+ buf = pack(self.fmt, self.type_, self.len_, nw_ttl)
+
+ res = OFPActionSetNwTtl.parser(buf, 0)
+ eq_(res.type, self.type_)
+ eq_(res.len, self.len_)
+ eq_(res.nw_ttl, nw_ttl)
+
+ def test_parser_mid(self):
+ self._test_parser(self.nw_ttl)
+
+ def test_parser_max(self):
+ self._test_parser(255)
+
+ def test_parser_min(self):
+ self._test_parser(0)
+
+ def _test_serialize(self, nw_ttl):
+ c = OFPActionSetNwTtl(nw_ttl)
+
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+ eq_(res[2], nw_ttl)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.nw_ttl)
+
+ def test_serialize_max(self):
+ self._test_serialize(255)
+
+ def test_serialize_min(self):
+ self._test_serialize(0)
+
+
+class TestOFPActionDecNwTtl(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionDecNwTtl
+ """
+
+ type_ = ofproto.OFPAT_DEC_NW_TTL
+ len_ = ofproto.OFP_ACTION_NW_TTL_SIZE
+ fmt = ofproto.OFP_ACTION_HEADER_PACK_STR
+ buf = pack(fmt, type_, len_)
+ c = OFPActionDecNwTtl()
+
+ def test_parser(self):
+ res = self.c.parser(self.buf, 0)
+
+ eq_(res.len, self.len_)
+ eq_(res.type, self.type_)
+
+ def test_serialize(self):
+ buf = bytearray()
+ self.c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+
+
+class TestOFPActionCopyTtlOut(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionCopyTtlOut
+ """
+
+ type_ = ofproto.OFPAT_COPY_TTL_OUT
+ len_ = ofproto.OFP_ACTION_HEADER_SIZE
+ fmt = ofproto.OFP_ACTION_HEADER_PACK_STR
+ buf = pack(fmt, type_, len_)
+ c = OFPActionCopyTtlOut()
+
+ def test_parser(self):
+ res = self.c.parser(self.buf, 0)
+ eq_(res.len, self.len_)
+ eq_(res.type, self.type_)
+
+ def test_serialize(self):
+ buf = bytearray()
+ self.c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+
+
+class TestOFPActionCopyTtlIn(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionCopyTtlIn
+ """
+
+ # OFP_ACTION_HEADER_PACK_STR
+ # '!HH'...type, len
+ type_ = ofproto.OFPAT_COPY_TTL_IN
+ len_ = ofproto.OFP_ACTION_HEADER_SIZE
+ fmt = ofproto.OFP_ACTION_HEADER_PACK_STR
+ buf = pack(fmt, type_, len_)
+ c = OFPActionCopyTtlIn()
+
+ def test_parser(self):
+ res = self.c.parser(self.buf, 0)
+
+ eq_(res.len, self.len_)
+ eq_(res.type, self.type_)
+
+ def test_serialize(self):
+ buf = bytearray()
+ self.c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+
+
+class TestOFPActionPushVlan(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionPushVlan
+ """
+
+ # OFP_ACTION_PUSH_PACK_STR
+ # '!HHH2x'...type, len, ethertype, pad(2)
+ type_ = ofproto.OFPAT_PUSH_VLAN
+ len_ = ofproto.OFP_ACTION_PUSH_SIZE
+ fmt = ofproto.OFP_ACTION_PUSH_PACK_STR
+
+ def test_init(self):
+ ethertype = 0x8100
+ c = OFPActionPushVlan(ethertype)
+ eq_(ethertype, c.ethertype)
+
+ def _test_parser(self, ethertype):
+ buf = pack(self.fmt, self.type_, self.len_, ethertype)
+
+ res = OFPActionPushVlan.parser(buf, 0)
+ eq_(res.type, self.type_)
+ eq_(res.len, self.len_)
+ eq_(res.ethertype, ethertype)
+
+ def test_parser_mid(self):
+ self._test_parser(0x8100)
+
+ def test_parser_max(self):
+ self._test_parser(0xffff)
+
+ def test_parser_min(self):
+ self._test_parser(0)
+
+ def _test_serialize(self, ethertype):
+ c = OFPActionPushVlan(ethertype)
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+ eq_(res[2], ethertype)
+
+ def test_serialize_mid(self):
+ self._test_serialize(0x8100)
+
+ def test_serialize_max(self):
+ self._test_serialize(0xffff)
+
+ def test_serialize_min(self):
+ self._test_serialize(0)
+
+
+class TestOFPActionPushMpls(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionPushMpls
+ """
+
+ # OFP_ACTION_PUSH_PACK_STR
+ # '!HHH2x'...type, len, ethertype, pad(2)
+ type_ = ofproto.OFPAT_PUSH_MPLS
+ len_ = ofproto.OFP_ACTION_PUSH_SIZE
+ fmt = ofproto.OFP_ACTION_PUSH_PACK_STR
+
+ def test_init(self):
+ ethertype = 0x8100
+ c = OFPActionPushMpls(ethertype)
+ eq_(ethertype, c.ethertype)
+
+ def _test_parser(self, ethertype):
+ buf = pack(self.fmt, self.type_, self.len_, ethertype)
+
+ res = OFPActionPushMpls.parser(buf, 0)
+ eq_(res.type, self.type_)
+ eq_(res.len, self.len_)
+ eq_(res.ethertype, ethertype)
+
+ def test_parser_mid(self):
+ self._test_parser(0x8100)
+
+ def test_parser_max(self):
+ self._test_parser(0xffff)
+
+ def test_parser_min(self):
+ self._test_parser(0)
+
+ def _test_serialize(self, ethertype):
+ c = OFPActionPushMpls(ethertype)
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+ eq_(res[2], ethertype)
+
+ def test_serialize_mid(self):
+ self._test_serialize(0x8100)
+
+ def test_serialize_max(self):
+ self._test_serialize(0xffff)
+
+ def test_serialize_min(self):
+ self._test_serialize(0)
+
+
+class TestOFPActionPopVlan(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionPopVlan
+ """
+
+ # OFP_ACTION_HEADER_PACK_STR
+ # '!HH'...type, len
+ type_ = ofproto.OFPAT_POP_VLAN
+ len_ = ofproto.OFP_ACTION_HEADER_SIZE
+ fmt = ofproto.OFP_ACTION_HEADER_PACK_STR
+ buf = pack(fmt, type_, len_)
+ c = OFPActionPopVlan()
+
+ def test_parser(self):
+ res = self.c.parser(self.buf, 0)
+ eq_(self.type_, res.type)
+ eq_(self.len_, res.len)
+
+ def test_serialize(self):
+ buf = bytearray()
+ self.c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+
+
+class TestOFPActionPopMpls(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionPopMpls
+ """
+
+ # OFP_ACTION_POP_MPLS_PACK_STR
+ # '!HHH2x'...type, len, ethertype, pad(2)
+ type_ = ofproto.OFPAT_POP_MPLS
+ len_ = ofproto.OFP_ACTION_POP_MPLS_SIZE
+ fmt = ofproto.OFP_ACTION_POP_MPLS_PACK_STR
+
+ def test_init(self):
+ ethertype = 0x8100
+ c = OFPActionPopMpls(ethertype)
+ eq_(ethertype, c.ethertype)
+
+ def _test_parser(self, ethertype):
+ buf = pack(self.fmt, self.type_, self.len_, ethertype)
+
+ res = OFPActionPopMpls.parser(buf, 0)
+ eq_(res.type, self.type_)
+ eq_(res.len, self.len_)
+ eq_(res.ethertype, ethertype)
+
+ def test_parser_mid(self):
+ self._test_parser(0x8100)
+
+ def test_parser_max(self):
+ self._test_parser(0xffff)
+
+ def test_parser_min(self):
+ self._test_parser(0)
+
+ def _test_serialize(self, ethertype):
+ c = OFPActionPopMpls(ethertype)
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+ eq_(res[2], ethertype)
+
+ def test_serialize_mid(self):
+ self._test_serialize(0x8100)
+
+ def test_serialize_max(self):
+ self._test_serialize(0xffff)
+
+ def test_serialize_min(self):
+ self._test_serialize(0)
+
+
+class TestOFPActionSetField(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionSetField
+ """
+
+ type_ = ofproto.OFPAT_SET_FIELD
+ header = ofproto.OXM_OF_IN_PORT
+ in_port = 6606
+
+ field = MTInPort(header, in_port)
+ length = ofproto.OFP_ACTION_SET_FIELD_SIZE + field.oxm_len()
+ len_ = utils.round_up(length, 8)
+
+ fmt = '!HHII4x'
+ buf = pack(fmt, type_, len_, header, in_port)
+
+ c = OFPActionSetField(field)
+
+ def test_init(self):
+ eq_(self.field, self.c.field)
+
+ def test_parser(self):
+ res = self.c.parser(self.buf, 0)
+
+ eq_(res.type, self.type_)
+ eq_(res.len, self.len_)
+ eq_(res.field.header, self.header)
+ eq_(res.field.value, self.in_port)
+
+ def test_serialize(self):
+ buf = bytearray()
+ self.c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+ eq_(res[2], self.header)
+ eq_(res[3], self.in_port)
+
+
+class TestOFPActionExperimenter(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPActionExperimenter
+ """
+
+ # OFP_ACTION_EXPERIMENTER_HEADER_PACK_STR v1.2
+ # '!HHI'...type, len, experimenter
+ type_ = ofproto.OFPAT_EXPERIMENTER
+ len_ = ofproto.OFP_ACTION_EXPERIMENTER_HEADER_SIZE
+ fmt = ofproto.OFP_ACTION_EXPERIMENTER_HEADER_PACK_STR
+
+ def test_init(self):
+ experimenter = 4294967295
+ c = OFPActionExperimenter(experimenter)
+ eq_(experimenter, c.experimenter)
+
+ def _test_parser(self, experimenter):
+ buf = pack(self.fmt, self.type_, self.len_, experimenter)
+
+ res = OFPActionExperimenter.parser(buf, 0)
+ eq_(res.type, self.type_)
+ eq_(res.len, self.len_)
+ eq_(res.experimenter, experimenter)
+
+ def test_parser_mid(self):
+ experimenter = 2147483648
+ self._test_parser(experimenter)
+
+ def test_parser_max(self):
+ experimenter = 4294967295
+ self._test_parser(experimenter)
+
+ def test_parser_min(self):
+ experimenter = 0
+ self._test_parser(experimenter)
+
+ def _test_serialize(self, experimenter):
+ c = OFPActionExperimenter(experimenter)
+
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ res = struct.unpack(self.fmt, six.binary_type(buf))
+ eq_(res[0], self.type_)
+ eq_(res[1], self.len_)
+ eq_(res[2], experimenter)
+
+ def test_serialize_mid(self):
+ experimenter = 2147483648
+ self._test_serialize(experimenter)
+
+ def test_serialize_max(self):
+ experimenter = 4294967295
+ self._test_serialize(experimenter)
+
+ def test_serialize_min(self):
+ experimenter = 0
+ self._test_serialize(experimenter)
+
+
+class TestOFPBucket(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPBucket
+ """
+
+ def test_init(self):
+ # OFP_BUCKET_PACK_STR
+ # '!HHII4x'...len, weight, watch_port, watch_group, pad(4)
+ weight = 4386
+ watch_port = 6606
+ watch_group = 3
+
+ # OFP_ACTION (OFP_ACTION_OUTPUT)
+ port = 3
+ max_len = 1500
+ actions = [OFPActionOutput(port, max_len)]
+
+ c = OFPBucket(weight, watch_port, watch_group, actions)
+ eq_(weight, c.weight)
+ eq_(watch_port, c.watch_port)
+ eq_(watch_group, c.watch_group)
+ eq_(1, len(c.actions))
+ eq_(port, c.actions[0].port)
+ eq_(max_len, c.actions[0].max_len)
+
+ def _test_parser(self, weight, watch_port, watch_group, action_cnt):
+ # OFP_BUCKET_PACK_STR
+ # '!HHII4x'...len, weight, watch_port, watch_group, pad(4)
+ len_ = ofproto.OFP_BUCKET_SIZE \
+ + (ofproto.OFP_ACTION_OUTPUT_SIZE * action_cnt)
+
+ fmt = ofproto.OFP_BUCKET_PACK_STR
+ buf = pack(fmt, len_, weight, watch_port, watch_group)
+
+ actions = []
+ for a in range(action_cnt):
+ # OFP_ACTION (OFP_ACTION_OUTPUT)
+ port = a
+ max_len = ofproto.OFP_ACTION_OUTPUT_SIZE
+ action = OFPActionOutput(port, max_len)
+ actions.append(action)
+ buf_actions = bytearray()
+ actions[a].serialize(buf_actions, 0)
+ buf += six.binary_type(buf_actions)
+
+ res = OFPBucket.parser(buf, 0)
+
+ # 16
+ eq_(weight, res.weight)
+ eq_(watch_port, res.watch_port)
+ eq_(watch_group, res.watch_group)
+
+ # 16 + 16 * action_cnt < 65535 byte
+ # action_cnt <= 4094
+ for a in range(action_cnt):
+ eq_(actions[a].type, res.actions[a].type)
+ eq_(actions[a].len, res.actions[a].len)
+ eq_(actions[a].port, res.actions[a].port)
+ eq_(actions[a].max_len, res.actions[a].max_len)
+
+ def test_parser_mid(self):
+ weight = 4386
+ watch_port = 6606
+ watch_group = 3
+ action_cnt = 2047
+ self._test_parser(weight, watch_port,
+ watch_group, action_cnt)
+
+ def test_parser_max(self):
+ weight = 65535
+ watch_port = 4294967295
+ watch_group = 4294967295
+ action_cnt = 4094
+ self._test_parser(weight, watch_port,
+ watch_group, action_cnt)
+
+ def test_parser_min(self):
+ weight = 0
+ watch_port = 0
+ watch_group = 0
+ action_cnt = 0
+ self._test_parser(weight, watch_port,
+ watch_group, action_cnt)
+
+ def _test_serialize(self, weight, watch_port, watch_group,
+ action_cnt):
+ # OFP_BUCKET_PACK_STR
+ # '!HHII4x'...len, weight, watch_port, watch_group, pad(4)
+ len_ = ofproto.OFP_BUCKET_SIZE \
+ + (ofproto.OFP_ACTION_OUTPUT_SIZE * action_cnt)
+
+ actions = []
+ for a in range(action_cnt):
+ # OFP_ACTION (OFP_ACTION_OUTPUT)
+ port = a
+ max_len = ofproto.OFP_ACTION_OUTPUT_SIZE
+ action = OFPActionOutput(port, max_len)
+ actions.append(action)
+
+ c = OFPBucket(weight, watch_port, watch_group, actions)
+
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ fmt = ofproto.OFP_BUCKET_PACK_STR
+ for a in range(action_cnt):
+ fmt += ofproto.OFP_ACTION_OUTPUT_PACK_STR[1:]
+ res = struct.unpack(fmt, six.binary_type(buf))
+
+ eq_(res[0], len_)
+ eq_(res[1], weight)
+ eq_(res[2], watch_port)
+ eq_(res[3], watch_group)
+
+ for a in range(action_cnt):
+ d = 4 + a * 4
+ eq_(res[d], actions[a].type)
+ eq_(res[d + 1], actions[a].len)
+ eq_(res[d + 2], actions[a].port)
+ eq_(res[d + 3], actions[a].max_len)
+
+ def test_serialize_mid(self):
+ weight = 4386
+ watch_port = 6606
+ watch_group = 3
+ action_cnt = 2047
+ self._test_serialize(weight, watch_port,
+ watch_group, action_cnt)
+
+ def test_serialize_max(self):
+ weight = 65535
+ watch_port = 4294967295
+ watch_group = 4294967295
+ action_cnt = 4094
+ self._test_serialize(weight, watch_port,
+ watch_group, action_cnt)
+
+ def test_serialize_min(self):
+ weight = 0
+ watch_port = 0
+ watch_group = 0
+ action_cnt = 0
+ self._test_serialize(weight, watch_port,
+ watch_group, action_cnt)
+
+
+class TestOFPGroupMod(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPGroupMod
+ """
+
+ def test_init(self):
+ # OFP_GROUP_MOD_PACK_STR
+ # '!HBBI'...command, type, pad, group_id
+ command = ofproto.OFPFC_ADD
+ type_ = ofproto.OFPGT_SELECT
+ group_id = 6606
+
+ # OFP_BUCKET
+ weight = 4386
+ watch_port = 8006
+ watch_group = 3
+
+ # OFP_ACTION (OFP_ACTION_OUTPUT)
+ port = 10
+ max_len = 2000
+ actions = [OFPActionOutput(port, max_len)]
+
+ buckets = [OFPBucket(weight, watch_port, watch_group, actions)]
+
+ c = OFPGroupMod(_Datapath, command, type_, group_id, buckets)
+ eq_(command, c.command)
+ eq_(type_, c.type)
+ eq_(group_id, c.group_id)
+ eq_(1, len(c.buckets))
+ eq_(1, len(c.buckets[0].actions))
+ eq_(port, c.buckets[0].actions[0].port)
+ eq_(max_len, c.buckets[0].actions[0].max_len)
+
+ def _test_serialize(self, command, type_, group_id, bucket_cnt):
+ len_ = ofproto.OFP_BUCKET_SIZE \
+ + ofproto.OFP_ACTION_OUTPUT_SIZE
+
+ buckets = []
+ for b in range(bucket_cnt):
+ # OFP_BUCKET
+ weight = watch_port = watch_group = port = b
+ actions = [OFPActionOutput(port, 0)]
+ bucket = OFPBucket(weight, watch_port, watch_group, actions)
+ buckets.append(bucket)
+
+ c = OFPGroupMod(_Datapath, command, type_, group_id, buckets)
+
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_GROUP_MOD, c.msg_type)
+ eq_(0, c.xid)
+ eq_(len(c.buf), c.msg_len)
+
+ # 16 byte
+ fmt = ofproto.OFP_HEADER_PACK_STR \
+ + ofproto.OFP_GROUP_MOD_PACK_STR[1:]
+
+ # 16 + (16 + 16) * bucket_cnt < 65535 byte
+ # bucket_cnt <= 2047
+ for b in range(bucket_cnt):
+ fmt += ofproto.OFP_BUCKET_PACK_STR[1:] \
+ + ofproto.OFP_ACTION_OUTPUT_PACK_STR[1:]
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ msg_len = ofproto.OFP_GROUP_MOD_SIZE \
+ + (len_ * bucket_cnt)
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_GROUP_MOD)
+ eq_(res[2], msg_len)
+ eq_(res[3], 0)
+ eq_(res[4], command)
+ eq_(res[5], type_)
+ eq_(res[6], group_id)
+
+ for d in range(bucket_cnt):
+ e = 7 + d * 8
+ eq_(res[e + 1], buckets[d].weight)
+ eq_(res[e + 2], buckets[d].watch_port)
+ eq_(res[e + 3], buckets[d].watch_group)
+ eq_(res[e + 4], buckets[d].actions[0].type)
+ eq_(res[e + 5], buckets[d].actions[0].len)
+ eq_(res[e + 6], buckets[d].actions[0].port)
+ eq_(res[e + 7], buckets[d].actions[0].max_len)
+
+ def test_serialize_mid(self):
+ command = 32768
+ type_ = 128
+ group_id = 6606
+ bucket_cnt = 1023
+ self._test_serialize(command, type_, group_id, bucket_cnt)
+
+ def test_serialize_max(self):
+ command = 65535
+ type_ = 255
+ group_id = 4294967295
+ bucket_cnt = 2047
+ self._test_serialize(command, type_, group_id, bucket_cnt)
+
+ def test_serialize_min(self):
+ command = 0
+ type_ = 0
+ group_id = 0
+ bucket_cnt = 0
+ self._test_serialize(command, type_, group_id, bucket_cnt)
+
+ def test_serialize_p1(self):
+ command = 1
+ type_ = 1
+ group_id = 6606
+ bucket_cnt = 1023
+ self._test_serialize(command, type_, group_id, bucket_cnt)
+
+ def test_serialize_p2(self):
+ command = 1
+ type_ = 2
+ group_id = 6606
+ bucket_cnt = 1023
+ self._test_serialize(command, type_, group_id, bucket_cnt)
+
+ def test_serialize_p3(self):
+ command = 2
+ type_ = 3
+ group_id = 6606
+ bucket_cnt = 1023
+ self._test_serialize(command, type_, group_id, bucket_cnt)
+
+
+class TestOFPPortMod(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPPortMod
+ """
+
+ # OFP_PORT_MOD_PACK_STR v1.2
+ # '!I4xs2xIII4x'...port_no, pad(4), hw_addr, pad(2),
+ # config, mask, advertise, pad(4)
+ port_no = 1119692796
+ hw_addr = 'e8:fe:5e:a9:68:6c'
+ config = 2226555987
+ mask = 1678244809
+ advertise = 2025421682
+
+ def test_init(self):
+ c = OFPPortMod(_Datapath, self.port_no, self.hw_addr,
+ self.config, self.mask, self.advertise)
+ eq_(self.port_no, c.port_no)
+ eq_(self.hw_addr, c.hw_addr)
+ eq_(self.config, c.config)
+ eq_(self.mask, c.mask)
+ eq_(self.advertise, c.advertise)
+
+ def _test_serialize(self, port_no, hw_addr, config, mask, advertise):
+ c = OFPPortMod(_Datapath, port_no, hw_addr, config,
+ mask, advertise)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_PORT_MOD, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + ofproto.OFP_PORT_MOD_PACK_STR.replace('!', '')
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_PORT_MOD)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], port_no)
+ eq_(res[5], addrconv.mac.text_to_bin(hw_addr))
+ eq_(res[6], config)
+ eq_(res[7], mask)
+ eq_(res[8], advertise)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.port_no, self.hw_addr,
+ self.config, self.mask, self.advertise)
+
+ def test_serialize_max(self):
+ port_no = ofproto.OFPP_ANY
+ hw_addr = 'ff:ff:ff:ff:ff:ff'
+ config = 0xffffffff
+ mask = 0xffffffff
+ advertise = 0xffffffff
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_min(self):
+ port_no = 0
+ hw_addr = '00:00:00:00:00:00'
+ config = 0
+ mask = 0
+ advertise = 0
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p1(self):
+ port_no = ofproto.OFPP_MAX
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_PORT_DOWN
+ mask = ofproto.OFPPC_PORT_DOWN
+ advertise = ofproto.OFPPF_10MB_HD
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p2(self):
+ port_no = ofproto.OFPP_IN_PORT
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_RECV
+ mask = ofproto.OFPPC_NO_RECV
+ advertise = ofproto.OFPPF_10MB_FD
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p3(self):
+ port_no = ofproto.OFPP_TABLE
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_FWD
+ mask = ofproto.OFPPC_NO_FWD
+ advertise = ofproto.OFPPF_100MB_HD
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p4(self):
+ port_no = ofproto.OFPP_NORMAL
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_100MB_FD
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p5(self):
+ port_no = ofproto.OFPP_FLOOD
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_1GB_HD
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p6(self):
+ port_no = ofproto.OFPP_ALL
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_1GB_FD
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p7(self):
+ port_no = ofproto.OFPP_CONTROLLER
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_10GB_FD
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p8(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_40GB_FD
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p9(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_100GB_FD
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p10(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_1TB_FD
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p11(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_OTHER
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p12(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_COPPER
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p13(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_FIBER
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p14(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_AUTONEG
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p15(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_PAUSE
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+ def test_serialize_p16(self):
+ port_no = ofproto.OFPP_LOCAL
+ hw_addr = self.hw_addr
+ config = ofproto.OFPPC_NO_PACKET_IN
+ mask = ofproto.OFPPC_NO_PACKET_IN
+ advertise = ofproto.OFPPF_PAUSE_ASYM
+ self._test_serialize(port_no, hw_addr, config, mask, advertise)
+
+
+class TestOFPTableMod(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPTableMod
+ """
+
+ # OFP_PORT_TABLE_PACK_STR v1.2
+ # '!B3xI'...table_id, pad(3), config
+ table_id = 3
+ config = 2226555987
+
+ def test_init(self):
+ c = OFPTableMod(_Datapath, self.table_id, self.config)
+ eq_(self.table_id, c.table_id)
+ eq_(self.config, c.config)
+
+ def _test_serialize(self, table_id, config):
+ c = OFPTableMod(_Datapath, table_id, config)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_TABLE_MOD, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + ofproto.OFP_TABLE_MOD_PACK_STR.replace('!', '')
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_TABLE_MOD)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], table_id)
+ eq_(res[5], config)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.table_id, self.config)
+
+ def test_serialize_max(self):
+ table_id = ofproto.OFPTT_ALL
+ config = 0xffffffff
+ self._test_serialize(table_id, config)
+
+ def test_serialize_min(self):
+ table_id = 0
+ config = 0
+ self._test_serialize(table_id, config)
+
+ def test_serialize_p1(self):
+ table_id = ofproto.OFPTT_MAX
+ config = ofproto.OFPTC_TABLE_MISS_CONTINUE
+ self._test_serialize(table_id, config)
+
+ def test_serialize_p2(self):
+ table_id = ofproto.OFPTT_MAX
+ config = ofproto.OFPTC_TABLE_MISS_DROP
+ self._test_serialize(table_id, config)
+
+ def test_serialize_p3(self):
+ table_id = ofproto.OFPTT_MAX
+ config = ofproto.OFPTC_TABLE_MISS_MASK
+ self._test_serialize(table_id, config)
+
+
+class TestOFPStatsRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPStatsRequest
+ """
+
+ type_ = ofproto.OFPST_DESC
+ c = OFPStatsRequest(_Datapath, type_)
+
+ def test_init(self):
+ eq_(self.type_, self.c.type)
+ eq_(0, self.c.flags)
+
+ def test_serialize_body(self):
+ len_ = ofproto.OFP_HEADER_SIZE \
+ + ofproto.OFP_STATS_REQUEST_SIZE
+ self.c.buf = bytearray(len_)
+ self.c._serialize_body()
+
+ fmt = ofproto.OFP_STATS_REQUEST_PACK_STR
+ res = struct.unpack_from(fmt, six.binary_type(self.c.buf),
+ ofproto.OFP_HEADER_SIZE)
+
+ eq_(res[0], self.type_)
+ eq_(res[1], 0)
+
+
+class TestOFPStatsReply(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPStatsReply
+ """
+
+ c = OFPStatsReply(_Datapath)
+
+ def test_parser_single_struct_true(self):
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_STATS_REPLY
+ msg_len = ofproto.OFP_STATS_REPLY_SIZE \
+ + ofproto.OFP_AGGREGATE_STATS_REPLY_SIZE
+ xid = 2495926989
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ # OFP_STATS_REPLY_PACK_STR
+ # '!HH4x'...type, flags, pad(4)
+ type_ = ofproto.OFPST_AGGREGATE
+ flags = 41802
+
+ fmt = ofproto.OFP_STATS_REPLY_PACK_STR
+ buf += pack(fmt, type_, flags)
+
+ # OFP_AGGREGATE_STATS_REPLY_PACK_STR
+ packet_count = 5142202600015232219
+ byte_count = 2659740543924820419
+ flow_count = 1344694860
+ body = OFPAggregateStatsReply(packet_count, byte_count, flow_count)
+
+ fmt = ofproto.OFP_AGGREGATE_STATS_REPLY_PACK_STR
+ buf += pack(fmt, packet_count, byte_count, flow_count)
+
+ res = self.c.parser(object, version, msg_type, msg_len, xid, buf)
+
+ eq_(version, res.version)
+ eq_(msg_type, res.msg_type)
+ eq_(msg_len, res.msg_len)
+ eq_(xid, res.xid)
+ eq_(type_, res.type)
+ eq_(flags, res.flags)
+ eq_(packet_count, res.body.packet_count)
+ eq_(byte_count, res.body.byte_count)
+ eq_(flow_count, res.body.flow_count)
+
+ def test_parser_single_struct_flase(self):
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_STATS_REPLY
+ msg_len = ofproto.OFP_STATS_REPLY_SIZE \
+ + ofproto.OFP_QUEUE_STATS_SIZE
+ xid = 2495926989
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ # OFP_STATS_REPLY_PACK_STR
+ # '!HH4x'...type, flags, pad(4)
+ type_ = ofproto.OFPST_QUEUE
+ flags = 11884
+
+ fmt = ofproto.OFP_STATS_REPLY_PACK_STR
+ buf += pack(fmt, type_, flags)
+
+ # OFP_QUEUE_STATS_PACK_STR
+ port_no = 41186
+ queue_id = 6606
+ tx_bytes = 8638420181865882538
+ tx_packets = 2856480458895760962
+ tx_errors = 6283093430376743019
+ body = [OFPQueueStats(port_no, queue_id, tx_bytes, tx_packets,
+ tx_errors)]
+
+ fmt = ofproto.OFP_QUEUE_STATS_PACK_STR
+ buf += pack(fmt, port_no, queue_id, tx_bytes, tx_packets, tx_errors)
+
+ res = self.c.parser(object, version, msg_type, msg_len, xid, buf)
+
+ eq_(version, res.version)
+ eq_(msg_type, res.msg_type)
+ eq_(msg_len, res.msg_len)
+ eq_(xid, res.xid)
+ eq_(type_, res.type)
+ eq_(flags, res.flags)
+ eq_(port_no, res.body[0].port_no)
+ eq_(queue_id, res.body[0].queue_id)
+ eq_(tx_bytes, res.body[0].tx_bytes)
+ eq_(tx_packets, res.body[0].tx_packets)
+ eq_(tx_errors, res.body[0].tx_errors)
+
+ def test_parser_max(self):
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_STATS_REPLY
+ msg_len = ofproto.OFP_STATS_REPLY_SIZE
+ xid = 0xffffffff
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ # OFP_STATS_REPLY_PACK_STR
+ # '!HH4x'...type, flags, pad(4)
+ type_ = ofproto.OFPST_QUEUE
+ flags = 0xffff
+
+ fmt = ofproto.OFP_STATS_REPLY_PACK_STR
+ buf += pack(fmt, type_, flags)
+ res = self.c.parser(object, version, msg_type, msg_len, xid, buf)
+
+ eq_(version, res.version)
+ eq_(msg_type, res.msg_type)
+ eq_(msg_len, res.msg_len)
+ eq_(xid, res.xid)
+ eq_(type_, res.type)
+ eq_(flags, res.flags)
+
+ def test_parser_min(self):
+ # OFP_HEADER_PACK_STR
+ # '!BBHI'...version, msg_type, msg_len, xid
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_STATS_REPLY
+ msg_len = ofproto.OFP_STATS_REPLY_SIZE
+ xid = 0
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ # OFP_STATS_REPLY_PACK_STR
+ # '!HH4x'...type, flags, pad(4)
+ type_ = ofproto.OFPST_QUEUE
+ flags = 0
+
+ fmt = ofproto.OFP_STATS_REPLY_PACK_STR
+ buf += pack(fmt, type_, flags)
+ res = self.c.parser(object, version, msg_type, msg_len, xid, buf)
+
+ eq_(version, res.version)
+ eq_(msg_type, res.msg_type)
+ eq_(msg_len, res.msg_len)
+ eq_(xid, res.xid)
+ eq_(type_, res.type)
+ eq_(flags, res.flags)
+
+
+class TestOFPDescStatsRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPDescStatsRequest
+ """
+
+ def test_serialize(self):
+ c = OFPDescStatsRequest(_Datapath)
+ c.serialize()
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + ofproto.OFP_STATS_REQUEST_PACK_STR.replace('!', '')
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_STATS_REQUEST)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], ofproto.OFPST_DESC)
+ eq_(res[5], 0)
+
+
+class TestOFPDescStats(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPDescStats
+ """
+
+ # OFP_DESC_STATS_PACK_STR
+ # '!256s256s256s32s256s'...mfr_desc, hw_desc, sw_desc, serial_num, dp_desc
+ mfr_desc = b'mfr_desc'.ljust(256)
+ hw_desc = b'hw_desc'.ljust(256)
+ sw_desc = b'sw_desc'.ljust(256)
+ serial_num = b'serial_num'.ljust(32)
+ dp_desc = b'dp_desc'.ljust(256)
+
+ buf = mfr_desc \
+ + hw_desc \
+ + sw_desc \
+ + serial_num \
+ + dp_desc
+
+ c = OFPDescStats(mfr_desc, hw_desc, sw_desc, serial_num, dp_desc)
+
+ def test_init(self):
+ eq_(self.mfr_desc, self.c.mfr_desc)
+ eq_(self.hw_desc, self.c.hw_desc)
+ eq_(self.sw_desc, self.c.sw_desc)
+ eq_(self.serial_num, self.c.serial_num)
+ eq_(self.dp_desc, self.c.dp_desc)
+
+ def test_parser(self):
+ res = self.c.parser(self.buf, 0)
+
+ eq_(self.mfr_desc, res.mfr_desc)
+ eq_(self.hw_desc, res.hw_desc)
+ eq_(self.sw_desc, res.sw_desc)
+ eq_(self.serial_num, res.serial_num)
+ eq_(self.dp_desc, res.dp_desc)
+
+
+class TestOFPFlowStatsRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPFlowStatsRequest
+ """
+
+ # OFP_FLOW_STATS_REQUEST_PACK_STR
+ # '!B3xII4xQQ'...table_id, pad(3), out_port, out_group, pad(4),
+ # cookie, cookie_mask
+ table_id = 3
+ out_port = 65037
+ out_group = 6606
+ cookie = 2127614848199081640
+ cookie_mask = 2127614848199081641
+
+ def test_init(self):
+ match = OFPMatch()
+ in_port = 3
+ match.set_in_port(in_port)
+
+ c = OFPFlowStatsRequest(_Datapath, self.table_id, self.out_port,
+ self.out_group, self.cookie, self.cookie_mask,
+ match)
+
+ eq_(self.table_id, c.table_id)
+ eq_(self.out_port, c.out_port)
+ eq_(self.out_group, c.out_group)
+ eq_(self.cookie, c.cookie)
+ eq_(self.cookie_mask, c.cookie_mask)
+ eq_(in_port, c.match._flow.in_port)
+
+ def _test_serialize(self, table_id, out_port, out_group,
+ cookie, cookie_mask):
+ match = OFPMatch()
+ dl_type = 0x800
+ match.set_dl_type(dl_type)
+
+ c = OFPFlowStatsRequest(_Datapath, table_id, out_port,
+ out_group, cookie, cookie_mask, match)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_STATS_REQUEST, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = ofproto.OFP_HEADER_PACK_STR \
+ + ofproto.OFP_STATS_REQUEST_PACK_STR[1:] \
+ + ofproto.OFP_FLOW_STATS_REQUEST_PACK_STR[1:] \
+ + 'HHHBB' \
+ + MTEthType.pack_str[1:] + '6x'
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_STATS_REQUEST)
+ size = ofproto.OFP_STATS_REPLY_SIZE \
+ + ofproto.OFP_FLOW_STATS_REQUEST_SIZE \
+ + calcsize(MTEthType.pack_str + '6x')
+ eq_(res[2], size)
+ eq_(res[3], 0)
+ eq_(res[4], ofproto.OFPST_FLOW)
+ eq_(res[5], 0)
+ eq_(res[6], table_id)
+ eq_(res[7], out_port)
+ eq_(res[8], out_group)
+ eq_(res[9], cookie)
+ eq_(res[10], cookie_mask)
+ # match
+ eq_(res[11], ofproto.OFPMT_OXM)
+ eq_(res[12], 10)
+ eq_(res[13], ofproto.OFPXMC_OPENFLOW_BASIC)
+ eq_(res[14] >> 1, ofproto.OFPXMT_OFB_ETH_TYPE)
+ eq_(res[14] & 0b0001, 0)
+ eq_(res[15], calcsize(MTEthType.pack_str))
+ eq_(res[16], dl_type)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.table_id, self.out_port, self.out_group,
+ self.cookie, self.cookie_mask)
+
+ def test_serialize_max(self):
+ table_id = 0xff
+ out_port = 0xffff
+ out_group = 0xffff
+ cookie = 0xffffffff
+ cookie_mask = 0xffffffff
+ self._test_serialize(table_id, out_port, out_group,
+ cookie, cookie_mask)
+
+ def test_serialize_min(self):
+ table_id = 0
+ out_port = 0
+ out_group = 0
+ cookie = 0
+ cookie_mask = 0
+ self._test_serialize(table_id, out_port, out_group,
+ cookie, cookie_mask)
+
+ def test_serialize_p1(self):
+ table_id = ofproto.OFPTT_MAX
+ self._test_serialize(table_id, self.out_port, self.out_group,
+ self.cookie, self.cookie_mask)
+
+
+class TestOFPFlowStats(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPFlowStats
+ """
+
+ def test_init(self):
+ length = ofproto.OFP_FLOW_STATS_SIZE
+ table_id = 81
+ duration_sec = 2484712402
+ duration_nsec = 3999715196
+ priority = 57792
+ idle_timeout = 36368
+ hard_timeout = 54425
+ cookie = 793171083674290912
+ packet_count = 5142202600015232219
+ byte_count = 2659740543924820419
+
+ match = OFPMatch()
+ in_port = 2
+ match.set_in_port(in_port)
+
+ goto_table = 3
+ instructions = [OFPInstructionGotoTable(goto_table)]
+ c = OFPFlowStats(table_id, duration_sec, duration_nsec,
+ priority, idle_timeout, hard_timeout, cookie,
+ packet_count, byte_count, match, instructions)
+
+ eq_(table_id, c.table_id)
+ eq_(duration_sec, c.duration_sec)
+ eq_(duration_nsec, c.duration_nsec)
+ eq_(priority, c.priority)
+ eq_(idle_timeout, c.idle_timeout)
+ eq_(hard_timeout, c.hard_timeout)
+ eq_(cookie, c.cookie)
+ eq_(packet_count, c.packet_count)
+ eq_(byte_count, c.byte_count)
+ eq_(in_port, c.match._flow.in_port)
+ eq_(goto_table, c.instructions[0].table_id)
+
+ def _test_parser(self, table_id, duration_sec, duration_nsec,
+ priority, idle_timeout, hard_timeout, cookie,
+ packet_count, byte_count, inst_cnt=0):
+
+ length = ofproto.OFP_FLOW_STATS_SIZE \
+ + calcsize(MTEthType.pack_str[1:] + '6x') \
+ + ofproto.OFP_INSTRUCTION_GOTO_TABLE_SIZE * inst_cnt
+
+ # OFP_FLOW_STATS_PACK_STR
+ buf = pack(ofproto.OFP_FLOW_STATS_PACK_STR,
+ length, table_id, duration_sec, duration_nsec,
+ priority, idle_timeout, hard_timeout, cookie,
+ packet_count, byte_count)
+
+ # match
+ match = OFPMatch()
+ dl_type = 0x0800
+ match.set_dl_type(dl_type)
+ match_buf = bytearray()
+ match.serialize(match_buf, 0)
+ buf += six.binary_type(match_buf)
+
+ # instructions
+ # 56 + 8 + 8 * inst_cnt <= 65535
+ # inst_cnt <= 8183
+ for i in range(inst_cnt):
+ inst = OFPInstructionGotoTable(1)
+ inst_buf = bytearray()
+ inst.serialize(inst_buf, 0)
+ buf += six.binary_type(inst_buf)
+
+ # parse
+ res = OFPFlowStats.parser(buf, 0)
+ eq_(length, res.length)
+ eq_(table_id, res.table_id)
+ eq_(duration_sec, res.duration_sec)
+ eq_(duration_nsec, res.duration_nsec)
+ eq_(priority, res.priority)
+ eq_(idle_timeout, res.idle_timeout)
+ eq_(hard_timeout, res.hard_timeout)
+ eq_(cookie, res.cookie)
+ eq_(packet_count, res.packet_count)
+ eq_(byte_count, res.byte_count)
+ eq_(dl_type, res.match.fields[0].value)
+ for i in range(inst_cnt):
+ eq_(1, res.instructions[i].table_id)
+
+ def test_parser_mid(self):
+ table_id = 81
+ duration_sec = 2484712402
+ duration_nsec = 3999715196
+ priority = 57792
+ idle_timeout = 36368
+ hard_timeout = 54425
+ cookie = 793171083674290912
+ packet_count = 5142202600015232219
+ byte_count = 2659740543924820419
+ inst_cnt = 2
+
+ self._test_parser(table_id, duration_sec, duration_nsec,
+ priority, idle_timeout, hard_timeout, cookie,
+ packet_count, byte_count, inst_cnt)
+
+ def test_parser_max(self):
+ table_id = 0xff
+ duration_sec = 0xffff
+ duration_nsec = 0xffff
+ priority = 0xffff
+ idle_timeout = 0xff
+ hard_timeout = 0xff
+ cookie = 0xffffffffffffffff
+ packet_count = 0xffffffffffffffff
+ byte_count = 0xffffffffffffffff
+ inst_cnt = 8183
+
+ self._test_parser(table_id, duration_sec, duration_nsec,
+ priority, idle_timeout, hard_timeout, cookie,
+ packet_count, byte_count, inst_cnt)
+
+ def test_parser_min(self):
+ self._test_parser(0, 0, 0, 0, 0, 0, 0, 0, 0)
+
+
+class TestOFPAggregateStatsRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPAggregateStatsRequest
+ """
+
+ # OFP_AGGREGATE_STATS_REQUEST_PACK_STR
+ # '!B3xII4xQQ'...table_id, pad(3), out_port, out_group, pad(4),
+ # cookie, cookie_mask
+ table_id = 3
+ out_port = 65037
+ out_group = 6606
+ cookie = 2127614848199081640
+ cookie_mask = 2127614848199081641
+
+ def test_init(self):
+ match = OFPMatch()
+ dl_type = 0x800
+ match.set_dl_type(dl_type)
+ c = OFPAggregateStatsRequest(_Datapath, self.table_id,
+ self.out_port, self.out_group,
+ self.cookie, self.cookie_mask,
+ match)
+
+ eq_(self.table_id, c.table_id)
+ eq_(self.out_port, c.out_port)
+ eq_(self.out_group, c.out_group)
+ eq_(self.cookie, c.cookie)
+ eq_(self.cookie_mask, c.cookie_mask)
+ eq_(dl_type, c.match._flow.dl_type)
+
+ def _test_serialize(self, table_id, out_port, out_group,
+ cookie, cookie_mask):
+ match = OFPMatch()
+ dl_type = 0x800
+ match.set_dl_type(dl_type)
+ c = OFPAggregateStatsRequest(_Datapath, table_id,
+ out_port, out_group, cookie,
+ cookie_mask, match)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_STATS_REQUEST, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = ofproto.OFP_HEADER_PACK_STR \
+ + ofproto.OFP_STATS_REQUEST_PACK_STR[1:] \
+ + ofproto.OFP_AGGREGATE_STATS_REQUEST_PACK_STR[1:] \
+ + 'HHHBB' \
+ + MTEthType.pack_str[1:] + '6x'
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_STATS_REQUEST)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], ofproto.OFPST_AGGREGATE)
+ eq_(res[5], 0)
+ eq_(res[6], table_id)
+ eq_(res[7], out_port)
+ eq_(res[8], out_group)
+ eq_(res[9], cookie)
+ eq_(res[10], cookie_mask)
+ # match
+ eq_(res[11], ofproto.OFPMT_OXM)
+ eq_(res[12], 10)
+ eq_(res[13], ofproto.OFPXMC_OPENFLOW_BASIC)
+ eq_(res[14] >> 1, ofproto.OFPXMT_OFB_ETH_TYPE)
+ eq_(res[14] & 0b0001, 0)
+ eq_(res[15], calcsize(MTEthType.pack_str))
+ eq_(res[16], dl_type)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.table_id, self.out_port, self.out_group,
+ self.cookie, self.cookie_mask)
+
+ def test_serialize_max(self):
+ table_id = 0xff
+ out_port = 0xffffffff
+ out_group = 0xffffffff
+ cookie = 0xffffffff
+ cookie_mask = 0xffffffff
+ self._test_serialize(table_id, out_port, out_group,
+ cookie, cookie_mask)
+
+ def test_serialize_min(self):
+ table_id = 0
+ out_port = 0
+ out_group = 0
+ cookie = 0
+ cookie_mask = 0
+ self._test_serialize(table_id, out_port, out_group,
+ cookie, cookie_mask)
+
+ def test_serialize_p1(self):
+ table_id = ofproto.OFPTT_MAX
+ self._test_serialize(table_id, self.out_port, self.out_group,
+ self.cookie, self.cookie_mask)
+
+
+class TestOFPAggregateStatsReply(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPAggregateStatsReply
+ """
+
+ # OFP_AGGREGATE_STATS_REPLY_PACK_STR
+ # '!QQI4x'...packet_count, byte_count, flow_count, pad(4)
+ packet_count = 5142202600015232219
+ byte_count = 2659740543924820419
+ flow_count = 1344694860
+
+ def test_init(self):
+ c = OFPAggregateStatsReply(self.packet_count, self.byte_count,
+ self.flow_count)
+
+ eq_(c.packet_count, self.packet_count)
+ eq_(c.byte_count, self.byte_count)
+ eq_(c.flow_count, self.flow_count)
+
+ def _test_parser(self, packet_count, byte_count, flow_count):
+ fmt = ofproto.OFP_AGGREGATE_STATS_REPLY_PACK_STR
+ buf = pack(fmt, packet_count, byte_count, flow_count)
+
+ res = OFPAggregateStatsReply.parser(buf, 0)
+ eq_(packet_count, res.packet_count)
+ eq_(byte_count, res.byte_count)
+ eq_(flow_count, res.flow_count)
+
+ def test_parser_mid(self):
+ self._test_parser(self.packet_count, self.byte_count,
+ self.flow_count)
+
+ def test_parser_max(self):
+ packet_count = 18446744073709551615
+ byte_count = 18446744073709551615
+ flow_count = 4294967295
+ self._test_parser(packet_count, byte_count,
+ flow_count)
+
+ def test_parser_min(self):
+ packet_count = 0
+ byte_count = 0
+ flow_count = 0
+ self._test_parser(packet_count, byte_count,
+ flow_count)
+
+
+class TestOFPTableStatsRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPTableStatsRequest
+ """
+
+ def test_serialize(self):
+ c = OFPTableStatsRequest(_Datapath)
+ c.serialize()
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + ofproto.OFP_STATS_REQUEST_PACK_STR.replace('!', '')
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_STATS_REQUEST)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], ofproto.OFPST_TABLE)
+ eq_(res[5], 0)
+
+
+class TestOFPTableStats(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPTableStats
+ """
+
+ def test_init(self):
+ table_id = 91
+ name = 'name'
+ match = 1270985291017894273
+ wildcards = 3316608530
+ write_actions = 2484712402
+ apply_actions = 3999715196
+ write_setfields = 5142202600015232219
+ apply_setfields = 2659740543924820419
+ metadata_match = 2127614848199081640
+ metadata_write = 2127614848199081641
+ instructions = 1119692796
+ config = 2226555987
+ max_entries = 2506913869
+ active_count = 2024581150
+ lookup_count = 4620020561814017052
+ matched_count = 2825167325263435621
+
+ res = OFPTableStats(table_id, name, match, wildcards, write_actions,
+ apply_actions, write_setfields, apply_setfields,
+ metadata_match, metadata_write, instructions,
+ config, max_entries, active_count, lookup_count,
+ matched_count)
+
+ eq_(table_id, res.table_id)
+ eq_(name, res.name)
+ eq_(match, res.match)
+ eq_(wildcards, res.wildcards)
+ eq_(write_actions, res.write_actions)
+ eq_(apply_actions, res.apply_actions)
+ eq_(write_setfields, res.write_setfields)
+ eq_(apply_setfields, res.apply_setfields)
+ eq_(metadata_match, res.metadata_match)
+ eq_(metadata_write, res.metadata_write)
+ eq_(instructions, res.instructions)
+ eq_(config, res.config)
+ eq_(max_entries, res.max_entries)
+ eq_(active_count, res.active_count)
+ eq_(lookup_count, res.lookup_count)
+ eq_(matched_count, res.matched_count)
+
+ def _test_parser(self, table_id, name, match, wildcards, write_actions,
+ apply_actions, write_setfields, apply_setfields,
+ metadata_match, metadata_write, instructions, config,
+ max_entries, active_count, lookup_count, matched_count):
+ # OFP_TABLE_STATS_PACK_STR
+ # '!B7x32sQQIIQQQQIIIIQQ'
+ # ...table_id, name, match, wildcards, write_actions, apply_actions,
+ # write_setfields, apply_setfields', metadata_match, metadata_write,
+ # instructions, config, max_entries,
+ # active_count, lookup_count, matched_count
+ fmt = ofproto.OFP_TABLE_STATS_PACK_STR
+ buf = pack(fmt, table_id, name,
+ match, wildcards, write_actions,
+ apply_actions, write_setfields, apply_setfields,
+ metadata_match, metadata_write, instructions, config,
+ max_entries, active_count, lookup_count, matched_count)
+
+ res = OFPTableStats.parser(buf, 0)
+
+ eq_(table_id, res.table_id)
+ eq_(name, res.name.replace(b'\x00', b''))
+ eq_(match, res.match)
+ eq_(wildcards, res.wildcards)
+ eq_(write_actions, res.write_actions)
+ eq_(apply_actions, res.apply_actions)
+ eq_(write_setfields, res.write_setfields)
+ eq_(apply_setfields, res.apply_setfields)
+ eq_(metadata_match, res.metadata_match)
+ eq_(metadata_write, res.metadata_write)
+ eq_(instructions, res.instructions)
+ eq_(config, res.config)
+ eq_(max_entries, res.max_entries)
+ eq_(active_count, res.active_count)
+ eq_(lookup_count, res.lookup_count)
+ eq_(matched_count, res.matched_count)
+
+ def test_parser_mid(self):
+ table_id = 91
+ name = b'name'
+ match = 1270985291017894273
+ wildcards = 3316608530
+ write_actions = 2484712402
+ apply_actions = 3999715196
+ write_setfields = 5142202600015232219
+ apply_setfields = 2659740543924820419
+ metadata_match = 2127614848199081640
+ metadata_write = 2127614848199081641
+ instructions = 1119692796
+ config = 2226555987
+ max_entries = 2506913869
+ active_count = 2024581150
+ lookup_count = 4620020561814017052
+ matched_count = 2825167325263435621
+
+ self._test_parser(table_id, name, match, wildcards, write_actions,
+ apply_actions, write_setfields, apply_setfields,
+ metadata_match, metadata_write, instructions, config,
+ max_entries, active_count, lookup_count,
+ matched_count)
+
+ def test_parser_max(self):
+ # '!B7x32sQQIIQQQQIIIIQQ'
+ table_id = 0xff
+ name = b'a' * 32
+ match = 0xffffffffffffffff
+ wildcards = 0xffffffffffffffff
+ write_actions = 0xffffffff
+ apply_actions = 0xffffffff
+ write_setfields = 0xffffffffffffffff
+ apply_setfields = 0xffffffffffffffff
+ metadata_match = 0xffffffffffffffff
+ metadata_write = 0xffffffffffffffff
+ instructions = 0xffffffff
+ config = 0xffffffff
+ max_entries = 0xffffffff
+ active_count = 0xffffffff
+ lookup_count = 0xffffffffffffffff
+ matched_count = 0xffffffffffffffff
+
+ self._test_parser(table_id, name, match, wildcards, write_actions,
+ apply_actions, write_setfields, apply_setfields,
+ metadata_match, metadata_write, instructions, config,
+ max_entries, active_count, lookup_count,
+ matched_count)
+
+ def test_parser_min(self):
+ table_id = 0
+ name = b''
+ match = 0
+ wildcards = 0
+ write_actions = 0
+ apply_actions = 0
+ write_setfields = 0
+ apply_setfields = 0
+ metadata_match = 0
+ metadata_write = 0
+ instructions = 0
+ config = 0
+ max_entries = 0
+ active_count = 0
+ lookup_count = 0
+ matched_count = 0
+
+ self._test_parser(table_id, name, match, wildcards, write_actions,
+ apply_actions, write_setfields, apply_setfields,
+ metadata_match, metadata_write, instructions, config,
+ max_entries, active_count, lookup_count,
+ matched_count)
+
+ def _test_parser_p(self, ofpxmt, ofpit, ofptc):
+ table_id = 91
+ name = b'name'
+ match = ofpxmt
+ wildcards = ofpxmt
+ write_actions = 2484712402
+ apply_actions = 3999715196
+ write_setfields = ofpxmt
+ apply_setfields = ofpxmt
+ metadata_match = 2127614848199081640
+ metadata_write = 2127614848199081641
+ instructions = ofpit
+ config = ofptc
+ max_entries = 2506913869
+ active_count = 2024581150
+ lookup_count = 4620020561814017052
+ matched_count = 2825167325263435621
+
+ self._test_parser(table_id, name, match, wildcards, write_actions,
+ apply_actions, write_setfields, apply_setfields,
+ metadata_match, metadata_write, instructions, config,
+ max_entries, active_count, lookup_count,
+ matched_count)
+
+ def test_parser_p1(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IN_PORT,
+ ofproto.OFPIT_GOTO_TABLE,
+ ofproto.OFPTC_TABLE_MISS_CONTINUE)
+
+ def test_parser_p2(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IN_PHY_PORT,
+ ofproto.OFPIT_WRITE_METADATA,
+ ofproto.OFPTC_TABLE_MISS_DROP)
+
+ def test_parser_p3(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_METADATA,
+ ofproto.OFPIT_WRITE_ACTIONS,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p4(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_ETH_DST,
+ ofproto.OFPIT_APPLY_ACTIONS,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p5(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_ETH_SRC,
+ ofproto.OFPIT_CLEAR_ACTIONS,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p6(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_ETH_TYPE,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p7(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_VLAN_VID,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p8(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_VLAN_PCP,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p9(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IP_DSCP,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p10(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IP_ECN,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p11(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IP_PROTO,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p12(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IPV4_SRC,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p13(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IPV4_DST,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p14(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_TCP_SRC,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p15(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_TCP_DST,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p16(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_UDP_SRC,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p17(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_UDP_DST,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p18(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_SCTP_SRC,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p19(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_SCTP_DST,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p20(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_ICMPV4_TYPE,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p21(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_ICMPV4_CODE,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p22(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_ARP_OP,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p23(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_ARP_SPA,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p24(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_ARP_TPA,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p25(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_ARP_SHA,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p26(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_ARP_THA,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p27(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IPV6_SRC,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p28(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IPV6_DST,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p29(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IPV6_FLABEL,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p30(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_ICMPV6_TYPE,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p31(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_ICMPV6_CODE,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p32(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IPV6_ND_TARGET,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p33(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IPV6_ND_SLL,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p34(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_IPV6_ND_TLL,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p35(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_MPLS_LABEL,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+ def test_parser_p36(self):
+ self._test_parser_p(ofproto.OFPXMT_OFB_MPLS_TC,
+ ofproto.OFPIT_EXPERIMENTER,
+ ofproto.OFPTC_TABLE_MISS_MASK)
+
+
+class TestOFPPortStatsRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPPortStatsRequest
+ """
+
+ # OFP_PORT_STATS_REQUEST_PACK_STR
+ # '!I4x'...port_no, pad(4)
+ port_no = 41186
+
+ def test_init(self):
+ c = OFPPortStatsRequest(_Datapath, self.port_no)
+ eq_(self.port_no, c.port_no)
+
+ def _test_serialize(self, port_no):
+ c = OFPPortStatsRequest(_Datapath, port_no)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_STATS_REQUEST, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + ofproto.OFP_STATS_REQUEST_PACK_STR.replace('!', '') \
+ + ofproto.OFP_PORT_STATS_REQUEST_PACK_STR.replace('!', '')
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_STATS_REQUEST)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], ofproto.OFPST_PORT)
+ eq_(res[5], 0)
+ eq_(res[6], port_no)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.port_no)
+
+ def test_serialize_max(self):
+ self._test_serialize(ofproto.OFPP_ANY)
+
+ def test_serialize_min(self):
+ self._test_serialize(0)
+
+ def test_serialize_p1(self):
+ self._test_serialize(ofproto.OFPP_MAX)
+
+ def test_serialize_p2(self):
+ self._test_serialize(ofproto.OFPP_IN_PORT)
+
+ def test_serialize_p3(self):
+ self._test_serialize(ofproto.OFPP_TABLE)
+
+ def test_serialize_p4(self):
+ self._test_serialize(ofproto.OFPP_NORMAL)
+
+ def test_serialize_p5(self):
+ self._test_serialize(ofproto.OFPP_FLOOD)
+
+ def test_serialize_p6(self):
+ self._test_serialize(ofproto.OFPP_ALL)
+
+ def test_serialize_p7(self):
+ self._test_serialize(ofproto.OFPP_CONTROLLER)
+
+ def test_serialize_p8(self):
+ self._test_serialize(ofproto.OFPP_LOCAL)
+
+
+class TestOFPPortStats(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPPortStats
+ """
+
+ def test_init(self):
+ port_no = 6606
+ rx_packets = 5999980397101236279
+ tx_packets = 2856480458895760962
+ rx_bytes = 6170274950576278921
+ tx_bytes = 8638420181865882538
+ rx_dropped = 6982303461569875546
+ tx_dropped = 661287462113808071
+ rx_errors = 3422231811478788365
+ tx_errors = 6283093430376743019
+ rx_frame_err = 876072919806406283
+ rx_over_err = 6525873760178941600
+ rx_crc_err = 8303073210207070535
+ collisions = 3409801584220270201
+
+ res = OFPPortStats(port_no, rx_packets, tx_packets,
+ rx_bytes, tx_bytes, rx_dropped, tx_dropped,
+ rx_errors, tx_errors, rx_frame_err,
+ rx_over_err, rx_crc_err, collisions)
+
+ eq_(port_no, res.port_no)
+ eq_(rx_packets, res.rx_packets)
+ eq_(tx_packets, res.tx_packets)
+ eq_(rx_bytes, res.rx_bytes)
+ eq_(tx_bytes, res.tx_bytes)
+ eq_(rx_dropped, res.rx_dropped)
+ eq_(tx_dropped, res.tx_dropped)
+ eq_(rx_errors, res.rx_errors)
+ eq_(tx_errors, res.tx_errors)
+ eq_(rx_frame_err, res.rx_frame_err)
+ eq_(rx_over_err, res.rx_over_err)
+ eq_(rx_crc_err, res.rx_crc_err)
+ eq_(collisions, res.collisions)
+
+ def _test_parser(self, port_no, rx_packets, tx_packets,
+ rx_bytes, tx_bytes, rx_dropped, tx_dropped,
+ rx_errors, tx_errors, rx_frame_err,
+ rx_over_err, rx_crc_err, collisions):
+
+ # OFP_PORT_STATS_PACK_STR = '!H6xQQQQQQQQQQQQ'
+ fmt = ofproto.OFP_PORT_STATS_PACK_STR
+ buf = pack(fmt, port_no, rx_packets, tx_packets, rx_bytes, tx_bytes,
+ rx_dropped, tx_dropped, rx_errors, tx_errors, rx_frame_err,
+ rx_over_err, rx_crc_err, collisions)
+
+ res = OFPPortStats.parser(buf, 0)
+
+ eq_(port_no, res.port_no)
+ eq_(rx_packets, res.rx_packets)
+ eq_(tx_packets, res.tx_packets)
+ eq_(rx_bytes, res.rx_bytes)
+ eq_(tx_bytes, res.tx_bytes)
+ eq_(rx_dropped, res.rx_dropped)
+ eq_(tx_dropped, res.tx_dropped)
+ eq_(rx_errors, res.rx_errors)
+ eq_(tx_errors, res.tx_errors)
+ eq_(rx_frame_err, res.rx_frame_err)
+ eq_(rx_over_err, res.rx_over_err)
+ eq_(rx_crc_err, res.rx_crc_err)
+ eq_(collisions, res.collisions)
+
+ def test_parser_mid(self):
+ port_no = 6606
+ rx_packets = 5999980397101236279
+ tx_packets = 2856480458895760962
+ rx_bytes = 6170274950576278921
+ tx_bytes = 8638420181865882538
+ rx_dropped = 6982303461569875546
+ tx_dropped = 661287462113808071
+ rx_errors = 3422231811478788365
+ tx_errors = 6283093430376743019
+ rx_frame_err = 876072919806406283
+ rx_over_err = 6525873760178941600
+ rx_crc_err = 8303073210207070535
+ collisions = 3409801584220270201
+
+ self._test_parser(port_no, rx_packets, tx_packets, rx_bytes, tx_bytes,
+ rx_dropped, tx_dropped, rx_errors, tx_errors,
+ rx_frame_err, rx_over_err, rx_crc_err, collisions)
+
+ def test_parser_max(self):
+ port_no = 0xffffffff
+ rx_packets = 0xffffffffffffffff
+ tx_packets = 0xffffffffffffffff
+ rx_bytes = 0xffffffffffffffff
+ tx_bytes = 0xffffffffffffffff
+ rx_dropped = 0xffffffffffffffff
+ tx_dropped = 0xffffffffffffffff
+ rx_errors = 0xffffffffffffffff
+ tx_errors = 0xffffffffffffffff
+ rx_frame_err = 0xffffffffffffffff
+ rx_over_err = 0xffffffffffffffff
+ rx_crc_err = 0xffffffffffffffff
+ collisions = 0xffffffffffffffff
+
+ self._test_parser(port_no, rx_packets, tx_packets, rx_bytes, tx_bytes,
+ rx_dropped, tx_dropped, rx_errors, tx_errors,
+ rx_frame_err, rx_over_err, rx_crc_err, collisions)
+
+ def test_parser_min(self):
+ port_no = 0
+ rx_packets = 0
+ tx_packets = 0
+ rx_bytes = 0
+ tx_bytes = 0
+ rx_dropped = 0
+ tx_dropped = 0
+ rx_errors = 0
+ tx_errors = 0
+ rx_frame_err = 0
+ rx_over_err = 0
+ rx_crc_err = 0
+ collisions = 0
+
+ self._test_parser(port_no, rx_packets, tx_packets, rx_bytes, tx_bytes,
+ rx_dropped, tx_dropped, rx_errors, tx_errors,
+ rx_frame_err, rx_over_err, rx_crc_err, collisions)
+
+ def _test_parser_p(self, port_no):
+ port_no = port_no
+ rx_packets = 5999980397101236279
+ tx_packets = 2856480458895760962
+ rx_bytes = 6170274950576278921
+ tx_bytes = 8638420181865882538
+ rx_dropped = 6982303461569875546
+ tx_dropped = 661287462113808071
+ rx_errors = 3422231811478788365
+ tx_errors = 6283093430376743019
+ rx_frame_err = 876072919806406283
+ rx_over_err = 6525873760178941600
+ rx_crc_err = 8303073210207070535
+ collisions = 3409801584220270201
+
+ self._test_parser(port_no, rx_packets, tx_packets, rx_bytes, tx_bytes,
+ rx_dropped, tx_dropped, rx_errors, tx_errors,
+ rx_frame_err, rx_over_err, rx_crc_err, collisions)
+
+ def test_parser_p1(self):
+ self._test_parser_p(ofproto.OFPP_MAX)
+
+ def test_parser_p2(self):
+ self._test_parser_p(ofproto.OFPP_IN_PORT)
+
+ def test_parser_p3(self):
+ self._test_parser_p(ofproto.OFPP_TABLE)
+
+ def test_parser_p4(self):
+ self._test_parser_p(ofproto.OFPP_NORMAL)
+
+ def test_parser_p5(self):
+ self._test_parser_p(ofproto.OFPP_FLOOD)
+
+ def test_parser_p6(self):
+ self._test_parser_p(ofproto.OFPP_ALL)
+
+ def test_parser_p7(self):
+ self._test_parser_p(ofproto.OFPP_CONTROLLER)
+
+ def test_parser_p8(self):
+ self._test_parser_p(ofproto.OFPP_LOCAL)
+
+
+class TestOFPQueueStatsRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPQueueStatsRequest
+ """
+
+ # OFP_QUEUE_STATS_REQUEST_PACK_STR
+ # '!II'...port_no, queue_id
+ port_no = 41186
+ queue_id = 6606
+
+ def test_init(self):
+ c = OFPQueueStatsRequest(_Datapath, self.port_no, self.queue_id)
+
+ eq_(self.port_no, c.port_no)
+ eq_(self.queue_id, c.queue_id)
+
+ def _test_serialize(self, port_no, queue_id):
+ c = OFPQueueStatsRequest(_Datapath, port_no, queue_id)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_STATS_REQUEST, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + ofproto.OFP_STATS_REQUEST_PACK_STR.replace('!', '') \
+ + ofproto.OFP_QUEUE_STATS_REQUEST_PACK_STR.replace('!', '')
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_STATS_REQUEST)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], ofproto.OFPST_QUEUE)
+ eq_(res[5], 0)
+ eq_(res[6], port_no)
+ eq_(res[7], queue_id)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.port_no, self.queue_id)
+
+ def test_serialize_max(self):
+ self._test_serialize(0xffffffff, 0xffffffff)
+
+ def test_serialize_min(self):
+ self._test_serialize(0, 0)
+
+ def test_serialize_p1(self):
+ self._test_serialize(ofproto.OFPP_MAX, self.queue_id)
+
+ def test_serialize_p2(self):
+ self._test_serialize(ofproto.OFPP_IN_PORT, self.queue_id)
+
+ def test_serialize_p3(self):
+ self._test_serialize(ofproto.OFPP_NORMAL, self.queue_id)
+
+ def test_serialize_p4(self):
+ self._test_serialize(ofproto.OFPP_TABLE, self.queue_id)
+
+ def test_serialize_p5(self):
+ self._test_serialize(ofproto.OFPP_FLOOD, self.queue_id)
+
+ def test_serialize_p6(self):
+ self._test_serialize(ofproto.OFPP_ALL, self.queue_id)
+
+ def test_serialize_p7(self):
+ self._test_serialize(ofproto.OFPP_CONTROLLER, self.queue_id)
+
+ def test_serialize_p8(self):
+ self._test_serialize(ofproto.OFPP_LOCAL, self.queue_id)
+
+
+class TestOFPQueueStats(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPQueueStats
+ """
+
+ def test_init(self):
+ port_no = 41186
+ queue_id = 6606
+ tx_bytes = 8638420181865882538
+ tx_packets = 2856480458895760962
+ tx_errors = 6283093430376743019
+
+ res = OFPQueueStats(port_no, queue_id, tx_bytes,
+ tx_packets, tx_errors)
+
+ eq_(port_no, res.port_no)
+ eq_(queue_id, res.queue_id)
+ eq_(tx_bytes, res.tx_bytes)
+ eq_(tx_packets, res.tx_packets)
+ eq_(tx_errors, res.tx_errors)
+
+ def _test_parser(self, port_no, queue_id, tx_bytes,
+ tx_packets, tx_errors):
+
+ # OFP_QUEUE_STATS_PACK_STR = '!IIQQQ'
+ fmt = ofproto.OFP_QUEUE_STATS_PACK_STR
+ buf = pack(fmt, port_no, queue_id, tx_bytes, tx_packets, tx_errors)
+ res = OFPQueueStats.parser(buf, 0)
+
+ eq_(port_no, res.port_no)
+ eq_(queue_id, res.queue_id)
+ eq_(tx_bytes, res.tx_bytes)
+ eq_(tx_packets, res.tx_packets)
+ eq_(tx_errors, res.tx_errors)
+
+ def test_parser_mid(self):
+ port_no = 41186
+ queue_id = 6606
+ tx_bytes = 8638420181865882538
+ tx_packets = 2856480458895760962
+ tx_errors = 6283093430376743019
+
+ self._test_parser(port_no, queue_id, tx_bytes,
+ tx_packets, tx_errors)
+
+ def test_parser_max(self):
+ port_no = 0xffffffff
+ queue_id = 0xffffffff
+ tx_bytes = 0xffffffffffffffff
+ tx_packets = 0xffffffffffffffff
+ tx_errors = 0xffffffffffffffff
+
+ self._test_parser(port_no, queue_id, tx_bytes,
+ tx_packets, tx_errors)
+
+ def test_parser_min(self):
+ port_no = 0
+ queue_id = 0
+ tx_bytes = 0
+ tx_packets = 0
+ tx_errors = 0
+
+ self._test_parser(port_no, queue_id, tx_bytes,
+ tx_packets, tx_errors)
+
+ def _test_parser_p(self, port_no):
+ queue_id = 6606
+ tx_bytes = 8638420181865882538
+ tx_packets = 2856480458895760962
+ tx_errors = 6283093430376743019
+
+ self._test_parser(port_no, queue_id, tx_bytes,
+ tx_packets, tx_errors)
+
+ def test_parser_p1(self):
+ self._test_parser_p(ofproto.OFPP_MAX)
+
+ def test_parser_p2(self):
+ self._test_parser_p(ofproto.OFPP_IN_PORT)
+
+ def test_parser_p3(self):
+ self._test_parser_p(ofproto.OFPP_TABLE)
+
+ def test_parser_p4(self):
+ self._test_parser_p(ofproto.OFPP_NORMAL)
+
+ def test_parser_p5(self):
+ self._test_parser_p(ofproto.OFPP_FLOOD)
+
+ def test_parser_p6(self):
+ self._test_parser_p(ofproto.OFPP_ALL)
+
+ def test_parser_p7(self):
+ self._test_parser_p(ofproto.OFPP_CONTROLLER)
+
+ def test_parser_p8(self):
+ self._test_parser_p(ofproto.OFPP_LOCAL)
+
+
+class TestOFPBucketCounter(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPBucketCounter
+ """
+
+ # OFP_BUCKET_COUNTER_PACK_STR = '!QQ'
+ packet_count = 6489108735192644493
+ byte_count = 7334344481123449724
+
+ def test_init(self):
+ c = OFPBucketCounter(self.packet_count, self.byte_count)
+
+ eq_(self.packet_count, c.packet_count)
+ eq_(self.byte_count, c.byte_count)
+
+ def _test_parser(self, packet_count, byte_count):
+ fmt = ofproto.OFP_BUCKET_COUNTER_PACK_STR
+ buf = pack(fmt, packet_count, byte_count)
+
+ res = OFPBucketCounter.parser(buf, 0)
+ eq_(packet_count, res.packet_count)
+ eq_(byte_count, res.byte_count)
+
+ def test_parser_mid(self):
+ self._test_parser(self.packet_count, self.byte_count)
+
+ def test_parser_max(self):
+ packet_count = 18446744073709551615
+ byte_count = 18446744073709551615
+ self._test_parser(packet_count, byte_count)
+
+ def test_parser_min(self):
+ packet_count = 0
+ byte_count = 0
+ self._test_parser(packet_count, byte_count)
+
+
+class TestOFPGroupStatsRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPGroupStatsRequest
+ """
+
+ # OFP_GROUP_STATS_REQUEST_PACK_STR
+ # '!I4x'...group_id, pad(4)
+ group_id = 6606
+
+ def test_init(self):
+ c = OFPGroupStatsRequest(_Datapath, self.group_id)
+ eq_(self.group_id, c.group_id)
+
+ def _test_serialize(self, group_id):
+ c = OFPGroupStatsRequest(_Datapath, group_id)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_STATS_REQUEST, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + ofproto.OFP_STATS_REQUEST_PACK_STR.replace('!', '') \
+ + ofproto.OFP_GROUP_STATS_REQUEST_PACK_STR.replace('!', '')
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_STATS_REQUEST)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], ofproto.OFPST_GROUP)
+ eq_(res[5], 0)
+ eq_(res[6], group_id)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.group_id)
+
+ def test_serialize_max(self):
+ self._test_serialize(0xffffffff)
+
+ def test_serialize_min(self):
+ self._test_serialize(0)
+
+ def test_serialize_p1(self):
+ self._test_serialize(ofproto.OFPG_MAX)
+
+ def test_serialize_p2(self):
+ self._test_serialize(ofproto.OFPG_ALL)
+
+
+class TestOFPGroupStats(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPGroupStats
+ """
+
+ # OFP_GROUP_STATS_PACK_STR = '!H2xII4xQQ'
+ length = ofproto.OFP_GROUP_STATS_SIZE \
+ + ofproto.OFP_BUCKET_COUNTER_SIZE
+ group_id = 6606
+ ref_count = 2102
+ packet_count = 6489108735192644493
+ byte_count = 7334344481123449724
+
+ # OFP_BUCKET_COUNTER_PACK_STR = '!QQ'
+ buck_packet_count = 3519264449364891087
+ buck_byte_count = 3123449724733434448
+ bucket_counters = [OFPBucketCounter(buck_packet_count, buck_byte_count)]
+ buf_bucket_counters = pack(ofproto.OFP_BUCKET_COUNTER_PACK_STR,
+ buck_packet_count, buck_byte_count)
+
+ fmt = ofproto.OFP_GROUP_STATS_PACK_STR
+ buf = pack(fmt, length, group_id, ref_count, packet_count, byte_count) \
+ + buf_bucket_counters
+
+ def test_init(self):
+ c = OFPGroupStats(self.group_id, self.ref_count,
+ self.packet_count, self.byte_count,
+ self.bucket_counters)
+
+ eq_(self.group_id, c.group_id)
+ eq_(self.ref_count, c.ref_count)
+ eq_(self.packet_count, c.packet_count)
+ eq_(self.byte_count, c.byte_count)
+ eq_(self.bucket_counters, c.bucket_counters)
+
+ def _test_parser(self, group_id, ref_count, packet_count,
+ byte_count, bucket_counter_cnt):
+ # OFP_GROUP_STATS_PACK_STR = '!H2xII4xQQ'
+ length = ofproto.OFP_GROUP_STATS_SIZE \
+ + (ofproto.OFP_BUCKET_COUNTER_SIZE * bucket_counter_cnt)
+ fmt = ofproto.OFP_GROUP_STATS_PACK_STR
+ buf = pack(fmt, length, group_id, ref_count,
+ packet_count, byte_count)
+
+ bucket_counters = []
+ for b in range(bucket_counter_cnt):
+ # OFP_BUCKET_COUNTER_PACK_STR = '!QQ'
+ buck_packet_count = b
+ buck_byte_count = b
+ bucket_counter = OFPBucketCounter(buck_packet_count,
+ buck_byte_count)
+ bucket_counters.append(bucket_counter)
+ buf_bucket_counters = \
+ pack(ofproto.OFP_BUCKET_COUNTER_PACK_STR,
+ buck_packet_count, buck_byte_count)
+ buf += buf_bucket_counters
+
+ res = OFPGroupStats.parser(buf, 0)
+
+ # 32
+ eq_(length, res.length)
+ eq_(group_id, res.group_id)
+ eq_(ref_count, res.ref_count)
+ eq_(packet_count, res.packet_count)
+ eq_(byte_count, res.byte_count)
+
+ # 32 + 16 * bucket_counter_cnt < 65535 byte
+ # bucket_counter_cnt <= 4093
+ for b in range(bucket_counter_cnt):
+ eq_(bucket_counters[b].packet_count,
+ res.bucket_counters[b].packet_count)
+ eq_(bucket_counters[b].byte_count,
+ res.bucket_counters[b].byte_count)
+
+ def test_parser_mid(self):
+ bucket_counter_cnt = 2046
+ self._test_parser(self.group_id, self.ref_count,
+ self.packet_count, self.byte_count,
+ bucket_counter_cnt)
+
+ def test_parser_max(self):
+ group_id = 4294967295
+ ref_count = 4294967295
+ packet_count = 18446744073709551615
+ byte_count = 18446744073709551615
+ bucket_counter_cnt = 4093
+ self._test_parser(group_id, ref_count,
+ packet_count, byte_count,
+ bucket_counter_cnt)
+
+ def test_parser_min(self):
+ group_id = 0
+ ref_count = 0
+ packet_count = 0
+ byte_count = 0
+ bucket_counter_cnt = 0
+ self._test_parser(group_id, ref_count,
+ packet_count, byte_count,
+ bucket_counter_cnt)
+
+
+class TestOFPGroupDescStatsRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPGroupDescStatsRequest
+ """
+
+ def test_serialize(self):
+ c = OFPGroupDescStatsRequest(_Datapath)
+ c.serialize()
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + ofproto.OFP_STATS_REQUEST_PACK_STR.replace('!', '')
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_STATS_REQUEST)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], ofproto.OFPST_GROUP_DESC)
+ eq_(res[5], 0)
+
+
+class TestOFPGroupDescStats(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPGroupDescStats
+ """
+
+ # OFP_GROUP_DESC_STATS_PACK_STR = '!HBxI'
+ length = ofproto.OFP_GROUP_DESC_STATS_SIZE \
+ + ofproto.OFP_BUCKET_SIZE \
+ + ofproto.OFP_ACTION_OUTPUT_SIZE
+ type_ = 128
+ group_id = 6606
+
+ # OFP_ACTION (OFP_ACTION_OUTPUT)
+ port = 0x00002ae0
+ max_len = ofproto.OFP_ACTION_OUTPUT_SIZE
+ actions = [OFPActionOutput(port, max_len)]
+ buf_actions = bytearray()
+ actions[0].serialize(buf_actions, 0)
+
+ # OFP_BUCKET
+ weight = 4386
+ watch_port = 8006
+ watch_group = 3
+ buckets = [OFPBucket(weight, watch_port, watch_group, actions)]
+
+ bucket_cnt = 1024
+
+ def test_init(self):
+ c = OFPGroupDescStats(self.type_, self.group_id, self.buckets)
+
+ eq_(self.type_, c.type)
+ eq_(self.group_id, c.group_id)
+ eq_(self.buckets, c.buckets)
+
+ def _test_parser(self, type_, group_id, bucket_cnt):
+ # OFP_GROUP_DESC_STATS_PACK_STR = '!HBxI'
+ length = ofproto.OFP_GROUP_DESC_STATS_SIZE \
+ + (ofproto.OFP_BUCKET_SIZE
+ + ofproto.OFP_ACTION_OUTPUT_SIZE) * bucket_cnt
+
+ fmt = ofproto.OFP_GROUP_DESC_STATS_PACK_STR
+ buf = pack(fmt, length, type_, group_id)
+
+ buckets = []
+ for b in range(bucket_cnt):
+ # OFP_BUCKET
+ weight = watch_port = watch_group = b
+ bucket = OFPBucket(weight,
+ watch_port, watch_group,
+ self.actions)
+ buckets.append(bucket)
+ buf_buckets = bytearray()
+ buckets[b].serialize(buf_buckets, 0)
+ buf += six.binary_type(buf_buckets)
+
+ res = OFPGroupDescStats.parser(buf, 0)
+
+ # 8 byte
+ eq_(type_, res.type)
+ eq_(group_id, res.group_id)
+
+ # 8 + ( 16 + 16 ) * b < 65535 byte
+ # b <= 2047 byte
+ for b in range(bucket_cnt):
+ eq_(buckets[b].weight, res.buckets[b].weight)
+ eq_(buckets[b].watch_port, res.buckets[b].watch_port)
+ eq_(buckets[b].watch_group, res.buckets[b].watch_group)
+ eq_(buckets[b].actions[0].port,
+ res.buckets[b].actions[0].port)
+ eq_(buckets[b].actions[0].max_len,
+ res.buckets[b].actions[0].max_len)
+
+ def test_parser_mid(self):
+ self._test_parser(self.type_, self.group_id, self.bucket_cnt)
+
+ def test_parser_max(self):
+ group_id = 4294967295
+ type_ = 255
+ bucket_cnt = 2047
+ self._test_parser(type_, group_id, bucket_cnt)
+
+ def test_parser_min(self):
+ group_id = 0
+ type_ = ofproto.OFPGT_ALL
+ bucket_cnt = 0
+ self._test_parser(type_, group_id, bucket_cnt)
+
+ def test_parser_p1(self):
+ type_ = ofproto.OFPGT_SELECT
+ self._test_parser(type_, self.group_id, self.bucket_cnt)
+
+ def test_parser_p2(self):
+ type_ = ofproto.OFPGT_INDIRECT
+ self._test_parser(type_, self.group_id, self.bucket_cnt)
+
+ def test_parser_p3(self):
+ type_ = ofproto.OFPGT_FF
+ self._test_parser(type_, self.group_id, self.bucket_cnt)
+
+
+class TestOFPGroupFeaturesStatsRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPGroupFeaturesStatsRequest
+ """
+
+ def test_serialize(self):
+ c = OFPGroupFeaturesStatsRequest(_Datapath)
+ c.serialize()
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + ofproto.OFP_STATS_REQUEST_PACK_STR.replace('!', '')
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_STATS_REQUEST)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], ofproto.OFPST_GROUP_FEATURES)
+ eq_(res[5], 0)
+
+
+class TestOFPGroupFeaturesStats(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPGroupFeaturesStats
+ """
+
+ # OFP_GROUP_FEATURES_STATS_PACK_STR = '!II4I4I'
+ types = ofproto.OFPGT_ALL
+ capabilities = ofproto.OFPGFC_SELECT_WEIGHT
+ max_groups = [1, 2, 3, 4]
+ actions = [1 << ofproto.OFPAT_OUTPUT,
+ 1 << ofproto.OFPAT_COPY_TTL_OUT,
+ 1 << ofproto.OFPAT_SET_MPLS_TTL,
+ 1 << ofproto.OFPAT_PUSH_VLAN]
+
+ def test_init(self):
+ c = OFPGroupFeaturesStats(self.types, self.capabilities,
+ self.max_groups, self.actions)
+ eq_(self.types, c.types)
+ eq_(self.capabilities, c.capabilities)
+ eq_(self.max_groups, c.max_groups)
+ eq_(self.actions, c.actions)
+
+ def _test_parser(self, types, capabilities, max_groups, actions):
+
+ buf = pack('!I', types) \
+ + pack('!I', capabilities) \
+ + pack('!I', max_groups[0]) \
+ + pack('!I', max_groups[1]) \
+ + pack('!I', max_groups[2]) \
+ + pack('!I', max_groups[3]) \
+ + pack('!I', actions[0]) \
+ + pack('!I', actions[1]) \
+ + pack('!I', actions[2]) \
+ + pack('!I', actions[3])
+
+ res = OFPGroupFeaturesStats.parser(buf, 0)
+
+ # max_groups and actions after the parser is tuple
+ eq_(types, res.types)
+ eq_(capabilities, res.capabilities)
+ eq_(max_groups, res.max_groups)
+ eq_(actions, res.actions)
+
+ def test_parser_mid(self):
+ self._test_parser(self.types, self.capabilities,
+ self.max_groups, self.actions)
+
+ def test_parser_max(self):
+ types = 0b11111111111111111111111111111111
+ capabilities = 0b11111111111111111111111111111111
+ max_groups = [4294967295] * 4
+ actions = [0b11111111111111111111111111111111] * 4
+ self._test_parser(types, capabilities,
+ max_groups, actions)
+
+ def test_parser_min(self):
+ types = 0b00000000000000000000000000000000
+ capabilities = 0b00000000000000000000000000000000
+ max_groups = [0] * 4
+ actions = [0b00000000000000000000000000000000] * 4
+ self._test_parser(types, capabilities,
+ max_groups, actions)
+
+ def _test_parser_p(self, types, capabilities, actions):
+ self._test_parser(types, capabilities,
+ self.max_groups, actions)
+
+ def test_parser_p1(self):
+ actions = [1 << ofproto.OFPAT_COPY_TTL_IN,
+ 1 << ofproto.OFPAT_DEC_MPLS_TTL,
+ 1 << ofproto.OFPAT_POP_VLAN,
+ 1 << ofproto.OFPAT_PUSH_MPLS]
+ self._test_parser_p(1 << ofproto.OFPGT_ALL,
+ ofproto.OFPGFC_CHAINING,
+ actions)
+
+ def test_parser_p2(self):
+ actions = [1 << ofproto.OFPAT_POP_MPLS,
+ 1 << ofproto.OFPAT_SET_QUEUE,
+ 1 << ofproto.OFPAT_GROUP,
+ 1 << ofproto.OFPAT_SET_NW_TTL]
+ self._test_parser_p(1 << ofproto.OFPGT_SELECT,
+ ofproto.OFPGFC_SELECT_WEIGHT,
+ actions)
+
+ def test_parser_p3(self):
+ actions = [1 << ofproto.OFPAT_DEC_NW_TTL,
+ 1 << ofproto.OFPAT_SET_FIELD,
+ 1 << ofproto.OFPAT_GROUP,
+ 1 << ofproto.OFPAT_SET_NW_TTL]
+ self._test_parser_p(1 << ofproto.OFPGT_SELECT,
+ ofproto.OFPGFC_SELECT_LIVENESS,
+ actions)
+
+ def test_parser_p4(self):
+ self._test_parser_p(1 << ofproto.OFPGT_INDIRECT,
+ ofproto.OFPGFC_CHAINING,
+ self.actions)
+
+ def test_parser_p5(self):
+ self._test_parser_p(1 << ofproto.OFPGT_FF,
+ ofproto.OFPGFC_CHAINING_CHECKS,
+ self.actions)
+
+
+class TestOFPQueueGetConfigRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPQueueGetConfigRequest
+ """
+
+ # OFP_QUEUE_GET_CONFIG_REQUEST_PACK_STR v1.2
+ # '!I4x'...port, pad(4)
+ port = 41186
+
+ def test_init(self):
+ c = OFPQueueGetConfigRequest(_Datapath, self.port)
+ eq_(self.port, c.port)
+
+ def _test_serialize(self, port):
+ c = OFPQueueGetConfigRequest(_Datapath, port)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_QUEUE_GET_CONFIG_REQUEST, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = ofproto.OFP_HEADER_PACK_STR \
+ + ofproto.OFP_QUEUE_GET_CONFIG_REQUEST_PACK_STR[1:]
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+ eq_(res[0], ofproto.OFP_VERSION)
+ eq_(res[1], ofproto.OFPT_QUEUE_GET_CONFIG_REQUEST)
+ eq_(res[2], len(c.buf))
+ eq_(res[3], 0)
+ eq_(res[4], port)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.port)
+
+ def test_serialize_max(self):
+ self._test_serialize(0xffffffff)
+
+ def test_serialize_min(self):
+ self._test_serialize(0)
+
+ def test_serialize_p1(self):
+ self._test_serialize(ofproto.OFPP_MAX)
+
+
+class TestOFPQueuePropHeader(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPQueuePropHeader
+ """
+
+ # OFP_QUEUE_PROP_HEADER_PACK_STR = '!HH4x'
+ property_ = 1
+ len_ = 10
+
+ def test_init(self):
+ c = OFPQueuePropHeader(self.property_, self.len_)
+ eq_(self.property_, c.property)
+ eq_(self.len_, c.len)
+
+ def _test_serialize(self, property_, len_):
+ c = OFPQueuePropHeader(property_, len_)
+ buf = bytearray()
+ c.serialize(buf, 0)
+
+ fmt = ofproto.OFP_QUEUE_PROP_HEADER_PACK_STR
+ res = struct.unpack(fmt, six.binary_type(buf))
+
+ eq_(res[0], property_)
+ eq_(res[1], len_)
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.property_, self.len_)
+
+ def test_serialize_max(self):
+ self._test_serialize(0xffff, 0xffff)
+
+ def test_serialize_min(self):
+ self._test_serialize(0, 0)
+
+
+class TestOFPPacketQueue(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPPacketQueue
+ """
+
+ def test_init(self):
+ queue_id = 1
+ port = 2
+ len_ = 3
+ properties = [4, 5, 6]
+ c = OFPPacketQueue(queue_id, port, properties)
+
+ eq_(queue_id, c.queue_id)
+ eq_(port, c.port)
+ eq_(properties, c.properties)
+
+ def _test_parser(self, queue_id, port, prop_cnt):
+ # OFP_PACKET_QUEUE_PACK_STR = '!IIH6x'
+ fmt = ofproto.OFP_PACKET_QUEUE_PACK_STR
+ queue_len = ofproto.OFP_PACKET_QUEUE_SIZE \
+ + ofproto.OFP_QUEUE_PROP_MIN_RATE_SIZE * prop_cnt
+
+ buf = pack(fmt, queue_id, port, queue_len)
+
+ for rate in range(prop_cnt):
+ # OFP_QUEUE_PROP_HEADER_PACK_STR = '!HH4x'
+ fmt = ofproto.OFP_QUEUE_PROP_HEADER_PACK_STR
+ prop_type = ofproto.OFPQT_MIN_RATE
+ prop_len = ofproto.OFP_QUEUE_PROP_MIN_RATE_SIZE
+ buf += pack(fmt, prop_type, prop_len)
+
+ # OFP_QUEUE_PROP_MIN_RATE_PACK_STR = '!H6x'
+ fmt = ofproto.OFP_QUEUE_PROP_MIN_RATE_PACK_STR
+ prop_rate = rate
+ buf += pack(fmt, prop_rate)
+
+ res = OFPPacketQueue.parser(buf, 0)
+
+ eq_(queue_id, res.queue_id)
+ eq_(port, res.port)
+ eq_(queue_len, res.len)
+ eq_(prop_cnt, len(res.properties))
+
+ for rate, p in enumerate(res.properties):
+ eq_(prop_type, p.property)
+ eq_(prop_len, p.len)
+ eq_(rate, p.rate)
+
+ def test_parser_mid(self):
+ queue_id = 1
+ port = 2
+ prop_cnt = 2
+ self._test_parser(queue_id, port, prop_cnt)
+
+ def test_parser_max(self):
+ # queue_len format is 'H' < number 65535
+ #
+ # queue_len = OFP_PACKET_QUEUE_SIZE(16)
+ # + OFP_QUEUE_PROP_MIN_RATE_SIZE(16) * N
+ # max_prop_cnt = (65535 - 16) / 16 = 4094
+ queue_id = 0xffffffff
+ port = 0xffffffff
+ prop_cnt = 4094
+ self._test_parser(queue_id, port, prop_cnt)
+
+ def test_parser_min(self):
+ queue_id = 0
+ port = 0
+ prop_cnt = 0
+ self._test_parser(queue_id, port, prop_cnt)
+
+
+class TestOFPQueuePropMinRate(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPQueuePropMinRate
+ """
+
+ def _test_parser(self, rate):
+ # OFP_QUEUE_PROP_MIN_RATE_PACK_STR...H6x
+ buf = pack(ofproto.OFP_QUEUE_PROP_MIN_RATE_PACK_STR, rate)
+ res = OFPQueuePropMinRate.parser(buf, 0)
+ eq_(rate, res.rate)
+
+ def test_parser_mid(self):
+ self._test_parser(32768)
+
+ def test_parser_max(self):
+ self._test_parser(0xffff)
+
+ def test_parser_min(self):
+ self._test_parser(0)
+
+
+class TestOFPQueuePropMaxRate(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPQueuePropMaxRate
+ """
+
+ rate = 100
+ buf = pack(ofproto.OFP_QUEUE_PROP_MAX_RATE_PACK_STR, rate)
+ c = OFPQueuePropMaxRate(rate)
+
+ def _test_parser(self, rate):
+ # OFP_QUEUE_PROP_MAX_RATE_PACK_STR...H6x
+ buf = pack(ofproto.OFP_QUEUE_PROP_MAX_RATE_PACK_STR, rate)
+ res = OFPQueuePropMaxRate.parser(buf, 0)
+ eq_(rate, res.rate)
+
+ def test_parser_mid(self):
+ self._test_parser(100)
+
+ def test_parser_max(self):
+ self._test_parser(0xffff)
+
+ def test_parser_min(self):
+ self._test_parser(0)
+
+
+class TestOFPQueueGetConfigReply(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPQueueGetConfigReply
+ """
+
+ def _test_parser(self, xid, port, queue_cnt):
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_QUEUE_GET_CONFIG_REPLY
+
+ queues_len = 0
+ for q in range(queue_cnt):
+ queues_len += ofproto.OFP_PACKET_QUEUE_SIZE
+ queues_len += ofproto.OFP_QUEUE_PROP_MIN_RATE_SIZE
+
+ msg_len = ofproto.OFP_QUEUE_GET_CONFIG_REPLY_SIZE \
+ + queues_len
+
+ # OFP_HEADER_PACK_STR = '!BBHI'
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ # OFP_QUEUE_GET_CONFIG_REPLY_PACK_STR = '!I4x'
+ fmt = ofproto.OFP_QUEUE_GET_CONFIG_REPLY_PACK_STR
+ buf += pack(fmt, port)
+
+ queues = []
+ for q in range(1, queue_cnt + 1):
+ # OFP_PACKET_QUEUE_PACK_STR = '!IIH6x'
+ fmt = ofproto.OFP_PACKET_QUEUE_PACK_STR
+ queue_id = q * 100
+ queue_port = q
+ queue_len = ofproto.OFP_PACKET_QUEUE_SIZE \
+ + ofproto.OFP_QUEUE_PROP_MIN_RATE_SIZE
+ buf += pack(fmt, queue_id, queue_port, queue_len)
+
+ # OFP_QUEUE_PROP_HEADER_PACK_STR = '!HH4x'
+ fmt = ofproto.OFP_QUEUE_PROP_HEADER_PACK_STR
+ prop_type = ofproto.OFPQT_MIN_RATE
+ prop_len = ofproto.OFP_QUEUE_PROP_MIN_RATE_SIZE
+ buf += pack(fmt, prop_type, prop_len)
+
+ # OFP_QUEUE_PROP_MIN_RATE_PACK_STR = '!H6x'
+ fmt = ofproto.OFP_QUEUE_PROP_MIN_RATE_PACK_STR
+ prop_rate = q * 10
+ buf += pack(fmt, prop_rate)
+
+ queue = {'queue_id': queue_id, 'queue_port': queue_port,
+ 'queue_len': queue_len, 'prop_type': prop_type,
+ 'prop_len': prop_len, 'prop_rate': prop_rate}
+ queues.append(queue)
+
+ res = OFPQueueGetConfigReply.parser(object, version, msg_type,
+ msg_len, xid, buf)
+ eq_(version, res.version)
+ eq_(msg_type, res.msg_type)
+ eq_(msg_len, res.msg_len)
+ eq_(xid, res.xid)
+ eq_(port, res.port)
+ eq_(queue_cnt, len(res.queues))
+
+ for i, val in enumerate(res.queues):
+ c = queues[i]
+ eq_(c['queue_id'], val.queue_id)
+ eq_(c['queue_port'], val.port)
+ eq_(c['queue_len'], val.len)
+ eq_(1, len(val.properties))
+
+ prop = val.properties[0]
+ eq_(c['prop_type'], prop.property)
+ eq_(c['prop_len'], prop.len)
+ eq_(c['prop_rate'], prop.rate)
+
+ def test_parser_mid(self):
+ self._test_parser(2495926989, 65037, 2)
+
+ def test_parser_max(self):
+ # total msg_len = 65520
+ self._test_parser(0xffffffff, 0xffffffff, 2047)
+
+ def test_parser_min(self):
+ self._test_parser(0, 0, 0)
+
+
+class TestOFPBarrierRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPBarrierRequest
+ """
+
+ def test_serialize(self):
+ c = OFPBarrierRequest(_Datapath)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_BARRIER_REQUEST, c.msg_type)
+ eq_(ofproto.OFP_HEADER_SIZE, c.msg_len)
+ eq_(0, c.xid)
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ res = unpack(fmt, six.binary_type(c.buf))
+ eq_(ofproto.OFP_VERSION, res[0])
+ eq_(ofproto.OFPT_BARRIER_REQUEST, res[1])
+ eq_(len(c.buf), res[2])
+ eq_(0, c.xid)
+
+
+class TestOFPBarrierReply(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPBarrierReply
+ """
+
+ def _test_parser(self, xid):
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_BARRIER_REPLY
+ msg_len = ofproto.OFP_HEADER_SIZE
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ res = OFPBarrierReply.parser(object, version, msg_type,
+ msg_len, xid, buf)
+ eq_(version, res.version)
+ eq_(msg_type, res.msg_type)
+ eq_(msg_len, res.msg_len)
+ eq_(xid, res.xid)
+
+ def test_parser_mid(self):
+ self._test_parser(2147483648)
+
+ def test_parser_max(self):
+ self._test_parser(0xffffffff)
+
+ def test_parser_min(self):
+ self._test_parser(0)
+
+
+class TestOFPRoleRequest(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPRoleRequest
+ """
+
+ # OFP_ROLE_REQUEST_PACK_STR
+ # '!I4xQ'...role, pad(4), generation_id
+ role = 2147483648
+ generation_id = 1270985291017894273
+
+ def test_init(self):
+ c = OFPRoleRequest(_Datapath, self.role, self.generation_id)
+ eq_(self.role, c.role)
+ eq_(self.generation_id, c.generation_id)
+
+ def _test_serialize(self, role, generation_id):
+ c = OFPRoleRequest(_Datapath, role, generation_id)
+ c.serialize()
+
+ eq_(ofproto.OFP_VERSION, c.version)
+ eq_(ofproto.OFPT_ROLE_REQUEST, c.msg_type)
+ eq_(0, c.xid)
+
+ fmt = '!' \
+ + ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
+ + ofproto.OFP_ROLE_REQUEST_PACK_STR.replace('!', '')
+
+ res = struct.unpack(fmt, six.binary_type(c.buf))
+
+ eq_(ofproto.OFP_VERSION, res[0])
+ eq_(ofproto.OFPT_ROLE_REQUEST, res[1])
+ eq_(len(c.buf), res[2])
+ eq_(0, res[3])
+ eq_(role, res[4])
+ eq_(generation_id, res[5])
+
+ def test_serialize_mid(self):
+ self._test_serialize(self.role, self.generation_id)
+
+ def test_serialize_max(self):
+ role = 0xffffffff
+ generation_id = 0xffffffffffffffff
+ self._test_serialize(role, generation_id)
+
+ def test_serialize_min(self):
+ role = 0
+ generation_id = 0
+ self._test_serialize(role, generation_id)
+
+ def test_serialize_p1(self):
+ role = ofproto.OFPCR_ROLE_EQUAL
+ self._test_serialize(role, self.generation_id)
+
+ def test_serialize_p2(self):
+ role = ofproto.OFPCR_ROLE_MASTER
+ self._test_serialize(role, self.generation_id)
+
+ def test_serialize_p3(self):
+ role = ofproto.OFPCR_ROLE_SLAVE
+ self._test_serialize(role, self.generation_id)
+
+
+class TestOFPRoleReply(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPRoleReply
+ """
+
+ # OFP_ROLE_REQUEST_PACK_STR
+ # '!I4xQ'...role, pad(4), generation_id
+ # role = ofproto.OFPCR_ROLE_NOCHANGE
+ role = 2147483648
+ generation_id = 1270985291017894273
+
+ def _test_parser(self, role, generation_id):
+ # OFP_HEADER_PACK_STR
+ version = ofproto.OFP_VERSION
+ msg_type = ofproto.OFPT_ROLE_REPLY
+ msg_len = ofproto.OFP_ROLE_REQUEST_SIZE
+ xid = 2495926989
+
+ fmt = ofproto.OFP_HEADER_PACK_STR
+ buf = pack(fmt, version, msg_type, msg_len, xid)
+
+ fmt = ofproto.OFP_ROLE_REQUEST_PACK_STR
+ buf += pack(fmt, role, generation_id)
+
+ res = OFPRoleReply.parser(object, version, msg_type, msg_len, xid, buf)
+
+ # OFP_HEADER_PACK_STR
+ eq_(version, res.version)
+ eq_(msg_type, res.msg_type)
+ eq_(msg_len, res.msg_len)
+ eq_(xid, res.xid)
+
+ # OFP_ROLE_REQUEST_PACK_STR
+ eq_(role, res.role)
+ eq_(generation_id, res.generation_id)
+
+ def test_parser_mid(self):
+ self._test_parser(self.role, self.generation_id)
+
+ def test_parser_max(self):
+ role = 0xffffffff
+ generation_id = 0xffffffffffffffff
+ self._test_parser(role, generation_id)
+
+ def test_parser_min(self):
+ role = ofproto.OFPCR_ROLE_NOCHANGE
+ generation_id = 0
+ self._test_parser(role, generation_id)
+
+ def test_parser_p1(self):
+ role = ofproto.OFPCR_ROLE_EQUAL
+ self._test_parser(role, self.generation_id)
+
+ def test_parser_p2(self):
+ role = ofproto.OFPCR_ROLE_MASTER
+ self._test_parser(role, self.generation_id)
+
+ def test_parser_p3(self):
+ role = ofproto.OFPCR_ROLE_SLAVE
+ self._test_parser(role, self.generation_id)
+
+
+class TestOFPMatch(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPMatch
+ """
+
+ def test_init(self):
+ res = OFPMatch()
+
+ # wc check
+ eq_(res._wc.metadata_mask, 0)
+ eq_(res._wc.dl_dst_mask, 0)
+ eq_(res._wc.dl_src_mask, 0)
+ eq_(res._wc.vlan_vid_mask, 0)
+ eq_(res._wc.ipv4_src_mask, 0)
+ eq_(res._wc.ipv4_dst_mask, 0)
+ eq_(res._wc.arp_spa_mask, 0)
+ eq_(res._wc.arp_tpa_mask, 0)
+ eq_(res._wc.arp_sha_mask, 0)
+ eq_(res._wc.arp_tha_mask, 0)
+ eq_(res._wc.ipv6_src_mask, [])
+ eq_(res._wc.ipv6_dst_mask, [])
+ eq_(res._wc.ipv6_flabel_mask, 0)
+ eq_(res._wc.wildcards, (1 << 64) - 1)
+
+ # flow check
+ eq_(res._flow.in_port, 0)
+ eq_(res._flow.in_phy_port, 0)
+ eq_(res._flow.metadata, 0)
+ eq_(res._flow.dl_dst, mac.DONTCARE)
+ eq_(res._flow.dl_src, mac.DONTCARE)
+ eq_(res._flow.dl_type, 0)
+ eq_(res._flow.vlan_vid, 0)
+ eq_(res._flow.vlan_pcp, 0)
+ eq_(res._flow.ip_dscp, 0)
+ eq_(res._flow.ip_ecn, 0)
+ eq_(res._flow.ip_proto, 0)
+ eq_(res._flow.ipv4_src, 0)
+ eq_(res._flow.ipv4_dst, 0)
+ eq_(res._flow.tcp_src, 0)
+ eq_(res._flow.tcp_dst, 0)
+ eq_(res._flow.udp_src, 0)
+ eq_(res._flow.udp_dst, 0)
+ eq_(res._flow.sctp_src, 0)
+ eq_(res._flow.sctp_dst, 0)
+ eq_(res._flow.icmpv4_type, 0)
+ eq_(res._flow.icmpv4_code, 0)
+ eq_(res._flow.arp_op, 0)
+ eq_(res._flow.arp_spa, 0)
+ eq_(res._flow.arp_tpa, 0)
+ eq_(res._flow.arp_sha, 0)
+ eq_(res._flow.arp_tha, 0)
+ eq_(res._flow.ipv6_src, [])
+ eq_(res._flow.ipv6_dst, [])
+ eq_(res._flow.ipv6_flabel, 0)
+ eq_(res._flow.icmpv6_type, 0)
+ eq_(res._flow.icmpv6_code, 0)
+ eq_(res._flow.ipv6_nd_target, [])
+ eq_(res._flow.ipv6_nd_sll, 0)
+ eq_(res._flow.ipv6_nd_tll, 0)
+ eq_(res._flow.mpls_label, 0)
+ eq_(res._flow.mpls_tc, 0)
+
+ # flow check
+ eq_(res.fields, [])
+
+ def _test_serialize_and_parser(self, match, header, value, mask=None):
+ cls_ = OFPMatchField._FIELDS_HEADERS.get(header)
+ pack_str = cls_.pack_str.replace('!', '')
+ fmt = '!HHI' + pack_str
+
+ # serialize
+ buf = bytearray()
+ length = match.serialize(buf, 0)
+ eq_(length, len(buf))
+ if mask and len(buf) > calcsize(fmt):
+ fmt += pack_str
+
+ res = list(unpack_from(fmt, six.binary_type(buf), 0)[3:])
+ if type(value) is list:
+ res_value = res[:calcsize(pack_str) // 2]
+ eq_(res_value, value)
+ if mask:
+ res_mask = res[calcsize(pack_str) // 2:]
+ eq_(res_mask, mask)
+ else:
+ res_value = res.pop(0)
+ if cls_.__name__ == 'MTVlanVid':
+ eq_(res_value, value | ofproto.OFPVID_PRESENT)
+ else:
+ eq_(res_value, value)
+ if mask and res and res[0]:
+ res_mask = res[0]
+ eq_(res_mask, mask)
+
+ # parser
+ res = match.parser(six.binary_type(buf), 0)
+ eq_(res.type, ofproto.OFPMT_OXM)
+ eq_(res.fields[0].header, header)
+ eq_(res.fields[0].value, value)
+ if mask and res.fields[0].mask is not None:
+ eq_(res.fields[0].mask, mask)
+
+ # to_jsondict
+ jsondict = match.to_jsondict()
+
+ # from_jsondict
+ match2 = match.from_jsondict(jsondict["OFPMatch"])
+ buf2 = bytearray()
+ match2.serialize(buf2, 0)
+ eq_(str(match), str(match2))
+ eq_(buf, buf2)
+
+ def test_parse_unknown_field(self):
+ buf = bytearray()
+ pack_utils.msg_pack_into('!HH', buf, 0, ofproto.OFPMT_OXM, 4 + 6)
+ header = ofproto.oxm_tlv_header(36, 2)
+ pack_utils.msg_pack_into('!IH', buf, 4, header, 1)
+ header = ofproto.OXM_OF_ETH_TYPE
+ pack_utils.msg_pack_into('!IH', buf, 10, header, 1)
+
+ match = OFPMatch()
+ res = match.parser(six.binary_type(buf), 0)
+
+ # set_in_port
+ def _test_set_in_port(self, in_port):
+ header = ofproto.OXM_OF_IN_PORT
+ match = OFPMatch()
+ match.set_in_port(in_port)
+ self._test_serialize_and_parser(match, header, in_port)
+
+ def test_set_in_port_mid(self):
+ self._test_set_in_port(0xff8)
+
+ def test_set_in_port_max(self):
+ self._test_set_in_port(0xffffffff)
+
+ def test_set_in_port_min(self):
+ self._test_set_in_port(0)
+
+ # set_in_phy_port
+ def _test_set_in_phy_port(self, phy_port):
+ header = ofproto.OXM_OF_IN_PHY_PORT
+ match = OFPMatch()
+ match.set_in_phy_port(phy_port)
+ self._test_serialize_and_parser(match, header, phy_port)
+
+ def test_set_in_phy_port_mid(self):
+ self._test_set_in_phy_port(1)
+
+ def test_set_in_phy_port_max(self):
+ self._test_set_in_phy_port(0xffffffff)
+
+ def test_set_in_phy_port_min(self):
+ self._test_set_in_phy_port(0)
+
+ # set_metadata
+ def _test_set_metadata(self, metadata, mask=None):
+ header = ofproto.OXM_OF_METADATA
+ match = OFPMatch()
+ if mask is None:
+ match.set_metadata(metadata)
+ else:
+ if (mask + 1) >> 64 != 1:
+ header = ofproto.OXM_OF_METADATA_W
+ match.set_metadata_masked(metadata, mask)
+ metadata &= mask
+ self._test_serialize_and_parser(match, header, metadata, mask)
+
+ def test_set_metadata_mid(self):
+ self._test_set_metadata(0x1212121212121212)
+
+ def test_set_metadata_max(self):
+ self._test_set_metadata(0xffffffffffffffff)
+
+ def test_set_metadata_min(self):
+ self._test_set_metadata(0)
+
+ def test_set_metadata_masked_mid(self):
+ self._test_set_metadata(0x1212121212121212, 0xff00ff00ff00ff00)
+
+ def test_set_metadata_masked_max(self):
+ self._test_set_metadata(0x1212121212121212, 0xffffffffffffffff)
+
+ def test_set_metadata_masked_min(self):
+ self._test_set_metadata(0x1212121212121212, 0)
+
+ # set_dl_dst
+ def _test_set_dl_dst(self, dl_dst, mask=None):
+ header = ofproto.OXM_OF_ETH_DST
+ match = OFPMatch()
+ dl_dst = mac.haddr_to_bin(dl_dst)
+ if mask is None:
+ match.set_dl_dst(dl_dst)
+ else:
+ header = ofproto.OXM_OF_ETH_DST_W
+ mask = mac.haddr_to_bin(mask)
+ match.set_dl_dst_masked(dl_dst, mask)
+ dl_dst = mac.haddr_bitand(dl_dst, mask)
+ self._test_serialize_and_parser(match, header, dl_dst, mask)
+
+ def test_set_dl_dst_mid(self):
+ self._test_set_dl_dst('e2:7a:09:79:0b:0f')
+
+ def test_set_dl_dst_max(self):
+ self._test_set_dl_dst('ff:ff:ff:ff:ff:ff')
+
+ def test_set_dl_dst_min(self):
+ self._test_set_dl_dst('00:00:00:00:00:00')
+
+ def test_set_dl_dst_masked_mid(self):
+ self._test_set_dl_dst('e2:7a:09:79:0b:0f', 'ff:00:ff:00:ff:00')
+
+ def test_set_dl_dst_masked_max(self):
+ self._test_set_dl_dst('e2:7a:09:79:0b:0f', 'ff:ff:ff:ff:ff:ff')
+
+ def test_set_dl_dst_masked_min(self):
+ self._test_set_dl_dst('e2:7a:09:79:0b:0f', '00:00:00:00:00:00')
+
+ # set_dl_src
+ def _test_set_dl_src(self, dl_src, mask=None):
+ header = ofproto.OXM_OF_ETH_SRC
+ match = OFPMatch()
+ dl_src = mac.haddr_to_bin(dl_src)
+ if mask is None:
+ match.set_dl_src(dl_src)
+ else:
+ header = ofproto.OXM_OF_ETH_SRC_W
+ mask = mac.haddr_to_bin(mask)
+ match.set_dl_src_masked(dl_src, mask)
+ dl_src = mac.haddr_bitand(dl_src, mask)
+ self._test_serialize_and_parser(match, header, dl_src, mask)
+
+ def test_set_dl_src_mid(self):
+ self._test_set_dl_src('d0:98:79:b4:75:b5')
+
+ def test_set_dl_src_max(self):
+ self._test_set_dl_src('ff:ff:ff:ff:ff:ff')
+
+ def test_set_dl_src_min(self):
+ self._test_set_dl_src('00:00:00:00:00:00')
+
+ def test_set_dl_src_masked_mid(self):
+ self._test_set_dl_src('d0:98:79:b4:75:b5', 'f0:f0:f0:f0:f0:f0')
+
+ def test_set_dl_src_masked_max(self):
+ self._test_set_dl_src('d0:98:79:b4:75:b5', 'ff:ff:ff:ff:ff:ff')
+
+ def test_set_dl_src_masked_min(self):
+ self._test_set_dl_src('d0:98:79:b4:75:b5', '00:00:00:00:00:00')
+
+ # set_dl_type
+ def _test_set_dl_type(self, value):
+ header = ofproto.OXM_OF_ETH_TYPE
+ match = OFPMatch()
+ match.set_dl_type(value)
+ self._test_serialize_and_parser(match, header, value)
+
+ def test_set_dl_type_mid(self):
+ self._test_set_dl_type(0x7fb6)
+
+ def test_set_dl_type_max(self):
+ self._test_set_dl_type(0xffff)
+
+ def test_set_dl_type_min(self):
+ self._test_set_dl_type(0)
+
+ def test_set_dl_type_ip(self):
+ value = ether.ETH_TYPE_IP
+ self._test_set_dl_type(value)
+
+ def test_set_dl_type_arp(self):
+ value = ether.ETH_TYPE_ARP
+ self._test_set_dl_type(value)
+
+ def test_set_dl_type_ipv6(self):
+ value = ether.ETH_TYPE_IPV6
+ self._test_set_dl_type(value)
+
+ def test_set_dl_type_slow(self):
+ value = ether.ETH_TYPE_SLOW
+ self._test_set_dl_type(value)
+
+ # set_vlan_vid
+ def _test_set_vlan_vid(self, vid, mask=None):
+ header = ofproto.OXM_OF_VLAN_VID
+ match = OFPMatch()
+ if mask is None:
+ match.set_vlan_vid(vid)
+ else:
+ header = ofproto.OXM_OF_VLAN_VID_W
+ match.set_vlan_vid_masked(vid, mask)
+ self._test_serialize_and_parser(match, header, vid, mask)
+
+ def _test_set_vlan_vid_none(self):
+ header = ofproto.OXM_OF_VLAN_VID
+ match = OFPMatch()
+ match.set_vlan_vid_none()
+ value = ofproto.OFPVID_NONE
+ cls_ = OFPMatchField._FIELDS_HEADERS.get(header)
+ pack_str = cls_.pack_str.replace('!', '')
+ fmt = '!HHI' + pack_str
+
+ # serialize
+ buf = bytearray()
+ length = match.serialize(buf, 0)
+ eq_(length, len(buf))
+
+ res = list(unpack_from(fmt, six.binary_type(buf), 0)[3:])
+ res_value = res.pop(0)
+ eq_(res_value, value)
+
+ # parser
+ res = match.parser(six.binary_type(buf), 0)
+ eq_(res.type, ofproto.OFPMT_OXM)
+ eq_(res.fields[0].header, header)
+ eq_(res.fields[0].value, value)
+
+ # to_jsondict
+ jsondict = match.to_jsondict()
+
+ # from_jsondict
+ match2 = match.from_jsondict(jsondict["OFPMatch"])
+ buf2 = bytearray()
+ match2.serialize(buf2, 0)
+ eq_(str(match), str(match2))
+ eq_(buf, buf2)
+
+ def test_set_vlan_vid_mid(self):
+ self._test_set_vlan_vid(2047)
+
+ def test_set_vlan_vid_max(self):
+ self._test_set_vlan_vid(0xfff)
+
+ def test_set_vlan_vid_min(self):
+ self._test_set_vlan_vid(0)
+
+ def test_set_vlan_vid_masked_mid(self):
+ self._test_set_vlan_vid(2047, 0xf0f)
+
+ def test_set_vlan_vid_masked_max(self):
+ self._test_set_vlan_vid(2047, 0xfff)
+
+ def test_set_vlan_vid_masked_min(self):
+ self._test_set_vlan_vid(2047, 0)
+
+ def test_set_vlan_vid_none(self):
+ self._test_set_vlan_vid_none()
+
+ # set_vlan_pcp
+ def _test_set_vlan_pcp(self, pcp):
+ header = ofproto.OXM_OF_VLAN_PCP
+ match = OFPMatch()
+ match.set_vlan_pcp(pcp)
+ self._test_serialize_and_parser(match, header, pcp)
+
+ def test_set_vlan_pcp_mid(self):
+ self._test_set_vlan_pcp(5)
+
+ def test_set_vlan_pcp_max(self):
+ self._test_set_vlan_pcp(7)
+
+ def test_set_vlan_pcp_min(self):
+ self._test_set_vlan_pcp(0)
+
+ # set_ip_dscp
+ def _test_set_ip_dscp(self, ip_dscp):
+ header = ofproto.OXM_OF_IP_DSCP
+ match = OFPMatch()
+ match.set_ip_dscp(ip_dscp)
+ self._test_serialize_and_parser(match, header, ip_dscp)
+
+ def test_set_ip_dscp_mid(self):
+ self._test_set_ip_dscp(36)
+
+ def test_set_ip_dscp_max(self):
+ self._test_set_ip_dscp(63)
+
+ def test_set_ip_dscp_min(self):
+ self._test_set_ip_dscp(0)
+
+ # set_ip_ecn
+ def _test_set_ip_ecn(self, ip_ecn):
+ header = ofproto.OXM_OF_IP_ECN
+ match = OFPMatch()
+ match.set_ip_ecn(ip_ecn)
+ self._test_serialize_and_parser(match, header, ip_ecn)
+
+ def test_set_ip_ecn_mid(self):
+ self._test_set_ip_ecn(1)
+
+ def test_set_ip_ecn_max(self):
+ self._test_set_ip_ecn(3)
+
+ def test_set_ip_ecn_min(self):
+ self._test_set_ip_ecn(0)
+
+ # set_ip_proto
+ def _test_set_ip_proto(self, ip_proto):
+ header = ofproto.OXM_OF_IP_PROTO
+ match = OFPMatch()
+ match.set_ip_proto(ip_proto)
+ self._test_serialize_and_parser(match, header, ip_proto)
+
+ def test_set_ip_proto_mid(self):
+ self._test_set_ip_proto(6)
+
+ def test_set_ip_proto_max(self):
+ self._test_set_ip_proto(0xff)
+
+ def test_set_ip_proto_min(self):
+ self._test_set_ip_proto(0)
+
+ # set_ipv4_src
+ def _test_set_ipv4_src(self, ip, mask=None):
+ header = ofproto.OXM_OF_IPV4_SRC
+ match = OFPMatch()
+ ip = unpack('!I', socket.inet_aton(ip))[0]
+ if mask is None:
+ match.set_ipv4_src(ip)
+ else:
+ mask = unpack('!I', socket.inet_aton(mask))[0]
+ if (mask + 1) >> 32 != 1:
+ header = ofproto.OXM_OF_IPV4_SRC_W
+ match.set_ipv4_src_masked(ip, mask)
+ self._test_serialize_and_parser(match, header, ip, mask)
+
+ def test_set_ipv4_src_mid(self):
+ self._test_set_ipv4_src('192.168.196.250')
+
+ def test_set_ipv4_src_max(self):
+ self._test_set_ipv4_src('255.255.255.255')
+
+ def test_set_ipv4_src_min(self):
+ self._test_set_ipv4_src('0.0.0.0')
+
+ def test_set_ipv4_src_masked_mid(self):
+ self._test_set_ipv4_src('192.168.196.250', '255.255.0.0')
+
+ def test_set_ipv4_src_masked_max(self):
+ self._test_set_ipv4_src('192.168.196.250', '255.255.255.255')
+
+ def test_set_ipv4_src_masked_min(self):
+ self._test_set_ipv4_src('192.168.196.250', '0.0.0.0')
+
+ # set_ipv4_dst
+ def _test_set_ipv4_dst(self, ip, mask=None):
+ header = ofproto.OXM_OF_IPV4_DST
+ match = OFPMatch()
+ ip = unpack('!I', socket.inet_aton(ip))[0]
+ if mask is None:
+ match.set_ipv4_dst(ip)
+ else:
+ mask = unpack('!I', socket.inet_aton(mask))[0]
+ if (mask + 1) >> 32 != 1:
+ header = ofproto.OXM_OF_IPV4_DST_W
+ match.set_ipv4_dst_masked(ip, mask)
+ self._test_serialize_and_parser(match, header, ip, mask)
+
+ def test_set_ipv4_dst_mid(self):
+ self._test_set_ipv4_dst('192.168.196.250')
+
+ def test_set_ipv4_dst_max(self):
+ self._test_set_ipv4_dst('255.255.255.255')
+
+ def test_set_ipv4_dst_min(self):
+ self._test_set_ipv4_dst('0.0.0.0')
+
+ def test_set_ipv4_dst_masked_mid(self):
+ self._test_set_ipv4_dst('192.168.196.250', '255.255.0.0')
+
+ def test_set_ipv4_dst_masked_max(self):
+ self._test_set_ipv4_dst('192.168.196.250', '255.255.255.255')
+
+ def test_set_ipv4_dst_masked_min(self):
+ self._test_set_ipv4_dst('192.168.196.250', '0.0.0.0')
+
+ # set_tcp_src
+ def _test_set_tcp_src(self, tcp_src):
+ header = ofproto.OXM_OF_TCP_SRC
+ match = OFPMatch()
+ match.set_tcp_src(tcp_src)
+ self._test_serialize_and_parser(match, header, tcp_src)
+
+ def test_set_tcp_src_mid(self):
+ self._test_set_tcp_src(1103)
+
+ def test_set_tcp_src_max(self):
+ self._test_set_tcp_src(0xffff)
+
+ def test_set_tcp_src_min(self):
+ self._test_set_tcp_src(0)
+
+ # set_tcp_dst
+ def _test_set_tcp_dst(self, tcp_dst):
+ header = ofproto.OXM_OF_TCP_DST
+ match = OFPMatch()
+ match.set_tcp_dst(tcp_dst)
+ self._test_serialize_and_parser(match, header, tcp_dst)
+
+ def test_set_tcp_dst_mid(self):
+ self._test_set_tcp_dst(236)
+
+ def test_set_tcp_dst_max(self):
+ self._test_set_tcp_dst(0xffff)
+
+ def test_set_tcp_dst_min(self):
+ self._test_set_tcp_dst(0)
+
+ # set_udp_src
+ def _test_set_udp_src(self, udp_src):
+ header = ofproto.OXM_OF_UDP_SRC
+ match = OFPMatch()
+ match.set_udp_src(udp_src)
+ self._test_serialize_and_parser(match, header, udp_src)
+
+ def test_set_udp_src_mid(self):
+ self._test_set_udp_src(56617)
+
+ def test_set_udp_src_max(self):
+ self._test_set_udp_src(0xffff)
+
+ def test_set_udp_src_min(self):
+ self._test_set_udp_src(0)
+
+ # set_udp_dst
+ def _test_set_udp_dst(self, udp_dst):
+ header = ofproto.OXM_OF_UDP_DST
+ match = OFPMatch()
+ match.set_udp_dst(udp_dst)
+ self._test_serialize_and_parser(match, header, udp_dst)
+
+ def test_set_udp_dst_mid(self):
+ self._test_set_udp_dst(61278)
+
+ def test_set_udp_dst_max(self):
+ self._test_set_udp_dst(0xffff)
+
+ def test_set_udp_dst_min(self):
+ self._test_set_udp_dst(0)
+
+ # set_sctp_src
+ def _test_set_sctp_src(self, sctp_src):
+ header = ofproto.OXM_OF_SCTP_SRC
+ match = OFPMatch()
+ match.set_sctp_src(sctp_src)
+ self._test_serialize_and_parser(match, header, sctp_src)
+
+ def test_set_sctp_src_mid(self):
+ self._test_set_sctp_src(9999)
+
+ def test_set_sctp_src_max(self):
+ self._test_set_sctp_src(0xffff)
+
+ def test_set_sctp_src_min(self):
+ self._test_set_sctp_src(0)
+
+ # set_sctp_dst
+ def _test_set_sctp_dst(self, sctp_dst):
+ header = ofproto.OXM_OF_SCTP_DST
+ match = OFPMatch()
+ match.set_sctp_dst(sctp_dst)
+ self._test_serialize_and_parser(match, header, sctp_dst)
+
+ def test_set_sctp_dst_mid(self):
+ self._test_set_sctp_dst(1234)
+
+ def test_set_sctp_dst_max(self):
+ self._test_set_sctp_dst(0xffff)
+
+ def test_set_sctp_dst_min(self):
+ self._test_set_sctp_dst(0)
+
+ # set_icmpv4_type
+ def _test_set_icmpv4_type(self, icmpv4_type):
+ header = ofproto.OXM_OF_ICMPV4_TYPE
+ match = OFPMatch()
+ match.set_icmpv4_type(icmpv4_type)
+ self._test_serialize_and_parser(match, header, icmpv4_type)
+
+ def test_set_icmpv4_type_mid(self):
+ self._test_set_icmpv4_type(8)
+
+ def test_set_icmpv4_type_max(self):
+ self._test_set_icmpv4_type(0xff)
+
+ def test_set_icmpv4_type_min(self):
+ self._test_set_icmpv4_type(0)
+
+ # set_icmpv4_code
+ def _test_set_icmpv4_code(self, icmpv4_code):
+ header = ofproto.OXM_OF_ICMPV4_CODE
+ match = OFPMatch()
+ match.set_icmpv4_code(icmpv4_code)
+ self._test_serialize_and_parser(match, header, icmpv4_code)
+
+ def test_set_icmpv4_code_mid(self):
+ self._test_set_icmpv4_code(1)
+
+ def test_set_icmpv4_code_max(self):
+ self._test_set_icmpv4_code(0xff)
+
+ def test_set_icmpv4_code_min(self):
+ self._test_set_icmpv4_code(0)
+
+ # set_arp_opcode
+ def _test_set_arp_opcode(self, arp_op):
+ header = ofproto.OXM_OF_ARP_OP
+ match = OFPMatch()
+ match.set_arp_opcode(arp_op)
+ self._test_serialize_and_parser(match, header, arp_op)
+
+ def test_set_arp_opcode_mid(self):
+ self._test_set_arp_opcode(1)
+
+ def test_set_arp_opcode_max(self):
+ self._test_set_arp_opcode(0xffff)
+
+ def test_set_arp_opcode_min(self):
+ self._test_set_arp_opcode(0)
+
+ # set_arp_spa
+ def _test_set_arp_spa(self, ip, mask=None):
+ header = ofproto.OXM_OF_ARP_SPA
+ match = OFPMatch()
+ ip = unpack('!I', socket.inet_aton(ip))[0]
+ if mask is None:
+ match.set_arp_spa(ip)
+ else:
+ mask = unpack('!I', socket.inet_aton(mask))[0]
+ if (mask + 1) >> 32 != 1:
+ header = ofproto.OXM_OF_ARP_SPA_W
+ match.set_arp_spa_masked(ip, mask)
+ self._test_serialize_and_parser(match, header, ip, mask)
+
+ def test_set_arp_spa_mid(self):
+ self._test_set_arp_spa('192.168.227.57')
+
+ def test_set_arp_spa_max(self):
+ self._test_set_arp_spa('255.255.255.255')
+
+ def test_set_arp_spa_min(self):
+ self._test_set_arp_spa('0.0.0.0')
+
+ def test_set_arp_spa_masked_mid(self):
+ self._test_set_arp_spa('192.168.227.57', '255.255.0.0')
+
+ def test_set_arp_spa_masked_max(self):
+ self._test_set_arp_spa('192.168.227.57', '255.255.255.255')
+
+ def test_set_arp_spa_masked_min(self):
+ self._test_set_arp_spa('192.168.227.57', '0.0.0.0')
+
+ # set_arp_tpa
+ def _test_set_arp_tpa(self, ip, mask=None):
+ header = ofproto.OXM_OF_ARP_TPA
+ match = OFPMatch()
+ ip = unpack('!I', socket.inet_aton(ip))[0]
+ if mask is None:
+ match.set_arp_tpa(ip)
+ else:
+ mask = unpack('!I', socket.inet_aton(mask))[0]
+ if (mask + 1) >> 32 != 1:
+ header = ofproto.OXM_OF_ARP_TPA_W
+ match.set_arp_tpa_masked(ip, mask)
+ self._test_serialize_and_parser(match, header, ip, mask)
+
+ def test_set_arp_tpa_mid(self):
+ self._test_set_arp_tpa('192.168.227.57')
+
+ def test_set_arp_tpa_max(self):
+ self._test_set_arp_tpa('255.255.255.255')
+
+ def test_set_arp_tpa_min(self):
+ self._test_set_arp_tpa('0.0.0.0')
+
+ def test_set_arp_tpa_masked_mid(self):
+ self._test_set_arp_tpa('192.168.227.57', '255.255.0.0')
+
+ def test_set_arp_tpa_masked_max(self):
+ self._test_set_arp_tpa('192.168.227.57', '255.255.255.255')
+
+ def test_set_arp_tpa_masked_min(self):
+ self._test_set_arp_tpa('192.168.227.57', '0.0.0.0')
+
+ # set_arp_sha
+ def _test_set_arp_sha(self, arp_sha, mask=None):
+ header = ofproto.OXM_OF_ARP_SHA
+ match = OFPMatch()
+ arp_sha = mac.haddr_to_bin(arp_sha)
+ if mask is None:
+ match.set_arp_sha(arp_sha)
+ else:
+ header = ofproto.OXM_OF_ARP_SHA_W
+ mask = mac.haddr_to_bin(mask)
+ match.set_arp_sha_masked(arp_sha, mask)
+ arp_sha = mac.haddr_bitand(arp_sha, mask)
+ self._test_serialize_and_parser(match, header, arp_sha, mask)
+
+ def test_set_arp_sha_mid(self):
+ self._test_set_arp_sha('3e:ec:13:9b:f3:0b')
+
+ def test_set_arp_sha_max(self):
+ self._test_set_arp_sha('ff:ff:ff:ff:ff:ff')
+
+ def test_set_arp_sha_min(self):
+ self._test_set_arp_sha('00:00:00:00:00:00')
+
+ def test_set_arp_sha_masked_mid(self):
+ self._test_set_arp_sha('3e:ec:13:9b:f3:0b', 'ff:ff:ff:00:00:00')
+
+ def test_set_arp_sha_masked_max(self):
+ self._test_set_arp_sha('3e:ec:13:9b:f3:0b', 'ff:ff:ff:ff:ff:ff')
+
+ def test_set_arp_sha_masked_min(self):
+ self._test_set_arp_sha('3e:ec:13:9b:f3:0b', '00:00:00:00:00:00')
+
+ # set_arp_tha
+ def _test_set_arp_tha(self, arp_tha, mask=None):
+ header = ofproto.OXM_OF_ARP_THA
+ match = OFPMatch()
+ arp_tha = mac.haddr_to_bin(arp_tha)
+ if mask is None:
+ match.set_arp_tha(arp_tha)
+ else:
+ header = ofproto.OXM_OF_ARP_THA_W
+ mask = mac.haddr_to_bin(mask)
+ match.set_arp_tha_masked(arp_tha, mask)
+ arp_tha = mac.haddr_bitand(arp_tha, mask)
+ self._test_serialize_and_parser(match, header, arp_tha, mask)
+
+ def test_set_arp_tha_mid(self):
+ self._test_set_arp_tha('83:6c:21:52:49:68')
+
+ def test_set_arp_tha_max(self):
+ self._test_set_arp_tha('ff:ff:ff:ff:ff:ff')
+
+ def test_set_arp_tha_min(self):
+ self._test_set_arp_tha('00:00:00:00:00:00')
+
+ def test_set_arp_tha_masked_mid(self):
+ self._test_set_arp_tha('83:6c:21:52:49:68', 'ff:ff:ff:00:00:00')
+
+ def test_set_arp_tha_masked_max(self):
+ self._test_set_arp_tha('83:6c:21:52:49:68', 'ff:ff:ff:ff:ff:ff')
+
+ def test_set_arp_tha_masked_min(self):
+ self._test_set_arp_tha('83:6c:21:52:49:68', '00:00:00:00:00:00')
+
+ # set_ipv6_src
+ def _test_set_ipv6_src(self, ipv6, mask=None):
+ header = ofproto.OXM_OF_IPV6_SRC
+ match = OFPMatch()
+ ipv6 = [int(x, 16) for x in ipv6.split(":")]
+ if mask is None:
+ match.set_ipv6_src(ipv6)
+ else:
+ header = ofproto.OXM_OF_IPV6_SRC_W
+ mask = [int(x, 16) for x in mask.split(":")]
+ match.set_ipv6_src_masked(ipv6, mask)
+ ipv6 = [x & y for (x, y) in zip(ipv6, mask)]
+ self._test_serialize_and_parser(match, header, ipv6, mask)
+
+ def test_set_ipv6_src_mid(self):
+ ipv6 = '2001:db8:bd05:1d2:288a:1fc0:1:10ee'
+ self._test_set_ipv6_src(ipv6)
+
+ def test_set_ipv6_src_max(self):
+ ipv6 = 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'
+ self._test_set_ipv6_src(ipv6)
+
+ def test_set_ipv6_src_min(self):
+ ipv6 = '0:0:0:0:0:0:0:0'
+ self._test_set_ipv6_src(ipv6)
+
+ def test_set_ipv6_src_masked_mid(self):
+ ipv6 = '2001:db8:bd05:1d2:288a:1fc0:1:10ee'
+ mask = 'ffff:ffff:ffff:ffff:0:0:0:0'
+ self._test_set_ipv6_src(ipv6, mask)
+
+ def test_set_ipv6_src_masked_max(self):
+ ipv6 = '2001:db8:bd05:1d2:288a:1fc0:1:10ee'
+ mask = 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'
+ self._test_set_ipv6_src(ipv6, mask)
+
+ def test_set_ipv6_src_masked_min(self):
+ ipv6 = '2001:db8:bd05:1d2:288a:1fc0:1:10ee'
+ mask = '0:0:0:0:0:0:0:0'
+ self._test_set_ipv6_src(ipv6, mask)
+
+ # set_ipv6_dst
+ def _test_set_ipv6_dst(self, ipv6, mask=None):
+ header = ofproto.OXM_OF_IPV6_DST
+ match = OFPMatch()
+ ipv6 = [int(x, 16) for x in ipv6.split(":")]
+ if mask is None:
+ match.set_ipv6_dst(ipv6)
+ else:
+ header = ofproto.OXM_OF_IPV6_DST_W
+ mask = [int(x, 16) for x in mask.split(":")]
+ match.set_ipv6_dst_masked(ipv6, mask)
+ ipv6 = [x & y for (x, y) in zip(ipv6, mask)]
+ self._test_serialize_and_parser(match, header, ipv6, mask)
+
+ def test_set_ipv6_dst_mid(self):
+ ipv6 = 'e9e8:9ea5:7d67:82cc:ca54:1fc0:2d24:f038'
+ self._test_set_ipv6_dst(ipv6)
+
+ def test_set_ipv6_dst_max(self):
+ ipv6 = ':'.join(['ffff'] * 8)
+ self._test_set_ipv6_dst(ipv6)
+
+ def test_set_ipv6_dst_min(self):
+ ipv6 = ':'.join(['0'] * 8)
+ self._test_set_ipv6_dst(ipv6)
+
+ def test_set_ipv6_dst_mask_mid(self):
+ ipv6 = 'e9e8:9ea5:7d67:82cc:ca54:1fc0:2d24:f038'
+ mask = ':'.join(['ffff'] * 4 + ['0'] * 4)
+ self._test_set_ipv6_dst(ipv6, mask)
+
+ def test_set_ipv6_dst_mask_max(self):
+ ipv6 = 'e9e8:9ea5:7d67:82cc:ca54:1fc0:2d24:f038'
+ mask = ':'.join(['ffff'] * 8)
+ self._test_set_ipv6_dst(ipv6, mask)
+
+ def test_set_ipv6_dst_mask_min(self):
+ ipv6 = 'e9e8:9ea5:7d67:82cc:ca54:1fc0:2d24:f038'
+ mask = ':'.join(['0'] * 8)
+ self._test_set_ipv6_dst(ipv6, mask)
+
+ # set_ipv6_flabel
+ def _test_set_ipv6_flabel(self, flabel, mask=None):
+ header = ofproto.OXM_OF_IPV6_FLABEL
+ match = OFPMatch()
+ if mask is None:
+ match.set_ipv6_flabel(flabel)
+ else:
+ header = ofproto.OXM_OF_IPV6_FLABEL_W
+ match.set_ipv6_flabel_masked(flabel, mask)
+ self._test_serialize_and_parser(match, header, flabel, mask)
+
+ def test_set_ipv6_flabel_mid(self):
+ self._test_set_ipv6_flabel(0xc5384)
+
+ def test_set_ipv6_flabel_max(self):
+ self._test_set_ipv6_flabel(0xfffff)
+
+ def test_set_ipv6_flabel_min(self):
+ self._test_set_ipv6_flabel(0)
+
+ def test_set_ipv6_flabel_masked_mid(self):
+ self._test_set_ipv6_flabel(0xc5384, 0xfff00)
+
+ def test_set_ipv6_flabel_masked_max(self):
+ self._test_set_ipv6_flabel(0xc5384, 0xfffff)
+
+ def test_set_ipv6_flabel_masked_min(self):
+ self._test_set_ipv6_flabel(0xc5384, 0)
+
+ # set_icmpv6_type
+ def _test_set_icmpv6_type(self, icmpv6_type):
+ header = ofproto.OXM_OF_ICMPV6_TYPE
+ match = OFPMatch()
+ match.set_icmpv6_type(icmpv6_type)
+ self._test_serialize_and_parser(match, header, icmpv6_type)
+
+ def test_set_icmpv6_type_mid(self):
+ self._test_set_icmpv6_type(129)
+
+ def test_set_icmpv6_type_max(self):
+ self._test_set_icmpv6_type(0xff)
+
+ def test_set_icmpv6_type_min(self):
+ self._test_set_icmpv6_type(0)
+
+ # set_icmpv6_code
+ def _test_set_icmpv6_code(self, icmpv6_code):
+ header = ofproto.OXM_OF_ICMPV6_CODE
+ match = OFPMatch()
+ match.set_icmpv6_code(icmpv6_code)
+ self._test_serialize_and_parser(match, header, icmpv6_code)
+
+ def test_set_icmpv6_code_mid(self):
+ self._test_set_icmpv6_code(1)
+
+ def test_set_icmpv6_code_max(self):
+ self._test_set_icmpv6_code(0xff)
+
+ def test_set_icmpv6_code_min(self):
+ self._test_set_icmpv6_code(0)
+
+ # set_ipv6_nd_target
+ def _test_set_ipv6_nd_target(self, ipv6):
+ header = ofproto.OXM_OF_IPV6_ND_TARGET
+ match = OFPMatch()
+ ipv6 = [int(x, 16) for x in ipv6.split(":")]
+ match.set_ipv6_nd_target(ipv6)
+ self._test_serialize_and_parser(match, header, ipv6)
+
+ def test_set_ipv6_nd_target_mid(self):
+ ip = '5420:db3f:921b:3e33:2791:98f:dd7f:2e19'
+ self._test_set_ipv6_nd_target(ip)
+
+ def test_set_ipv6_nd_target_max(self):
+ ip = ':'.join(['ffff'] * 8)
+ self._test_set_ipv6_nd_target(ip)
+
+ def test_set_ipv6_nd_target_min(self):
+ ip = ':'.join(['0'] * 8)
+ self._test_set_ipv6_nd_target(ip)
+
+ # set_ipv6_nd_sll
+ def _test_set_ipv6_nd_sll(self, nd_sll):
+ header = ofproto.OXM_OF_IPV6_ND_SLL
+ match = OFPMatch()
+ nd_sll = mac.haddr_to_bin(nd_sll)
+ match.set_ipv6_nd_sll(nd_sll)
+ self._test_serialize_and_parser(match, header, nd_sll)
+
+ def test_set_ipv6_nd_sll_mid(self):
+ self._test_set_ipv6_nd_sll('93:6d:d0:d4:e8:36')
+
+ def test_set_ipv6_nd_sll_max(self):
+ self._test_set_ipv6_nd_sll('ff:ff:ff:ff:ff:ff')
+
+ def test_set_ipv6_nd_sll_min(self):
+ self._test_set_ipv6_nd_sll('00:00:00:00:00:00')
+
+ # set_ipv6_nd_tll
+ def _test_set_ipv6_nd_tll(self, nd_tll):
+ header = ofproto.OXM_OF_IPV6_ND_TLL
+ match = OFPMatch()
+ nd_tll = mac.haddr_to_bin(nd_tll)
+ match.set_ipv6_nd_tll(nd_tll)
+ self._test_serialize_and_parser(match, header, nd_tll)
+
+ def test_set_ipv6_nd_tll_mid(self):
+ self._test_set_ipv6_nd_tll('18:f6:66:b6:f1:b3')
+
+ def test_set_ipv6_nd_tll_max(self):
+ self._test_set_ipv6_nd_tll('ff:ff:ff:ff:ff:ff')
+
+ def test_set_ipv6_nd_tll_min(self):
+ self._test_set_ipv6_nd_tll('00:00:00:00:00:00')
+
+ # set_mpls_label
+ def _test_set_mpls_label(self, mpls_label):
+ header = ofproto.OXM_OF_MPLS_LABEL
+ match = OFPMatch()
+ match.set_mpls_label(mpls_label)
+ self._test_serialize_and_parser(match, header, mpls_label)
+
+ def test_set_mpls_label_mid(self):
+ self._test_set_mpls_label(2144)
+
+ def test_set_mpls_label_max(self):
+ self._test_set_mpls_label(0xfffff)
+
+ def test_set_mpls_label_min(self):
+ self._test_set_mpls_label(0)
+
+ # set_mpls_tc
+ def _test_set_mpls_tc(self, mpls_tc):
+ header = ofproto.OXM_OF_MPLS_TC
+ match = OFPMatch()
+ match.set_mpls_tc(mpls_tc)
+ self._test_serialize_and_parser(match, header, mpls_tc)
+
+ def test_set_mpls_tc_mid(self):
+ self._test_set_mpls_tc(3)
+
+ def test_set_mpls_tc_max(self):
+ self._test_set_mpls_tc(7)
+
+ def test_set_mpls_tc_min(self):
+ self._test_set_mpls_tc(0)
+
+
+class TestOFPMatchField(unittest.TestCase):
+ """ Test case for ofproto_v1_2_parser.OFPMatchField
+ """
+
+ def test_init_hasmask_true(self):
+ header = 0x0100
+
+ res = OFPMatchField(header)
+
+ eq_(res.header, header)
+ eq_(res.n_bytes, (header & 0xff) // 2)
+ eq_(res.length, 0)
+
+ def test_init_hasmask_false(self):
+ header = 0x0000
+
+ res = OFPMatchField(header)
+
+ eq_(res.header, header)
+ eq_(res.n_bytes, header & 0xff)
+ eq_(res.length, 0)
projects / vsorcdistro / .git / blobdiff