openstack/os-ken
Code Issues Proposed changes
a0ea1bead4
os-ken/os_ken/tests/unit/ofproto/test_parser_v12.py
Hongbin Lu 9f1f1726d0 Move files from ryu/* to os_ken/* 
After forking from Ryu, the namespace needs to change from 'ryu'
to 'os_ken' so that it won't collide with the namespace of the
old library.

Change-Id: I807a8785e525cc02825d15a1a01eec3d5d20cce4
2018-09-25 20:55:24 +00:00

7562 lines
239 KiB
Python
Raw Blame History

# 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 os_ken.ofproto.ofproto_v1_2_parser import *
from os_ken.ofproto import ofproto_v1_2_parser
from os_ken.ofproto import ofproto_v1_2
from os_ken.ofproto import ofproto_protocol
from os_ken.ofproto import ether
from os_ken.ofproto.ofproto_parser import MsgBase
from os_ken import utils
from os_ken.lib import addrconv
from os_ken.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)
View Git Blame Copy Permalink