![Hongbin Lu](/assets/img/avatar_default.png)
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
5557 lines
166 KiB
Python
5557 lines
166 KiB
Python
# 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
|
|
from nose.tools import *
|
|
from os_ken.ofproto.ofproto_v1_0_parser import *
|
|
from os_ken.ofproto.nx_actions import *
|
|
from os_ken.ofproto import ofproto_v1_0_parser
|
|
from os_ken.lib import addrconv
|
|
|
|
|
|
LOG = logging.getLogger('test_ofproto_v10')
|
|
|
|
|
|
class TestOFPPhyPort(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPPhyPort
|
|
"""
|
|
|
|
# OFP_PHY_PORT_PACK_STR
|
|
# '!H6s16sIIIIII'... port_no, hw_addr, name, config, state
|
|
# curr, advertised, supported, peer
|
|
port_no = {'buf': b'\xe7\x6b', 'val': 59243}
|
|
hw_addr = '52:54:54:10:20:99'
|
|
name = b'name'.ljust(16)
|
|
config = {'buf': b'\x84\xb6\x8c\x53', 'val': 2226555987}
|
|
state = {'buf': b'\x64\x07\xfb\xc9', 'val': 1678244809}
|
|
curr = {'buf': b'\xa9\xe8\x0a\x2b', 'val': 2850556459}
|
|
advertised = {'buf': b'\x78\xb9\x7b\x72', 'val': 2025421682}
|
|
supported = {'buf': b'\x7e\x65\x68\xad', 'val': 2120575149}
|
|
peer = {'buf': b'\xa4\x5b\x8b\xed', 'val': 2757463021}
|
|
|
|
buf = port_no['buf'] \
|
|
+ addrconv.mac.text_to_bin(hw_addr) \
|
|
+ name \
|
|
+ config['buf'] \
|
|
+ state['buf'] \
|
|
+ curr['buf'] \
|
|
+ advertised['buf'] \
|
|
+ supported['buf'] \
|
|
+ peer['buf']
|
|
|
|
c = OFPPhyPort(port_no['val'],
|
|
hw_addr,
|
|
name,
|
|
config['val'],
|
|
state['val'],
|
|
curr['val'],
|
|
advertised['val'],
|
|
supported['val'],
|
|
peer['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.port_no['val'], self.c.port_no)
|
|
eq_(self.hw_addr, self.c.hw_addr)
|
|
eq_(self.name, self.c.name)
|
|
eq_(self.config['val'], self.c.config)
|
|
eq_(self.state['val'], self.c.state)
|
|
eq_(self.curr['val'], self.c.curr)
|
|
eq_(self.advertised['val'], self.c.advertised)
|
|
eq_(self.supported['val'], self.c.supported)
|
|
eq_(self.peer['val'], self.c.peer)
|
|
|
|
def test_parser(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
|
|
eq_(self.port_no['val'], res.port_no)
|
|
eq_(self.hw_addr, res.hw_addr)
|
|
eq_(self.name, res.name)
|
|
eq_(self.config['val'], res.config)
|
|
eq_(self.state['val'], res.state)
|
|
eq_(self.curr['val'], res.curr)
|
|
eq_(self.advertised['val'], res.advertised)
|
|
eq_(self.supported['val'], res.supported)
|
|
eq_(self.peer['val'], res.peer)
|
|
|
|
|
|
class TestOFPMatch(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPMatch
|
|
"""
|
|
|
|
# OFP_MATCH_PACK_STR
|
|
# '!IH6s6sHBxHBB2xIIHH'...wildcards, in_port, dl_src, dl_dst, dl_vlan,
|
|
# dl_vlan_pcp, dl_type, nw_tos, nw_proto,
|
|
# nw_src, nw_dst, tp_src, tp_dst
|
|
wildcards = {'buf': b'\x00\x02\x10\x00', 'val': 135168}
|
|
in_port = {'buf': b'\x37\x8b', 'val': 14219}
|
|
dl_src = {'buf': b'\x52\x54\x54\x10\x20\x99',
|
|
'human': '52:54:54:10:20:99'}
|
|
dl_dst = {'buf': b'\x61\x31\x50\x6d\xc9\xe5',
|
|
'human': '61:31:50:6d:c9:e5'}
|
|
dl_vlan = {'buf': b'\xc1\xf9', 'val': 49657}
|
|
dl_vlan_pcp = {'buf': b'\x79', 'val': 121}
|
|
zfill0 = b'\x00'
|
|
dl_type = {'buf': b'\xa6\x9e', 'val': 42654}
|
|
nw_tos = {'buf': b'\xde', 'val': 222}
|
|
nw_proto = {'buf': b'\xe5', 'val': 229}
|
|
zfil11 = b'\x00' * 2
|
|
nw_src = {'buf': b'\x1b\x6d\x8d\x4b', 'val': 460164427,
|
|
'human': '27.109.141.75'}
|
|
nw_dst = {'buf': b'\xab\x25\xe1\x20', 'val': 2871386400,
|
|
'human': '171.37.225.32'}
|
|
tp_src = {'buf': b'\xd5\xc3', 'val': 54723}
|
|
tp_dst = {'buf': b'\x78\xb9', 'val': 30905}
|
|
|
|
buf = wildcards['buf'] \
|
|
+ in_port['buf'] \
|
|
+ dl_src['buf'] \
|
|
+ dl_dst['buf'] \
|
|
+ dl_vlan['buf'] \
|
|
+ dl_vlan_pcp['buf'] \
|
|
+ zfill0 \
|
|
+ dl_type['buf'] \
|
|
+ nw_tos['buf'] \
|
|
+ nw_proto['buf'] \
|
|
+ zfil11 \
|
|
+ nw_src['buf'] \
|
|
+ nw_dst['buf'] \
|
|
+ tp_src['buf'] \
|
|
+ tp_dst['buf']
|
|
|
|
def _get_obj(self, dl_src, dl_dst):
|
|
c = OFPMatch(self.wildcards['val'],
|
|
self.in_port['val'],
|
|
dl_src,
|
|
dl_dst,
|
|
self.dl_vlan['val'],
|
|
self.dl_vlan_pcp['val'],
|
|
self.dl_type['val'],
|
|
self.nw_tos['val'],
|
|
self.nw_proto['val'],
|
|
self.nw_src['val'],
|
|
self.nw_dst['val'],
|
|
self.tp_src['val'],
|
|
self.tp_dst['val'])
|
|
return c
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
c = self._get_obj(self.dl_src['buf'], self.dl_dst['buf'])
|
|
|
|
eq_(self.wildcards['val'], c.wildcards)
|
|
eq_(self.in_port['val'], c.in_port)
|
|
eq_(self.dl_src['buf'], c.dl_src)
|
|
eq_(self.dl_dst['buf'], c.dl_dst)
|
|
eq_(self.dl_vlan['val'], c.dl_vlan)
|
|
eq_(self.dl_vlan_pcp['val'], c.dl_vlan_pcp)
|
|
eq_(self.dl_type['val'], c.dl_type)
|
|
eq_(self.nw_tos['val'], c.nw_tos)
|
|
eq_(self.nw_proto['val'], c.nw_proto)
|
|
eq_(self.nw_src['val'], c.nw_src)
|
|
eq_(self.nw_dst['val'], c.nw_dst)
|
|
eq_(self.tp_src['val'], c.tp_src)
|
|
eq_(self.tp_dst['val'], c.tp_dst)
|
|
|
|
def test_init_zero(self):
|
|
c = self._get_obj(0, 0)
|
|
eq_(mac.DONTCARE, c.dl_src)
|
|
eq_(mac.DONTCARE, c.dl_dst)
|
|
|
|
def test_parse(self):
|
|
c = self._get_obj(self.dl_src['buf'], self.dl_dst['buf'])
|
|
res = c.parse(self.buf, 0)
|
|
|
|
eq_(self.wildcards['val'], res.wildcards)
|
|
eq_(self.in_port['val'], res.in_port)
|
|
eq_(self.dl_src['buf'], res.dl_src)
|
|
eq_(self.dl_dst['buf'], res.dl_dst)
|
|
eq_(self.dl_vlan['val'], res.dl_vlan)
|
|
eq_(self.dl_vlan_pcp['val'], res.dl_vlan_pcp)
|
|
eq_(self.dl_type['val'], res.dl_type)
|
|
eq_(self.nw_tos['val'], res.nw_tos)
|
|
eq_(self.nw_proto['val'], res.nw_proto)
|
|
eq_(self.nw_src['val'], res.nw_src)
|
|
eq_(self.nw_dst['val'], res.nw_dst)
|
|
eq_(self.tp_src['val'], res.tp_src)
|
|
eq_(self.tp_dst['val'], res.tp_dst)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
c = self._get_obj(self.dl_src['buf'], self.dl_dst['buf'])
|
|
|
|
c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_MATCH_PACK_STR
|
|
res = struct.unpack_from(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.wildcards['val'], res[0])
|
|
eq_(self.in_port['val'], res[1])
|
|
eq_(self.dl_src['buf'], res[2])
|
|
eq_(self.dl_dst['buf'], res[3])
|
|
eq_(self.dl_vlan['val'], res[4])
|
|
eq_(self.dl_vlan_pcp['val'], res[5])
|
|
eq_(self.dl_type['val'], res[6])
|
|
eq_(self.nw_tos['val'], res[7])
|
|
eq_(self.nw_proto['val'], res[8])
|
|
eq_(self.nw_src['val'], res[9])
|
|
eq_(self.nw_dst['val'], res[10])
|
|
eq_(self.tp_src['val'], res[11])
|
|
eq_(self.tp_dst['val'], res[12])
|
|
|
|
def test_getitem(self):
|
|
c = self._get_obj(self.dl_src['buf'], self.dl_dst['buf'])
|
|
|
|
eq_(self.wildcards['val'], c["wildcards"])
|
|
eq_(self.in_port['val'], c["in_port"])
|
|
eq_(self.dl_src['human'], c["dl_src"])
|
|
eq_(self.dl_dst['human'], c["dl_dst"])
|
|
eq_(self.dl_vlan['val'], c["dl_vlan"])
|
|
eq_(self.dl_vlan_pcp['val'], c["dl_vlan_pcp"])
|
|
eq_(self.dl_type['val'], c["dl_type"])
|
|
eq_(self.nw_tos['val'], c["nw_tos"])
|
|
eq_(self.nw_proto['val'], c["nw_proto"])
|
|
eq_(self.nw_src['human'], c["nw_src"])
|
|
eq_(self.nw_dst['human'], c["nw_dst"])
|
|
eq_(self.tp_src['val'], c["tp_src"])
|
|
eq_(self.tp_dst['val'], c["tp_dst"])
|
|
|
|
|
|
class TestOFPActionHeader(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionHeader
|
|
"""
|
|
|
|
# OFP_ACTION_HEADER_PACK_STR
|
|
# '!HH4x'...type, len, zfill
|
|
type = {'buf': b'\x00\x02', 'val': ofproto.OFPAT_SET_VLAN_PCP}
|
|
len = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_HEADER_SIZE}
|
|
zfill = b'\x00' * 4
|
|
|
|
buf = type['buf'] \
|
|
+ len['buf'] \
|
|
+ zfill
|
|
|
|
c = OFPActionHeader(type['val'], len['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.type['val'], self.c.type)
|
|
eq_(self.len['val'], self.c.len)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_ACTION_HEADER_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type['val'], res[0])
|
|
eq_(self.len['val'], res[1])
|
|
|
|
|
|
class TestOFPActionOutput(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionOutput
|
|
"""
|
|
|
|
# OFP_ACTION_OUTPUT_PACK_STR
|
|
# '!HHHH'...type, len, port, max_len
|
|
type_ = {'buf': b'\x00\x00', 'val': ofproto.OFPAT_OUTPUT}
|
|
len_ = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_OUTPUT_SIZE}
|
|
port = {'buf': b'\x19\xce', 'val': 6606}
|
|
max_len = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_OUTPUT_SIZE}
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ port['buf'] \
|
|
+ max_len['buf']
|
|
|
|
c = OFPActionOutput(port['val'], max_len['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.port['val'], self.c.port)
|
|
eq_(self.max_len['val'], self.c.max_len)
|
|
|
|
def test_parser(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
|
|
eq_(self.port['val'], res.port)
|
|
eq_(self.max_len['val'], res.max_len)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_type(self):
|
|
type_ = {'buf': b'\x00\x01', 'val': 1}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.port['buf'] \
|
|
+ self.max_len['buf']
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_len(self):
|
|
len_ = {'buf': b'\x00\x07', 'val': 7}
|
|
|
|
buf = self.type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.port['buf'] \
|
|
+ self.max_len['buf']
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_ACTION_OUTPUT_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.port['val'], res[2])
|
|
eq_(self.max_len['val'], res[3])
|
|
|
|
|
|
class TestOFPActionVlanVid(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionVlanVid
|
|
"""
|
|
|
|
# OFP_ACTION_VLAN_VID_PACK_STR
|
|
# '!HHH2x'...type, len, vlan_vid, zfill
|
|
type_ = {'buf': b'\x00\x01', 'val': ofproto.OFPAT_SET_VLAN_VID}
|
|
len_ = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_VLAN_VID_SIZE}
|
|
vlan_vid = {'buf': b'\x3c\x0e', 'val': 15374}
|
|
zfill = b'\x00' * 2
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vlan_vid['buf'] \
|
|
+ zfill
|
|
|
|
c = OFPActionVlanVid(vlan_vid['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.vlan_vid['val'], self.c.vlan_vid)
|
|
|
|
def test_parser(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
|
|
eq_(self.vlan_vid['val'], res.vlan_vid)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_type(self):
|
|
type_ = {'buf': b'\x00\x02', 'val': 2}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.vlan_vid['buf'] \
|
|
+ self.zfill
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_len(self):
|
|
len_ = {'buf': b'\x00\x07', 'val': 7}
|
|
|
|
buf = self.type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.vlan_vid['buf'] \
|
|
+ self.zfill
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_ACTION_VLAN_VID_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vlan_vid['val'], res[2])
|
|
|
|
|
|
class TestOFPActionVlanPcp(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionVlanPcp
|
|
"""
|
|
|
|
# OFP_ACTION_VLAN_PCP_PACK_STR
|
|
# '!HHB3x'...type, len, vlan_pcp, zfill
|
|
type_ = {'buf': b'\x00\x02', 'val': ofproto.OFPAT_SET_VLAN_PCP}
|
|
len_ = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_VLAN_PCP_SIZE}
|
|
vlan_pcp = {'buf': b'\x1c', 'val': 28}
|
|
zfill = b'\x00' * 3
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vlan_pcp['buf'] \
|
|
+ zfill
|
|
|
|
c = OFPActionVlanPcp(vlan_pcp['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.vlan_pcp['val'], self.c.vlan_pcp)
|
|
|
|
def test_parser(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
eq_(self.vlan_pcp['val'], res.vlan_pcp)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_type(self):
|
|
type_ = {'buf': b'\x00\x01', 'val': 1}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.vlan_pcp['buf'] \
|
|
+ self.zfill
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_len(self):
|
|
len_ = {'buf': b'\x00\x07', 'val': 7}
|
|
|
|
buf = self.type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.vlan_pcp['buf'] \
|
|
+ self.zfill
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_ACTION_VLAN_PCP_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vlan_pcp['val'], res[2])
|
|
|
|
|
|
class TestOFPActionStripVlan(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionStripVlan
|
|
"""
|
|
|
|
# OFP_ACTION_HEADER_PACK_STR
|
|
# '!HH4x'...type, len, zfill
|
|
type_ = {'buf': b'\x00\x03', 'val': ofproto.OFPAT_STRIP_VLAN}
|
|
len_ = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_HEADER_SIZE}
|
|
zfill = b'\x00' * 4
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ zfill
|
|
|
|
c = OFPActionStripVlan()
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
ok_(self.c.parser(self.buf, 0))
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_type(self):
|
|
type_ = {'buf': b'\x00\x01', 'val': 1}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.zfill
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_len(self):
|
|
len_ = {'buf': b'\x00\x07', 'val': 7}
|
|
|
|
buf = self.type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.zfill
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
|
|
class TestOFPActionSetDlSrc(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionSetDlSrc
|
|
"""
|
|
|
|
# OFP_ACTION_DL_ADDR_PACK_STR
|
|
# '!HH6s6x'...type, len, dl_addr, zfill
|
|
type_ = {'buf': b'\x00\x04', 'val': ofproto.OFPAT_SET_DL_SRC}
|
|
len_ = {'buf': b'\x00\x10', 'val': ofproto.OFP_ACTION_DL_ADDR_SIZE}
|
|
dl_addr = b'\x0e\xde\x27\xce\xc6\xcf'
|
|
zfill = b'\x00' * 6
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ dl_addr \
|
|
+ zfill
|
|
|
|
c = OFPActionSetDlSrc(dl_addr)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.dl_addr, self.c.dl_addr)
|
|
|
|
def test_parser_type_src(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
eq_(self.dl_addr, res.dl_addr)
|
|
|
|
def test_parser_type_dst(self):
|
|
type_ = {'buf': b'\x00\x05', 'val': ofproto.OFPAT_SET_DL_DST}
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.dl_addr \
|
|
+ self.zfill
|
|
|
|
res = self.c.parser(buf, 0)
|
|
|
|
eq_(self.dl_addr, res.dl_addr)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_type(self):
|
|
type_ = {'buf': b'\x00\x06', 'val': 6}
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.dl_addr \
|
|
+ self.zfill
|
|
|
|
res = self.c.parser(buf, 0)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_len(self):
|
|
len_ = {'buf': b'\x00\x07', 'val': 7}
|
|
buf = self.type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.dl_addr \
|
|
+ self.zfill
|
|
|
|
res = self.c.parser(buf, 0)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_ACTION_DL_ADDR_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.dl_addr, res[2])
|
|
|
|
|
|
class TestOFPActionSetDlDst(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionSetDlDst
|
|
"""
|
|
|
|
# OFP_ACTION_DL_ADDR_PACK_STR
|
|
# '!HH6s6x'...type, len, dl_addr, zfill
|
|
type_ = {'buf': b'\x00\x05', 'val': ofproto.OFPAT_SET_DL_DST}
|
|
len_ = {'buf': b'\x00\x10', 'val': ofproto.OFP_ACTION_DL_ADDR_SIZE}
|
|
dl_addr = b'\x37\x48\x38\x9a\xf4\x28'
|
|
zfill = b'\x00' * 6
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ dl_addr \
|
|
+ zfill
|
|
|
|
c = OFPActionSetDlDst(dl_addr)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.dl_addr, self.c.dl_addr)
|
|
|
|
def test_parser_type_dst(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
eq_(self.dl_addr, res.dl_addr)
|
|
|
|
def test_parser_type_src(self):
|
|
type_ = {'buf': b'\x00\x04', 'val': ofproto.OFPAT_SET_DL_SRC}
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.dl_addr \
|
|
+ self.zfill
|
|
|
|
res = self.c.parser(buf, 0)
|
|
|
|
eq_(self.dl_addr, res.dl_addr)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_type(self):
|
|
type_ = {'buf': b'\x00\x06', 'val': 6}
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.dl_addr \
|
|
+ self.zfill
|
|
|
|
res = self.c.parser(buf, 0)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_len(self):
|
|
len_ = {'buf': b'\x00\x07', 'val': 7}
|
|
buf = self.type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.dl_addr \
|
|
+ self.zfill
|
|
|
|
res = self.c.parser(buf, 0)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_ACTION_DL_ADDR_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.dl_addr, res[2])
|
|
|
|
|
|
class TestOFPActionSetNwSrc(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionSetNwSrc
|
|
"""
|
|
|
|
# OFP_ACTION_NW_ADDR_PACK_STR
|
|
# '!HHI'...type, len, nw_addr
|
|
type_ = {'buf': b'\x00\x06', 'val': ofproto.OFPAT_SET_NW_SRC}
|
|
len_ = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_NW_ADDR_SIZE}
|
|
nw_addr = {'buf': b'\xc0\xa8\x7a\x0a', 'val': 3232266762}
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ nw_addr['buf']
|
|
|
|
c = OFPActionSetNwSrc(nw_addr['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.nw_addr['val'], self.c.nw_addr)
|
|
|
|
def test_parser_src(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
eq_(self.nw_addr['val'], res.nw_addr)
|
|
|
|
def test_parser_dst(self):
|
|
type_ = {'buf': b'\x00\x07', 'val': ofproto.OFPAT_SET_NW_DST}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.nw_addr['buf']
|
|
|
|
res = self.c.parser(buf, 0)
|
|
eq_(self.nw_addr['val'], res.nw_addr)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_type(self):
|
|
type_ = {'buf': b'\x00\x05', 'val': 5}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.nw_addr['buf']
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_len(self):
|
|
len_ = {'buf': b'\x00\x10', 'val': 16}
|
|
|
|
buf = self.type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.nw_addr['buf']
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_ACTION_NW_ADDR_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.nw_addr['val'], res[2])
|
|
|
|
|
|
class TestOFPActionSetNwDst(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionSetNwDst
|
|
"""
|
|
|
|
# OFP_ACTION_NW_ADDR_PACK_STR
|
|
# '!HHI'...type, len, nw_addr
|
|
type_ = {'buf': b'\x00\x07', 'val': ofproto.OFPAT_SET_NW_DST}
|
|
len_ = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_NW_ADDR_SIZE}
|
|
nw_addr = {'buf': b'\xc0\xa8\x7a\x0a', 'val': 3232266762}
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ nw_addr['buf']
|
|
|
|
c = OFPActionSetNwDst(nw_addr['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.nw_addr['val'], self.c.nw_addr)
|
|
|
|
def test_parser_dst(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
eq_(self.nw_addr['val'], res.nw_addr)
|
|
|
|
def test_parser_src(self):
|
|
type_ = {'buf': b'\x00\x06', 'val': ofproto.OFPAT_SET_NW_SRC}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.nw_addr['buf']
|
|
|
|
res = self.c.parser(buf, 0)
|
|
eq_(self.nw_addr['val'], res.nw_addr)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_type(self):
|
|
type_ = {'buf': b'\x00\x05', 'val': 5}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.nw_addr['buf']
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_len(self):
|
|
len_ = {'buf': b'\x00\x10', 'val': 16}
|
|
|
|
buf = self.type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.nw_addr['buf']
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_ACTION_NW_ADDR_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.nw_addr['val'], res[2])
|
|
|
|
|
|
class TestOFPActionSetNwTos(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionSetNwTos
|
|
"""
|
|
|
|
# OFP_ACTION_NW_TOS_PACK_STR
|
|
# '!HHB3x'...type, len, tos, zfill
|
|
type_ = {'buf': b'\x00\x08', 'val': ofproto.OFPAT_SET_NW_TOS}
|
|
len_ = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_NW_TOS_SIZE}
|
|
tos = {'buf': b'\xb6', 'val': 182}
|
|
zfill = b'\x00' * 3
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ tos['buf'] \
|
|
+ zfill
|
|
|
|
c = OFPActionSetNwTos(tos['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.tos['val'], self.c.tos)
|
|
|
|
def test_parser(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
eq_(self.tos['val'], res.tos)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_type(self):
|
|
type_ = {'buf': b'\x00\x05', 'val': 5}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.tos['buf'] \
|
|
+ self.zfill
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_len(self):
|
|
len_ = {'buf': b'\x00\x07', 'val': 7}
|
|
|
|
buf = self.type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.tos['buf'] \
|
|
+ self.zfill
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_ACTION_NW_TOS_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.tos['val'], res[2])
|
|
|
|
|
|
class TestOFPActionSetTpSrc(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionSetTpSrc
|
|
"""
|
|
|
|
# OFP_ACTION_TP_PORT_PACK_STR
|
|
# '!HHH2x'...type, len, tp, zfill
|
|
type_ = {'buf': b'\x00\x09', 'val': ofproto.OFPAT_SET_TP_SRC}
|
|
len_ = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_TP_PORT_SIZE}
|
|
tp = {'buf': b'\x07\xf1', 'val': 2033}
|
|
zfill = b'\x00' * 2
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ tp['buf'] \
|
|
+ zfill
|
|
|
|
c = OFPActionSetTpSrc(tp['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.tp['val'], self.c.tp)
|
|
|
|
def test_parser_src(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
eq_(self.tp['val'], res.tp)
|
|
|
|
def test_parser_dst(self):
|
|
type_ = {'buf': b'\x00\x0a', 'val': ofproto.OFPAT_SET_TP_DST}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.tp['buf'] \
|
|
+ self.zfill
|
|
|
|
res = self.c.parser(self.buf, 0)
|
|
eq_(self.tp['val'], res.tp)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_type(self):
|
|
type_ = {'buf': b'\x00\x07', 'val': 7}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.tp['buf'] \
|
|
+ self.zfill
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_len(self):
|
|
len_ = {'buf': b'\x00\x07', 'val': 7}
|
|
|
|
buf = self.type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.tp['buf'] \
|
|
+ self.zfill
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_ACTION_TP_PORT_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.tp['val'], res[2])
|
|
|
|
|
|
class TestOFPActionSetTpDst(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionSetTpDst
|
|
"""
|
|
|
|
# OFP_ACTION_TP_PORT_PACK_STR
|
|
# '!HHH2x'...type, len, tp, zfill
|
|
type_ = {'buf': b'\x00\x0a', 'val': ofproto.OFPAT_SET_TP_DST}
|
|
len_ = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_TP_PORT_SIZE}
|
|
tp = {'buf': b'\x06\x6d', 'val': 1645}
|
|
zfill = b'\x00' * 2
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ tp['buf'] \
|
|
+ zfill
|
|
|
|
c = OFPActionSetTpDst(tp['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.tp['val'], self.c.tp)
|
|
|
|
def test_parser_dst(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
eq_(self.tp['val'], res.tp)
|
|
|
|
def test_parser_src(self):
|
|
type_ = {'buf': b'\x00\x09', 'val': ofproto.OFPAT_SET_TP_SRC}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.tp['buf'] \
|
|
+ self.zfill
|
|
|
|
res = self.c.parser(buf, 0)
|
|
eq_(self.tp['val'], res.tp)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_type(self):
|
|
type_ = {'buf': b'\x00\x10', 'val': 16}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.tp['buf'] \
|
|
+ self.zfill
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_len(self):
|
|
len_ = {'buf': b'\x00\x07', 'val': 7}
|
|
|
|
buf = self.type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.tp['buf'] \
|
|
+ self.zfill
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_ACTION_TP_PORT_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.tp['val'], res[2])
|
|
|
|
|
|
class TestOFPActionEnqueue(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPActionEnqueue
|
|
"""
|
|
|
|
# OFP_ACTION_ENQUEUE_PACK_STR
|
|
# '!HHH6xI'...type_, len_, port, zfill, queue_id
|
|
type_ = {'buf': b'\x00\x0b', 'val': ofproto.OFPAT_ENQUEUE}
|
|
len_ = {'buf': b'\x00\x10', 'val': ofproto.OFP_ACTION_ENQUEUE_SIZE}
|
|
port = {'buf': b'\x04\x55', 'val': 1109}
|
|
zfill = b'\x00' * 6
|
|
queue_id = {'buf': b'\x0a\x5b\x03\x5e', 'val': 173736798}
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ port['buf'] \
|
|
+ zfill \
|
|
+ queue_id['buf']
|
|
|
|
c = OFPActionEnqueue(port['val'], queue_id['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.port['val'], self.c.port)
|
|
eq_(self.queue_id['val'], self.c.queue_id)
|
|
|
|
def test_parser(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
|
|
eq_(self.port['val'], res.port)
|
|
eq_(self.queue_id['val'], res.queue_id)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_type(self):
|
|
type_ = {'buf': b'\x00\x0a', 'val': 10}
|
|
|
|
buf = type_['buf'] \
|
|
+ self.len_['buf'] \
|
|
+ self.port['buf'] \
|
|
+ self.zfill \
|
|
+ self.queue_id['buf']
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
@raises(AssertionError)
|
|
def test_parser_check_len(self):
|
|
len_ = {'buf': b'\x00\x05', 'val': 5}
|
|
|
|
buf = self.type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.port['buf'] \
|
|
+ self.zfill \
|
|
+ self.queue_id['buf']
|
|
|
|
self.c.parser(buf, 0)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.OFP_ACTION_ENQUEUE_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.port['val'], res[2])
|
|
eq_(self.queue_id['val'], res[3])
|
|
|
|
|
|
class TestNXActionResubmit(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionResubmit
|
|
"""
|
|
|
|
# NX_ACTION_RESUBMIT_PACK_STR
|
|
# '!HHIHHB3x'...type, len, vendor, subtype, in_port, table, zfill
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x10', 'val': ofproto.NX_ACTION_RESUBMIT_SIZE}
|
|
vendor = {'buf': b'\x00\x00\x23\x20', 'val': 8992}
|
|
subtype = {'buf': b'\x00\x01', 'val': 1}
|
|
in_port = {'buf': b'\x0a\x4c', 'val': 2636}
|
|
table = {'buf': b'\x52', 'val': 82}
|
|
zfill = b'\x00' * 3
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ in_port['buf'] \
|
|
+ table['buf'] \
|
|
+ zfill
|
|
|
|
c = NXActionResubmit(in_port['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
eq_(self.in_port['val'], self.c.in_port)
|
|
|
|
def test_parser(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.in_port['val'], res.in_port)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.NX_ACTION_RESUBMIT_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
eq_(self.in_port['val'], res[4])
|
|
|
|
|
|
class TestNXActionResubmitTable(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionResubmitTable
|
|
"""
|
|
|
|
# NX_ACTION_RESUBMIT_PACK_STR
|
|
# '!HHIHHB3x'...type, len, vendor, subtype, in_port, table, zfill
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x10', 'val': ofproto.NX_ACTION_RESUBMIT_SIZE}
|
|
vendor = {'buf': b'\x00\x00\x23\x20', 'val': 8992}
|
|
subtype = {'buf': b'\x00\x0e', 'val': 14}
|
|
in_port = {'buf': b'\x0a\x4c', 'val': 2636}
|
|
table_id = {'buf': b'\x52', 'val': 82}
|
|
zfill = b'\x00' * 3
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ in_port['buf'] \
|
|
+ table_id['buf'] \
|
|
+ zfill
|
|
|
|
c = NXActionResubmitTable(in_port['val'], table_id['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
eq_(self.in_port['val'], self.c.in_port)
|
|
eq_(self.table_id['val'], self.c.table_id)
|
|
|
|
def test_parser(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.in_port['val'], res.in_port)
|
|
eq_(self.table_id['val'], res.table_id)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.NX_ACTION_RESUBMIT_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
eq_(self.in_port['val'], res[4])
|
|
eq_(self.table_id['val'], res[5])
|
|
|
|
|
|
class TestNXActionSetTunnel(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionSetTunnel
|
|
"""
|
|
|
|
# NX_ACTION_SET_TUNNEL_PACK_STR
|
|
# '!HHIH2xI'...type, len, vendor, subtype, zfill, tun_id
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x10', 'val': ofproto.NX_ACTION_SET_TUNNEL_SIZE}
|
|
vendor = {'buf': b'\x00\x00\x23\x20', 'val': 8992}
|
|
subtype = {'buf': b'\x00\x02', 'val': 2}
|
|
zfill = b'\x00' * 2
|
|
tun_id = {'buf': b'\x01\x6f\x01\xd0', 'val': 24052176}
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ zfill \
|
|
+ tun_id['buf']
|
|
|
|
c = NXActionSetTunnel(tun_id['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
eq_(self.tun_id['val'], self.c.tun_id)
|
|
|
|
def test_parse(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.tun_id['val'], res.tun_id)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.NX_ACTION_SET_TUNNEL_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
eq_(self.tun_id['val'], res[4])
|
|
|
|
|
|
class TestNXActionSetQueue(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionSetQueue
|
|
"""
|
|
|
|
# NX_ACTION_SET_QUEUE_PACK_STR
|
|
# '!HHIH2xI'...type, len, vendor, subtype, zfill, queue_id
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x10', 'val': ofproto.NX_ACTION_SET_TUNNEL_SIZE}
|
|
vendor = {'buf': b'\x00\x00\x23\x20',
|
|
'val': ofproto_common.NX_EXPERIMENTER_ID}
|
|
subtype = {'buf': b'\x00\x04', 'val': ofproto.NXAST_SET_QUEUE}
|
|
zfill = b'\x00' * 2
|
|
queue_id = {'buf': b'\xde\xbe\xc5\x18', 'val': 3737044248}
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ zfill \
|
|
+ queue_id['buf']
|
|
|
|
c = NXActionSetQueue(queue_id['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
eq_(self.queue_id['val'], self.c.queue_id)
|
|
|
|
def test_parser(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.queue_id['val'], res.queue_id)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.NX_ACTION_SET_QUEUE_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
eq_(self.queue_id['val'], res[4])
|
|
|
|
|
|
class TestNXActionPopQueue(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionPopQueue
|
|
"""
|
|
|
|
# NX_ACTION_POP_QUEUE_PACK_STR
|
|
# '!HHIH6x'...type, len, vendor, subtype, zfill
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x10', 'val': ofproto.NX_ACTION_SET_TUNNEL_SIZE}
|
|
vendor = {'buf': b'\x00\x00\x23\x20',
|
|
'val': ofproto_common.NX_EXPERIMENTER_ID}
|
|
subtype = {'buf': b'\x00\x05', 'val': ofproto.NXAST_POP_QUEUE}
|
|
zfill = b'\x00' * 6
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ zfill
|
|
|
|
c = NXActionPopQueue()
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
|
|
def test_parser(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.subtype['val'], res.subtype)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.NX_ACTION_POP_QUEUE_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
|
|
|
|
class TestNXActionRegMove(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionRegMove
|
|
"""
|
|
|
|
# NX_ACTION_REG_MOVE_PACK_STR
|
|
# '!HHIHHHHII'...type_, len_, vendor, subtype, n_bits,
|
|
# src_ofs, dst_ofs, src, dst
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x18', 'val': ofproto.NX_ACTION_REG_MOVE_SIZE}
|
|
vendor = {'buf': b'\x00\x00\x23\x20',
|
|
'val': ofproto_common.NX_EXPERIMENTER_ID}
|
|
subtype = {'buf': b'\x00\x06', 'val': ofproto.NXAST_REG_MOVE}
|
|
n_bits = {'buf': b'\x3d\x98', 'val': 15768}
|
|
src_ofs = {'buf': b'\xf3\xa3', 'val': 62371}
|
|
dst_ofs = {'buf': b'\xdc\x67', 'val': 56423}
|
|
src_field = {'buf': b'\x00\x01\x00\x04', 'val': "reg0", "val2": 65540}
|
|
dst_field = {'buf': b'\x00\x01\x02\x04', 'val': "reg1", "val2": 66052}
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ n_bits['buf'] \
|
|
+ src_ofs['buf'] \
|
|
+ dst_ofs['buf'] \
|
|
+ src_field['buf'] \
|
|
+ dst_field['buf']
|
|
|
|
c = NXActionRegMove(src_field['val'],
|
|
dst_field['val'],
|
|
n_bits['val'],
|
|
src_ofs['val'],
|
|
dst_ofs['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
eq_(self.src_field['val'], self.c.src_field)
|
|
eq_(self.dst_field['val'], self.c.dst_field)
|
|
eq_(self.n_bits['val'], self.c.n_bits)
|
|
eq_(self.src_field['val'], self.c.src_field)
|
|
eq_(self.dst_field['val'], self.c.dst_field)
|
|
|
|
def test_parser(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.subtype['val'], res.subtype)
|
|
eq_(self.src_ofs['val'], res.src_ofs)
|
|
eq_(self.dst_ofs['val'], res.dst_ofs)
|
|
eq_(self.n_bits['val'], res.n_bits)
|
|
eq_(self.src_field['val'], res.src_field)
|
|
eq_(self.dst_field['val'], res.dst_field)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.NX_ACTION_REG_MOVE_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
eq_(self.n_bits['val'], res[4])
|
|
eq_(self.src_ofs['val'], res[5])
|
|
eq_(self.dst_ofs['val'], res[6])
|
|
eq_(self.src_field['val2'], res[7])
|
|
eq_(self.dst_field['val2'], res[8])
|
|
|
|
|
|
class TestNXActionRegLoad(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionRegLoad
|
|
"""
|
|
|
|
# NX_ACTION_REG_LOAD_PACK_STR
|
|
# '!HHIHHIQ'...type_, len_, vendor, subtype,
|
|
# ofs_nbits, dst, value
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x18', 'val': ofproto.NX_ACTION_REG_MOVE_SIZE}
|
|
vendor = {'buf': b'\x00\x00\x23\x20',
|
|
'val': ofproto_common.NX_EXPERIMENTER_ID}
|
|
subtype = {'buf': b'\x00\x07', 'val': ofproto.NXAST_REG_LOAD}
|
|
ofs_nbits = {'buf': b'\x3d\x98', 'val': 15768}
|
|
dst = {'buf': b'\x00\x01\x00\x04', 'val': "reg0", "val2": 65540}
|
|
value = {'buf': b'\x33\x51\xcd\x43\x25\x28\x18\x99',
|
|
'val': 3697962457317775513}
|
|
start = 246
|
|
end = 270
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ ofs_nbits['buf'] \
|
|
+ dst['buf'] \
|
|
+ value['buf']
|
|
|
|
c = NXActionRegLoad(ofs_nbits['val'],
|
|
dst['val'],
|
|
value['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
eq_(self.ofs_nbits['val'], self.c.ofs_nbits)
|
|
eq_(self.dst['val'], self.c.dst)
|
|
eq_(self.value['val'], self.c.value)
|
|
|
|
def test_parser(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.ofs_nbits['val'], self.c.ofs_nbits)
|
|
eq_(self.dst['val'], res.dst)
|
|
eq_(self.value['val'], res.value)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.NX_ACTION_REG_LOAD_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
eq_(self.ofs_nbits['val'], res[4])
|
|
eq_(self.dst['val2'], res[5])
|
|
eq_(self.value['val'], res[6])
|
|
|
|
|
|
class TestNXActionSetTunnel64(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionSetTunnel64
|
|
"""
|
|
|
|
# NX_ACTION_SET_TUNNEL64_PACK_STR
|
|
# '!HHIH6xQ'...type, len, vendor, subtype, zfill, tun_id
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x18', 'val': ofproto.NX_ACTION_SET_TUNNEL64_SIZE}
|
|
vendor = {'buf': b'\x00\x00\x23\x20',
|
|
'val': ofproto_common.NX_EXPERIMENTER_ID}
|
|
subtype = {'buf': b'\x00\x09', 'val': ofproto.NXAST_SET_TUNNEL64}
|
|
zfill = b'\x00' * 6
|
|
tun_id = {'buf': b'\x6e\x01\xa6\xea\x7e\x36\x1d\xd9',
|
|
'val': 7926800345218817497}
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ zfill \
|
|
+ tun_id['buf']
|
|
|
|
c = NXActionSetTunnel64(tun_id['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
eq_(self.tun_id['val'], self.c.tun_id)
|
|
|
|
def test_parser(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.subtype['val'], res.subtype)
|
|
eq_(self.tun_id['val'], res.tun_id)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.NX_ACTION_SET_TUNNEL64_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
eq_(self.tun_id['val'], res[4])
|
|
|
|
|
|
class TestNXActionMultipath(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionMultipath
|
|
"""
|
|
|
|
# NX_ACTION_MULTIPATH_PACK_STR
|
|
# '!HHIHHH2xHHI2xHI'...type, len, vendor, subtype, fields, basis, zfill
|
|
# algorithm, max_link, arg, zfill, ofs_nbits, dst
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x20', 'val': ofproto.NX_ACTION_MULTIPATH_SIZE}
|
|
vendor = {'buf': b'\x00\x00\x23\x20',
|
|
'val': ofproto_common.NX_EXPERIMENTER_ID}
|
|
subtype = {'buf': b'\x00\x0a', 'val': ofproto.NXAST_MULTIPATH}
|
|
fields = {'buf': b'\x6d\xf5', 'val': 28149}
|
|
basis = {'buf': b'\x7c\x0a', 'val': 31754}
|
|
zfill0 = b'\x00' * 2
|
|
algorithm = {'buf': b'\x82\x1d', 'val': 33309}
|
|
max_link = {'buf': b'\x06\x2b', 'val': 1579}
|
|
arg = {'buf': b'\x18\x79\x41\xc8', 'val': 410599880}
|
|
zfill1 = b'\x00' * 2
|
|
ofs_nbits = {'buf': b'\xa9\x9a', 'val': 43418}
|
|
dst = {'buf': b'\x00\x01\x00\x04', 'val': "reg0", 'val2': 65540}
|
|
start = 678
|
|
end = 704
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ fields['buf'] \
|
|
+ basis['buf'] \
|
|
+ zfill0 \
|
|
+ algorithm['buf'] \
|
|
+ max_link['buf'] \
|
|
+ arg['buf'] \
|
|
+ zfill1 \
|
|
+ ofs_nbits['buf'] \
|
|
+ dst['buf']
|
|
|
|
c = NXActionMultipath(fields['val'],
|
|
basis['val'],
|
|
algorithm['val'],
|
|
max_link['val'],
|
|
arg['val'],
|
|
ofs_nbits['val'],
|
|
dst['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
eq_(self.fields['val'], self.c.fields)
|
|
eq_(self.basis['val'], self.c.basis)
|
|
eq_(self.algorithm['val'], self.c.algorithm)
|
|
eq_(self.max_link['val'], self.c.max_link)
|
|
eq_(self.arg['val'], self.c.arg)
|
|
eq_(self.ofs_nbits['val'], self.c.ofs_nbits)
|
|
eq_(self.dst['val'], self.c.dst)
|
|
|
|
def test_parser(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.subtype['val'], res.subtype)
|
|
eq_(self.fields['val'], res.fields)
|
|
eq_(self.basis['val'], res.basis)
|
|
eq_(self.algorithm['val'], res.algorithm)
|
|
eq_(self.max_link['val'], res.max_link)
|
|
eq_(self.arg['val'], res.arg)
|
|
eq_(self.ofs_nbits['val'], res.ofs_nbits)
|
|
eq_(self.dst['val'], res.dst)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.NX_ACTION_MULTIPATH_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
eq_(self.fields['val'], res[4])
|
|
eq_(self.basis['val'], res[5])
|
|
eq_(self.algorithm['val'], res[6])
|
|
eq_(self.max_link['val'], res[7])
|
|
eq_(self.arg['val'], res[8])
|
|
eq_(self.ofs_nbits['val'], res[9])
|
|
eq_(self.dst['val2'], res[10])
|
|
|
|
|
|
class TestNXActionBundle(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionBundle
|
|
"""
|
|
|
|
# NX_ACTION_BUNDLE_PACK_STR
|
|
# '!HHIHHHHIHHI4x'...type, len, vendor, subtype, algorithm,
|
|
# fields, basis, slave_type, n_slaves,
|
|
# ofs_nbits, dst, zfill
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x28', 'val': (ofproto.NX_ACTION_BUNDLE_SIZE + 8)}
|
|
vendor = {'buf': b'\x00\x00\x23\x20',
|
|
'val': ofproto_common.NX_EXPERIMENTER_ID}
|
|
subtype = {'buf': b'\x00\x0c', 'val': ofproto.NXAST_BUNDLE}
|
|
algorithm = {'buf': b'\x51\xa7', 'val': 20903}
|
|
fields = {'buf': b'\xf8\xef', 'val': 63727}
|
|
basis = {'buf': b'\xfd\x6f', 'val': 64879}
|
|
slave_type = {'buf': b'\x7c\x51\x0f\xe0', 'val': 2085687264}
|
|
n_slaves = {'buf': b'\x00\x02', 'val': 2}
|
|
ofs_nbits = {'buf': b'\x00\x00', 'val': 0}
|
|
dst = {'buf': b'\x00\x00\x00\x00', 'val': 0}
|
|
zfill = b'\x00' * 4
|
|
|
|
slaves_buf = (b'\x00\x01', b'\x00\x02')
|
|
slaves_val = (1, 2)
|
|
|
|
_len = len_['val'] + len(slaves_val) * 2
|
|
_len += (_len % 8)
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ algorithm['buf'] \
|
|
+ fields['buf'] \
|
|
+ basis['buf'] \
|
|
+ slave_type['buf'] \
|
|
+ n_slaves['buf'] \
|
|
+ ofs_nbits['buf'] \
|
|
+ dst['buf'] \
|
|
+ zfill \
|
|
+ slaves_buf[0] \
|
|
+ slaves_buf[1]
|
|
|
|
c = NXActionBundle(algorithm['val'],
|
|
fields['val'],
|
|
basis['val'],
|
|
slave_type['val'],
|
|
n_slaves['val'],
|
|
ofs_nbits['val'],
|
|
dst['val'],
|
|
slaves_val)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
eq_(self.algorithm['val'], self.c.algorithm)
|
|
eq_(self.fields['val'], self.c.fields)
|
|
eq_(self.basis['val'], self.c.basis)
|
|
eq_(self.slave_type['val'], self.c.slave_type)
|
|
eq_(self.n_slaves['val'], self.c.n_slaves)
|
|
eq_(self.ofs_nbits['val'], self.c.ofs_nbits)
|
|
eq_(self.dst['val'], self.c.dst)
|
|
|
|
# slaves
|
|
slaves = self.c.slaves
|
|
eq_(self.slaves_val[0], slaves[0])
|
|
eq_(self.slaves_val[1], slaves[1])
|
|
|
|
def test_parser(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.subtype['val'], res.subtype)
|
|
eq_(self.algorithm['val'], res.algorithm)
|
|
eq_(self.fields['val'], res.fields)
|
|
eq_(self.basis['val'], res.basis)
|
|
eq_(self.slave_type['val'], res.slave_type)
|
|
eq_(self.n_slaves['val'], res.n_slaves)
|
|
eq_(self.ofs_nbits['val'], res.ofs_nbits)
|
|
eq_(self.dst['val'], res.dst)
|
|
|
|
# slaves
|
|
slaves = res.slaves
|
|
eq_(self.slaves_val[0], slaves[0])
|
|
eq_(self.slaves_val[1], slaves[1])
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.NX_ACTION_BUNDLE_PACK_STR.replace('!', '') \
|
|
+ 'HH4x'
|
|
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
eq_(self.algorithm['val'], res[4])
|
|
eq_(self.fields['val'], res[5])
|
|
eq_(self.basis['val'], res[6])
|
|
eq_(self.slave_type['val'], res[7])
|
|
eq_(self.n_slaves['val'], res[8])
|
|
eq_(self.ofs_nbits['val'], res[9])
|
|
eq_(self.dst['val'], res[10])
|
|
|
|
|
|
class TestNXActionBundleLoad(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionBundleLoad
|
|
"""
|
|
|
|
# NX_ACTION_BUNDLE_PACK_STR
|
|
# '!HHIHHHHIHHI4x'...type, len, vendor, subtype, algorithm,
|
|
# fields, basis, slave_type, n_slaves,
|
|
# ofs_nbits, dst, zfill
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x28', 'val': (ofproto.NX_ACTION_BUNDLE_SIZE + 8)}
|
|
vendor = {'buf': b'\x00\x00\x23\x20',
|
|
'val': ofproto_common.NX_EXPERIMENTER_ID}
|
|
subtype = {'buf': b'\x00\x0d', 'val': ofproto.NXAST_BUNDLE_LOAD}
|
|
algorithm = {'buf': b'\x83\x15', 'val': 33557}
|
|
fields = {'buf': b'\xc2\x7a', 'val': 49786}
|
|
basis = {'buf': b'\x86\x18', 'val': 34328}
|
|
slave_type = {'buf': b'\x18\x42\x0b\x55', 'val': 406981461}
|
|
n_slaves = {'buf': b'\x00\x02', 'val': 2}
|
|
ofs_nbits = {'buf': b'\xd2\x9d', 'val': 53917}
|
|
dst = {'buf': b'\x00\x01\x00\x04', 'val': "reg0", 'val2': 65540}
|
|
zfill = b'\x00' * 4
|
|
|
|
slaves_buf = (b'\x00\x01', b'\x00\x02')
|
|
slaves_val = (1, 2)
|
|
|
|
_len = len_['val'] + len(slaves_val) * 2
|
|
_len += (_len % 8)
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ algorithm['buf'] \
|
|
+ fields['buf'] \
|
|
+ basis['buf'] \
|
|
+ slave_type['buf'] \
|
|
+ n_slaves['buf'] \
|
|
+ ofs_nbits['buf'] \
|
|
+ dst['buf'] \
|
|
+ zfill \
|
|
+ slaves_buf[0] \
|
|
+ slaves_buf[1]
|
|
|
|
c = NXActionBundleLoad(algorithm['val'],
|
|
fields['val'],
|
|
basis['val'],
|
|
slave_type['val'],
|
|
n_slaves['val'],
|
|
ofs_nbits['val'],
|
|
dst['val'],
|
|
slaves_val)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
eq_(self.algorithm['val'], self.c.algorithm)
|
|
eq_(self.fields['val'], self.c.fields)
|
|
eq_(self.basis['val'], self.c.basis)
|
|
eq_(self.slave_type['val'], self.c.slave_type)
|
|
eq_(self.n_slaves['val'], self.c.n_slaves)
|
|
eq_(self.ofs_nbits['val'], self.c.ofs_nbits)
|
|
eq_(self.dst['val'], self.c.dst)
|
|
|
|
# slaves
|
|
slaves = self.c.slaves
|
|
eq_(self.slaves_val[0], slaves[0])
|
|
eq_(self.slaves_val[1], slaves[1])
|
|
|
|
def test_parser(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.subtype['val'], res.subtype)
|
|
eq_(self.algorithm['val'], res.algorithm)
|
|
eq_(self.fields['val'], res.fields)
|
|
eq_(self.basis['val'], res.basis)
|
|
eq_(self.slave_type['val'], res.slave_type)
|
|
eq_(self.n_slaves['val'], res.n_slaves)
|
|
eq_(self.ofs_nbits['val'], res.ofs_nbits)
|
|
eq_(self.dst['val'], res.dst)
|
|
|
|
# slaves
|
|
slaves = res.slaves
|
|
eq_(self.slaves_val[0], slaves[0])
|
|
eq_(self.slaves_val[1], slaves[1])
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.NX_ACTION_BUNDLE_PACK_STR.replace('!', '') \
|
|
+ 'HH4x'
|
|
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
eq_(self.algorithm['val'], res[4])
|
|
eq_(self.fields['val'], res[5])
|
|
eq_(self.basis['val'], res[6])
|
|
eq_(self.slave_type['val'], res[7])
|
|
eq_(self.n_slaves['val'], res[8])
|
|
eq_(self.ofs_nbits['val'], res[9])
|
|
eq_(self.dst['val2'], res[10])
|
|
|
|
|
|
class TestNXActionOutputReg(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionOutputReg
|
|
"""
|
|
|
|
# NX_ACTION_OUTPUT_REG_PACK_STR
|
|
# '!HHIHHIH6x'...type, len, vendor, subtype, ofs_nbits,
|
|
# src, max_len, zfill
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x18', 'val': ofproto.NX_ACTION_OUTPUT_REG_SIZE}
|
|
vendor = {'buf': b'\x00\x00\x23\x20',
|
|
'val': ofproto_common.NX_EXPERIMENTER_ID}
|
|
subtype = {'buf': b'\x00\x0f', 'val': ofproto.NXAST_OUTPUT_REG}
|
|
ofs_nbits = {'buf': b'\xfe\x78', 'val': 65144}
|
|
src = {'buf': b'\x00\x01\x00\x04', 'val': "reg0", 'val2': 65540}
|
|
max_len = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_OUTPUT_SIZE}
|
|
zfill = b'\x00' * 6
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ ofs_nbits['buf'] \
|
|
+ src['buf'] \
|
|
+ max_len['buf'] \
|
|
+ zfill
|
|
|
|
c = NXActionOutputReg(ofs_nbits['val'],
|
|
src['val'],
|
|
max_len['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
eq_(self.ofs_nbits['val'], self.c.ofs_nbits)
|
|
eq_(self.src['val'], self.c.src)
|
|
eq_(self.max_len['val'], self.c.max_len)
|
|
|
|
def test_parser(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.subtype['val'], res.subtype)
|
|
eq_(self.ofs_nbits['val'], self.c.ofs_nbits)
|
|
eq_(self.src['val'], res.src)
|
|
eq_(self.max_len['val'], res.max_len)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.NX_ACTION_OUTPUT_REG_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
eq_(self.ofs_nbits['val'], res[4])
|
|
eq_(self.src['val2'], res[5])
|
|
eq_(self.max_len['val'], res[6])
|
|
|
|
|
|
class TestNXActionExit(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXActionExit
|
|
"""
|
|
|
|
# NX_ACTION_HEADER_PACK_STR
|
|
# '!HHIH'...type, len, vendor, subtype
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
len_ = {'buf': b'\x00\x10', 'val': ofproto.NX_ACTION_HEADER_SIZE}
|
|
vendor = {'buf': b'\x00\x00\x23\x20',
|
|
'val': ofproto_common.NX_EXPERIMENTER_ID}
|
|
subtype = {'buf': b'\x00\x11', 'val': ofproto.NXAST_EXIT}
|
|
zfill = b'\x00' * 6
|
|
|
|
buf = type_['buf'] \
|
|
+ len_['buf'] \
|
|
+ vendor['buf'] \
|
|
+ subtype['buf'] \
|
|
+ zfill
|
|
|
|
c = NXActionExit()
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.subtype['val'], self.c.subtype)
|
|
|
|
def test_parser(self):
|
|
res = OFPActionVendor.parser(self.buf, 0)
|
|
eq_(self.type_['val'], res.type)
|
|
eq_(self.len_['val'], res.len)
|
|
eq_(self.subtype['val'], res.subtype)
|
|
|
|
def test_serialize(self):
|
|
buf = bytearray()
|
|
self.c.serialize(buf, 0)
|
|
|
|
fmt = ofproto.NX_ACTION_HEADER_PACK_STR
|
|
res = struct.unpack(fmt, six.binary_type(buf))
|
|
|
|
eq_(self.type_['val'], res[0])
|
|
eq_(self.len_['val'], res[1])
|
|
eq_(self.vendor['val'], res[2])
|
|
eq_(self.subtype['val'], res[3])
|
|
|
|
|
|
class TestOFPDescStats(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_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 setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
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, self.mfr_desc)
|
|
eq_(self.hw_desc, self.hw_desc)
|
|
eq_(self.sw_desc, self.sw_desc)
|
|
eq_(self.serial_num, self.serial_num)
|
|
eq_(self.dp_desc, self.dp_desc)
|
|
|
|
|
|
class TestOFPFlowStats(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPFlowStats
|
|
"""
|
|
|
|
# OFP_FLOW_STATS_0_PACK_STR
|
|
# '!HBx'...length, table_id, zfill
|
|
length = {'buf': b'\x00\x58', 'val': 88}
|
|
length_append_action = {'buf': b'\x00\x60', 'val': 96}
|
|
table_id = {'buf': b'\x51', 'val': 81}
|
|
zfill_0 = b'\x00'
|
|
|
|
# OFP_MATCH_PACK_STR
|
|
# '!IH6s6sHBxHBB2xIIHH'...
|
|
match = b'\x97\x7c\xa6\x1e' \
|
|
+ b'\x5e\xa0' \
|
|
+ b'\x7a\x3e\xed\x30\x4a\x90' \
|
|
+ b'\x96\x8e\x67\xbe\x2f\xe2' \
|
|
+ b'\xb1\x81' \
|
|
+ b'\xbe' \
|
|
+ b'\x00' \
|
|
+ b'\x01\xab' \
|
|
+ b'\x42' \
|
|
+ b'\xfe' \
|
|
+ b'\x00\x00' \
|
|
+ b'\xa4\x5d\x5c\x42' \
|
|
+ b'\xa2\x5c\x2e\x05' \
|
|
+ b'\x5a\x94' \
|
|
+ b'\x64\xd4'
|
|
|
|
# OFP_FLOW_STATS_1_PACK_STR
|
|
# '!IIHHH6xQQQ'...duration_sec, duration_nsec, priority,
|
|
# idle_timeout, hard_timeout, zfill,
|
|
# cookie, packet_count, byte_count
|
|
duration_sec = {'buf': b'\x94\x19\xb3\xd2', 'val': 2484712402}
|
|
duration_nsec = {'buf': b'\xee\x66\xcf\x7c', 'val': 3999715196}
|
|
priority = {'buf': b'\xe1\xc0', 'val': 57792}
|
|
idle_timeout = {'buf': b'\x8e\x10', 'val': 36368}
|
|
hard_timeout = {'buf': b'\xd4\x99', 'val': 54425}
|
|
zfill_1 = b'\x00\x00\x00\x00\x00\x00'
|
|
cookie = {'buf': b'\x0b\x01\xe8\xe5\xf0\x84\x8a\xe0',
|
|
'val': 793171083674290912}
|
|
packet_count = {'buf': b'\x47\x5c\xc6\x05\x28\xff\x7c\xdb',
|
|
'val': 5142202600015232219}
|
|
byte_count = {'buf': b'\x24\xe9\x4b\xee\xcb\x57\xd9\xc3',
|
|
'val': 2659740543924820419}
|
|
|
|
# <action>_PACK_STR...type_, len_ [others...]
|
|
type = {'buf': b'\x00\x00', 'val': ofproto.OFPAT_OUTPUT}
|
|
len = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_OUTPUT_SIZE}
|
|
port = {'buf': b'\x59\x2a', 'val': 22826}
|
|
max_len = {'buf': b'\x00\x08', 'val': ofproto.OFP_ACTION_OUTPUT_SIZE}
|
|
action = (type, len, port, max_len)
|
|
|
|
ACTION_TYPE = 0
|
|
ACTION_LEN = 1
|
|
ACTION_PORT = 2
|
|
ACTION_MAX_LEN = 3
|
|
|
|
c = OFPFlowStats()
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def _parser(self, action=None):
|
|
buf = self.table_id['buf'] \
|
|
+ self.zfill_0 \
|
|
+ self.match \
|
|
+ self.duration_sec['buf'] \
|
|
+ self.duration_nsec['buf'] \
|
|
+ self.priority['buf'] \
|
|
+ self.idle_timeout['buf'] \
|
|
+ self.hard_timeout['buf'] \
|
|
+ self.zfill_1 \
|
|
+ self.cookie['buf'] \
|
|
+ self.packet_count['buf'] \
|
|
+ self.byte_count['buf']
|
|
|
|
if not action:
|
|
buf = self.length['buf'] + buf
|
|
else:
|
|
buf = self.length_append_action['buf'] + buf
|
|
|
|
for a in self.action:
|
|
buf = buf + a['buf']
|
|
|
|
return self.c.parser(buf, 0)
|
|
|
|
def test_parser(self):
|
|
res = self._parser()
|
|
|
|
eq_(self.length['val'], res.length)
|
|
eq_(self.table_id['val'], res.table_id)
|
|
eq_(self.duration_sec['val'], res.duration_sec)
|
|
eq_(self.duration_nsec['val'], res.duration_nsec)
|
|
eq_(self.priority['val'], res.priority)
|
|
eq_(self.idle_timeout['val'], res.idle_timeout)
|
|
eq_(self.hard_timeout['val'], res.hard_timeout)
|
|
eq_(self.cookie['val'], res.cookie)
|
|
eq_(self.packet_count['val'], res.packet_count)
|
|
eq_(self.byte_count['val'], res.byte_count)
|
|
|
|
def test_parser_append_actions(self):
|
|
res = self._parser(True).actions[0]
|
|
|
|
eq_(self.action[self.ACTION_TYPE]['val'], res.type)
|
|
eq_(self.action[self.ACTION_LEN]['val'], res.len)
|
|
eq_(self.action[self.ACTION_PORT]['val'], res.port)
|
|
eq_(self.action[self.ACTION_MAX_LEN]['val'], res.max_len)
|
|
|
|
|
|
class TestOFPAggregateStats(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPAggregateStats
|
|
"""
|
|
|
|
# OFP_AGGREGATE_STATS_REPLY_PACK_STR
|
|
# '!QQI4x'...packet_count, byte_count, flow_count, zfill
|
|
packet_count = {'buf': b'\x43\x95\x1b\xfb\x0f\xf6\xa7\xdd',
|
|
'val': 4869829337189623773}
|
|
byte_count = {'buf': b'\x36\xda\x2d\x80\x2a\x95\x35\xdd',
|
|
'val': 3952521651464517085}
|
|
flow_count = {'buf': b'\xc3\x0d\xc3\xed', 'val': 3272459245}
|
|
zfill = b'\x00' * 4
|
|
|
|
buf = packet_count['buf'] \
|
|
+ byte_count['buf'] \
|
|
+ flow_count['buf'] \
|
|
+ zfill
|
|
|
|
c = OFPAggregateStats(packet_count['val'],
|
|
byte_count['val'],
|
|
flow_count['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.packet_count['val'], self.c.packet_count)
|
|
eq_(self.byte_count['val'], self.c.byte_count)
|
|
eq_(self.flow_count['val'], self.c.flow_count)
|
|
|
|
def test_parser(self):
|
|
|
|
res = self.c.parser(self.buf, 0)
|
|
|
|
eq_(self.packet_count['val'], res.packet_count)
|
|
eq_(self.byte_count['val'], res.byte_count)
|
|
eq_(self.flow_count['val'], res.flow_count)
|
|
|
|
|
|
class TestOFPTableStats(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPTableStats
|
|
"""
|
|
|
|
# OFP_TABLE_STATS_PACK_STR
|
|
# '!B3x32sIIIQQ'...table_id, zfill, name, wildcards, max_entries,
|
|
# active_count, lookup_count, matched_count
|
|
table_id = {'buf': b'\x5b', 'val': 91}
|
|
zfill = b'\x00' * 3
|
|
name = b'name'.ljust(32)
|
|
wildcards = {'buf': b'\xc5\xaf\x6e\x12', 'val': 3316608530}
|
|
max_entries = {'buf': b'\x95\x6c\x78\x4d', 'val': 2506913869}
|
|
active_count = {'buf': b'\x78\xac\xa8\x1e', 'val': 2024581150}
|
|
lookup_count = {'buf': b'\x40\x1d\x9c\x39\x19\xec\xd4\x1c',
|
|
'val': 4620020561814017052}
|
|
matched_count = {'buf': b'\x27\x35\x02\xb6\xc5\x5e\x17\x65',
|
|
'val': 2825167325263435621}
|
|
|
|
buf = table_id['buf'] \
|
|
+ zfill \
|
|
+ name \
|
|
+ wildcards['buf'] \
|
|
+ max_entries['buf'] \
|
|
+ active_count['buf'] \
|
|
+ lookup_count['buf'] \
|
|
+ matched_count['buf']
|
|
|
|
c = OFPTableStats(table_id['val'],
|
|
name,
|
|
wildcards['val'],
|
|
max_entries['val'],
|
|
active_count['val'],
|
|
lookup_count['val'],
|
|
matched_count['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.table_id['val'], self.c.table_id)
|
|
eq_(self.name, self.c.name)
|
|
eq_(self.wildcards['val'], self.c.wildcards)
|
|
eq_(self.max_entries['val'], self.c.max_entries)
|
|
eq_(self.active_count['val'], self.c.active_count)
|
|
eq_(self.lookup_count['val'], self.c.lookup_count)
|
|
eq_(self.matched_count['val'], self.c.matched_count)
|
|
|
|
def test_parser(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
|
|
eq_(self.table_id['val'], res.table_id)
|
|
eq_(self.name, res.name)
|
|
eq_(self.wildcards['val'], res.wildcards)
|
|
eq_(self.max_entries['val'], res.max_entries)
|
|
eq_(self.active_count['val'], res.active_count)
|
|
eq_(self.lookup_count['val'], res.lookup_count)
|
|
eq_(self.matched_count['val'], res.matched_count)
|
|
|
|
|
|
class TestOFPPortStats(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPPortStats
|
|
"""
|
|
|
|
# OFP_PORT_STATS_PACK_STR
|
|
# '!H6xQQQQQQQQQQQQ'... port_no, zfill, 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
|
|
port_no = {'buf': b'\xe7\x6b', 'val': 59243}
|
|
zfill = b'\x00' * 6
|
|
rx_packets = {'buf': b'\x53\x44\x36\x61\xc4\x86\xc0\x37',
|
|
'val': 5999980397101236279}
|
|
tx_packets = {'buf': b'\x27\xa4\x41\xd7\xd4\x53\x9e\x42',
|
|
'val': 2856480458895760962}
|
|
rx_bytes = {'buf': b'\x55\xa1\x38\x60\x43\x97\x0d\x89',
|
|
'val': 6170274950576278921}
|
|
tx_bytes = {'buf': b'\x77\xe1\xd5\x63\x18\xae\x63\xaa',
|
|
'val': 8638420181865882538}
|
|
rx_dropped = {'buf': b'\x60\xe6\x20\x01\x24\xda\x4e\x5a',
|
|
'val': 6982303461569875546}
|
|
tx_dropped = {'buf': b'\x09\x2d\x5d\x71\x71\xb6\x8e\xc7',
|
|
'val': 661287462113808071}
|
|
rx_errors = {'buf': b'\x2f\x7e\x35\xb3\x66\x3c\x19\x0d',
|
|
'val': 3422231811478788365}
|
|
tx_errors = {'buf': b'\x57\x32\x08\x2f\x88\x32\x40\x6b',
|
|
'val': 6283093430376743019}
|
|
rx_frame_err = {'buf': b'\x0c\x28\x6f\xad\xce\x66\x6e\x8b',
|
|
'val': 876072919806406283}
|
|
rx_over_err = {'buf': b'\x5a\x90\x8f\x9b\xfc\x82\x2e\xa0',
|
|
'val': 6525873760178941600}
|
|
rx_crc_err = {'buf': b'\x73\x3a\x71\x17\xd6\x74\x69\x47',
|
|
'val': 8303073210207070535}
|
|
collisions = {'buf': b'\x2f\x52\x0c\x79\x96\x03\x6e\x79',
|
|
'val': 3409801584220270201}
|
|
|
|
buf = port_no['buf'] \
|
|
+ zfill \
|
|
+ rx_packets['buf'] \
|
|
+ tx_packets['buf'] \
|
|
+ rx_bytes['buf'] \
|
|
+ tx_bytes['buf'] \
|
|
+ rx_dropped['buf'] \
|
|
+ tx_dropped['buf'] \
|
|
+ rx_errors['buf'] \
|
|
+ tx_errors['buf'] \
|
|
+ rx_frame_err['buf'] \
|
|
+ rx_over_err['buf'] \
|
|
+ rx_crc_err['buf'] \
|
|
+ collisions['buf']
|
|
|
|
c = OFPPortStats(port_no['val'],
|
|
rx_packets['val'],
|
|
tx_packets['val'],
|
|
rx_bytes['val'],
|
|
tx_bytes['val'],
|
|
rx_dropped['val'],
|
|
tx_dropped['val'],
|
|
rx_errors['val'],
|
|
tx_errors['val'],
|
|
rx_frame_err['val'],
|
|
rx_over_err['val'],
|
|
rx_crc_err['val'],
|
|
collisions['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.port_no['val'], self.c.port_no)
|
|
eq_(self.rx_packets['val'], self.c.rx_packets)
|
|
eq_(self.tx_packets['val'], self.c.tx_packets)
|
|
eq_(self.rx_bytes['val'], self.c.rx_bytes)
|
|
eq_(self.tx_bytes['val'], self.c.tx_bytes)
|
|
eq_(self.rx_dropped['val'], self.c.rx_dropped)
|
|
eq_(self.tx_dropped['val'], self.c.tx_dropped)
|
|
eq_(self.rx_errors['val'], self.c.rx_errors)
|
|
eq_(self.tx_errors['val'], self.c.tx_errors)
|
|
eq_(self.rx_frame_err['val'], self.c.rx_frame_err)
|
|
eq_(self.rx_over_err['val'], self.c.rx_over_err)
|
|
eq_(self.rx_crc_err['val'], self.c.rx_crc_err)
|
|
eq_(self.collisions['val'], self.c.collisions)
|
|
|
|
def test_parser(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
|
|
eq_(self.port_no['val'], res.port_no)
|
|
eq_(self.rx_packets['val'], res.rx_packets)
|
|
eq_(self.tx_packets['val'], res.tx_packets)
|
|
eq_(self.rx_bytes['val'], res.rx_bytes)
|
|
eq_(self.tx_bytes['val'], res.tx_bytes)
|
|
eq_(self.rx_dropped['val'], res.rx_dropped)
|
|
eq_(self.tx_dropped['val'], res.tx_dropped)
|
|
eq_(self.rx_errors['val'], res.rx_errors)
|
|
eq_(self.tx_errors['val'], res.tx_errors)
|
|
eq_(self.rx_frame_err['val'], res.rx_frame_err)
|
|
eq_(self.rx_over_err['val'], res.rx_over_err)
|
|
eq_(self.rx_crc_err['val'], res.rx_crc_err)
|
|
eq_(self.collisions['val'], res.collisions)
|
|
|
|
|
|
class TestOFPQueueStats(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPQueueStats
|
|
"""
|
|
|
|
# OFP_QUEUE_STATS_PACK_STR
|
|
# '!H2xIQQQ...port_no, queue_id, tx_bytes, tx_packets, tx_errors
|
|
port_no = {'buf': b'\xe7\x6b', 'val': 59243}
|
|
zfill = b'\x00' * 2
|
|
queue_id = {'buf': b'\x2a\xa8\x7f\x32', 'val': 715685682}
|
|
tx_bytes = {'buf': b'\x77\xe1\xd5\x63\x18\xae\x63\xaa',
|
|
'val': 8638420181865882538}
|
|
tx_packets = {'buf': b'\x27\xa4\x41\xd7\xd4\x53\x9e\x42',
|
|
'val': 2856480458895760962}
|
|
tx_errors = {'buf': b'\x57\x32\x08\x2f\x88\x32\x40\x6b',
|
|
'val': 6283093430376743019}
|
|
|
|
c = OFPQueueStats(port_no['val'],
|
|
queue_id['val'],
|
|
tx_bytes['val'],
|
|
tx_packets['val'],
|
|
tx_errors['val'])
|
|
|
|
buf = port_no['buf'] \
|
|
+ zfill \
|
|
+ queue_id['buf'] \
|
|
+ tx_bytes['buf'] \
|
|
+ tx_packets['buf'] \
|
|
+ tx_errors['buf']
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.port_no['val'], self.c.port_no)
|
|
eq_(self.queue_id['val'], self.c.queue_id)
|
|
eq_(self.tx_bytes['val'], self.c.tx_bytes)
|
|
eq_(self.tx_packets['val'], self.c.tx_packets)
|
|
eq_(self.tx_errors['val'], self.c.tx_errors)
|
|
|
|
def test_parser(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
|
|
eq_(self.port_no['val'], res.port_no)
|
|
eq_(self.queue_id['val'], res.queue_id)
|
|
eq_(self.tx_bytes['val'], res.tx_bytes)
|
|
eq_(self.tx_packets['val'], res.tx_packets)
|
|
eq_(self.tx_errors['val'], res.tx_errors)
|
|
|
|
|
|
class TestOFPVendorStats(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPVendorStats
|
|
"""
|
|
|
|
specific_data = 'specific_data'
|
|
specific_data_after = 'data'
|
|
offset = specific_data.find(specific_data_after)
|
|
|
|
c = OFPVendorStats(specific_data)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.specific_data, self.c.specific_data)
|
|
|
|
def test_parser(self):
|
|
res = self.c.parser(self.specific_data, self.offset)
|
|
eq_(self.specific_data_after, res.specific_data)
|
|
|
|
|
|
class TestOFPQueuePropNone(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPQueuePropNone
|
|
"""
|
|
|
|
# OFP_QUEUE_PROP_HEADER_PACK_STR
|
|
# '!HH4x'...property_, len_
|
|
property = {'buf': b'\x00\x00', 'val': ofproto.OFPQT_NONE}
|
|
len = {'buf': b'\x00\x08', 'val': ofproto.OFP_QUEUE_PROP_HEADER_SIZE}
|
|
zfill = b'\x00' * 4
|
|
|
|
c = OFPQueuePropNone()
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
cls = OFPQueuePropHeader._QUEUE_PROPERTIES[self.c.cls_prop_type]
|
|
|
|
eq_(self.property['val'], self.c.cls_prop_type)
|
|
eq_(self.property['val'], self.c.property)
|
|
eq_(self.property['val'], cls.cls_prop_type)
|
|
|
|
eq_(self.len['val'], self.c.cls_prop_len)
|
|
eq_(self.len['val'], self.c.len)
|
|
eq_(self.len['val'], cls.cls_prop_len)
|
|
|
|
def test_parser(self):
|
|
buf = self.property['buf'] \
|
|
+ self.len['buf'] \
|
|
+ self.zfill
|
|
|
|
ok_(self.c.parser(buf, 0))
|
|
|
|
|
|
class TestOFPQueuePropMinRate(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPQueuePropMinRate
|
|
"""
|
|
|
|
# OFP_QUEUE_PROP_MIN_RATE_PACK_STR
|
|
# '!H6x'...rate
|
|
rate = {'buf': b'\x00\x01', 'val': ofproto.OFPQT_MIN_RATE}
|
|
len = {'buf': b'\x00\x10', 'val': ofproto.OFP_QUEUE_PROP_MIN_RATE_SIZE}
|
|
zfill = b'\x00' * 6
|
|
|
|
buf = rate['buf'] \
|
|
+ zfill
|
|
|
|
c = OFPQueuePropMinRate(rate['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
cls = OFPQueuePropHeader._QUEUE_PROPERTIES[self.c.cls_prop_type]
|
|
|
|
eq_(self.rate['val'], self.c.cls_prop_type)
|
|
eq_(self.rate['val'], self.c.rate)
|
|
eq_(self.rate['val'], cls.cls_prop_type)
|
|
|
|
eq_(self.len['val'], self.c.cls_prop_len)
|
|
eq_(self.len['val'], cls.cls_prop_len)
|
|
|
|
def test_parser(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
eq_(self.rate['val'], res.rate)
|
|
|
|
|
|
class TestOFPPacketQueue(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPPacketQueue
|
|
"""
|
|
|
|
# OFP_PACKET_QUEUE_PQCK_STR
|
|
# '!IH2x'...queue_id, len_, zfill
|
|
queue_id = {'buf': b'\x4d\x4b\x3a\xd1', 'val': 1296775889}
|
|
len_ = {'buf': b'\x00\x08',
|
|
'val': ofproto.OFP_QUEUE_PROP_HEADER_SIZE}
|
|
zfill = b'\x00' * 2
|
|
|
|
buf = queue_id['buf'] \
|
|
+ len_['buf'] \
|
|
+ zfill
|
|
|
|
c = OFPPacketQueue(queue_id['val'],
|
|
len_['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.queue_id['val'], self.c.queue_id)
|
|
eq_(self.len_['val'], self.c.len)
|
|
|
|
def test_parser(self):
|
|
res = self.c.parser(self.buf, 0)
|
|
eq_(self.queue_id['val'], res.queue_id)
|
|
eq_(self.len_['val'], res.len)
|
|
|
|
def test_parser_append_prop(self):
|
|
# OFP_QUEUE_PROP_HEADER_PACK_STR + OFP_QUEUE_PROP_MIN_RATE_PACK_STR
|
|
# '!HH4xH6x'...type, len, zfill, rate, zfill
|
|
len_ = {'buf': b'\x00\x10',
|
|
'val': ofproto.OFP_QUEUE_PROP_MIN_RATE_SIZE}
|
|
a_type = {'buf': b'\x00\x01', 'val': ofproto.OFPQT_MIN_RATE}
|
|
a_len = {'buf': b'\x00\x10',
|
|
'val': ofproto.OFP_QUEUE_PROP_MIN_RATE_SIZE}
|
|
a_zfill0 = b'\x00' * 4
|
|
a_rate = {'buf': b'\x00\x01', 'val': ofproto.OFPQT_MIN_RATE}
|
|
a_zfill1 = b'\x00' * 6
|
|
|
|
buf = self.queue_id['buf'] \
|
|
+ len_['buf'] \
|
|
+ self.zfill \
|
|
+ a_type['buf'] \
|
|
+ a_len['buf'] \
|
|
+ a_zfill0 \
|
|
+ a_rate['buf'] \
|
|
+ a_zfill1
|
|
|
|
res = self.c.parser(buf, 0)
|
|
|
|
eq_(self.queue_id['val'], res.queue_id)
|
|
eq_(len_['val'], res.len)
|
|
|
|
append_cls = res.properties[0]
|
|
|
|
eq_(a_type['val'], append_cls.property)
|
|
eq_(a_len['val'], append_cls.len)
|
|
eq_(a_rate['val'], append_cls.rate)
|
|
|
|
|
|
class TestOFPHello(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPHello
|
|
"""
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = ofproto.OFP_VERSION
|
|
msg_type = ofproto.OFPT_HELLO
|
|
msg_len = ofproto.OFP_HEADER_SIZE
|
|
xid = 2183948390
|
|
data = b'\x00\x01\x02\x03'
|
|
|
|
fmt = ofproto.OFP_HEADER_PACK_STR
|
|
buf = struct.pack(fmt, version, msg_type, msg_len, xid) \
|
|
+ data
|
|
|
|
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_serialize(self):
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
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_0_parser.OFPErrorMsg
|
|
"""
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x01', 'val': ofproto.OFPT_ERROR}
|
|
msg_len = {'buf': b'\x00\x0c',
|
|
'val': ofproto.OFP_ERROR_MSG_SIZE}
|
|
xid = {'buf': b'\x87\x8b\x26\x7c', 'val': 2274043516}
|
|
type = {'buf': b'\xab\x3e', 'val': 43838}
|
|
code = {'buf': b'\x5d\x3c', 'val': 23868}
|
|
data = b'Error Message.'
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf'] \
|
|
+ type['buf'] \
|
|
+ code['buf'] \
|
|
+ data
|
|
|
|
res = OFPErrorMsg.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(type['val'], res.type)
|
|
eq_(code['val'], res.code)
|
|
eq_(data, res.data)
|
|
|
|
def test_serialize(self):
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
type = 1306
|
|
code = 13774
|
|
data = b'Error Message.'
|
|
|
|
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)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_ERROR_MSG_PACK_STR.replace('!', '') \
|
|
+ str(len(data)) + 's'
|
|
|
|
res = struct.unpack(fmt, six.binary_type(c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_ERROR, res[1])
|
|
eq_(len(c.buf), res[2])
|
|
eq_(0, res[3])
|
|
eq_(type, res[4])
|
|
eq_(code, res[5])
|
|
eq_(data, res[6])
|
|
|
|
|
|
class TestOFPEchoRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPEchoRequest
|
|
"""
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x02', 'val': ofproto.OFPT_ECHO_REQUEST}
|
|
msg_len = {'buf': b'\x00\x08',
|
|
'val': ofproto.OFP_HEADER_SIZE}
|
|
xid = {'buf': b'\x84\x47\xef\x3f', 'val': 2219306815}
|
|
data = b'Request Message.'
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf'] \
|
|
+ data
|
|
|
|
res = OFPEchoRequest.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(data, res.data)
|
|
|
|
def test_serialize(self):
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
data = b'Request Message.'
|
|
|
|
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.replace('!', '') \
|
|
+ str(len(data)) + 's'
|
|
|
|
res = struct.unpack(fmt, six.binary_type(c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_ECHO_REQUEST, res[1])
|
|
eq_(len(c.buf), res[2])
|
|
eq_(0, res[3])
|
|
eq_(data, res[4])
|
|
|
|
|
|
class TestOFPEchoReply(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPEchoReply
|
|
"""
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x03', 'val': ofproto.OFPT_ECHO_REPLY}
|
|
msg_len = {'buf': b'\x00\x08',
|
|
'val': ofproto.OFP_HEADER_SIZE}
|
|
xid = {'buf': b'\x6e\x21\x3e\x62', 'val': 1847672418}
|
|
data = b'Reply Message.'
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf'] \
|
|
+ data
|
|
|
|
res = OFPEchoReply.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(data, res.data)
|
|
|
|
def test_serialize(self):
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
data = b'Reply Message.'
|
|
|
|
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(data)) + 's'
|
|
|
|
res = struct.unpack(fmt, six.binary_type(c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_ECHO_REPLY, res[1])
|
|
eq_(len(c.buf), res[2])
|
|
eq_(0, res[3])
|
|
eq_(data, res[4])
|
|
|
|
|
|
class TestOFPVendor(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPVendor
|
|
"""
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x04', 'val': ofproto.OFPT_VENDOR}
|
|
msg_len = {'buf': b'\x00\x0c',
|
|
'val': ofproto.OFP_VENDOR_HEADER_SIZE}
|
|
xid = {'buf': b'\x05\x45\xdf\x18', 'val': 88465176}
|
|
vendor = {'buf': b'\x53\xea\x25\x3e', 'val': 1407853886}
|
|
data = b'Vendor Message.'
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf'] \
|
|
+ vendor['buf'] \
|
|
+ data
|
|
|
|
res = OFPVendor.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(vendor['val'], res.vendor)
|
|
eq_(data, res.data)
|
|
|
|
def test_serialize(self):
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
vendor = {'buf': b'\x38\x4b\xf9\x6c', 'val': 944503148}
|
|
data = b'Reply Message.'
|
|
|
|
c = OFPVendor(Datapath)
|
|
c.vendor = vendor['val']
|
|
c.data = data
|
|
|
|
c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, c.version)
|
|
eq_(ofproto.OFPT_VENDOR, c.msg_type)
|
|
eq_(0, c.xid)
|
|
eq_(vendor['val'], c.vendor)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_VENDOR_HEADER_PACK_STR.replace('!', '') \
|
|
+ str(len(data)) + 's'
|
|
|
|
res = struct.unpack(fmt, six.binary_type(c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_VENDOR, res[1])
|
|
eq_(len(c.buf), res[2])
|
|
eq_(0, res[3])
|
|
eq_(vendor['val'], res[4])
|
|
eq_(data, res[5])
|
|
|
|
|
|
# class TestNXTRequest(unittest.TestCase):
|
|
class TestNiciraHeader(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NiciraHeader
|
|
"""
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
subtype = ofproto.NXT_FLOW_MOD_TABLE_ID
|
|
|
|
c = NiciraHeader(object, subtype)
|
|
eq_(subtype, c.subtype)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
data = b'Reply Message.'
|
|
subtype = ofproto.NXT_FLOW_MOD_TABLE_ID
|
|
|
|
c = NiciraHeader(Datapath, subtype)
|
|
c.data = data
|
|
|
|
c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, c.version)
|
|
eq_(ofproto.OFPT_VENDOR, c.msg_type)
|
|
eq_(0, c.xid)
|
|
eq_(ofproto_common.NX_EXPERIMENTER_ID, c.vendor)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.NICIRA_HEADER_PACK_STR.replace('!', '') \
|
|
+ str(len(data)) + 's'
|
|
|
|
res = struct.unpack(fmt, six.binary_type(c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_VENDOR, res[1])
|
|
eq_(len(c.buf), res[2])
|
|
eq_(0, res[3])
|
|
eq_(ofproto_common.NX_EXPERIMENTER_ID, res[4])
|
|
eq_(subtype, res[5])
|
|
eq_(data, res[6])
|
|
|
|
|
|
class TestNXTSetFlowFormat(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXTSetFlowFormat
|
|
"""
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
flow_format = {'buf': b'\xdc\x6b\xf5\x24', 'val': 3698062628}
|
|
|
|
c = NXTSetFlowFormat(object, flow_format['val'])
|
|
eq_(flow_format['val'], c.format)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
flow_format = {'buf': b'\x5a\x4e\x59\xad', 'val': 1515084205}
|
|
|
|
c = NXTSetFlowFormat(Datapath, flow_format['val'])
|
|
c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, c.version)
|
|
eq_(ofproto.OFPT_VENDOR, c.msg_type)
|
|
eq_(0, c.xid)
|
|
eq_(ofproto_common.NX_EXPERIMENTER_ID, c.vendor)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.NICIRA_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.NX_SET_FLOW_FORMAT_PACK_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_VENDOR, res[1])
|
|
eq_(len(c.buf), res[2])
|
|
eq_(0, res[3])
|
|
eq_(ofproto_common.NX_EXPERIMENTER_ID, res[4])
|
|
eq_(ofproto.NXT_SET_FLOW_FORMAT, res[5])
|
|
eq_(flow_format['val'], res[6])
|
|
|
|
|
|
class TestNXTFlowMod(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXTFlowMod
|
|
"""
|
|
|
|
# NX_FLOW_MOD_PACK_STR
|
|
# '!Q4HI3H6x'...cokkie, command, idle_timeout, head_timeout,
|
|
# priority, buffer_id, out_port, flags, rule, zfill
|
|
cookie = {'buf': b'\x04\x56\x27\xad\xbd\x43\xd6\x83',
|
|
'val': 312480851306993283}
|
|
command = {'buf': b'\x61\xaa', 'val': 25002}
|
|
idle_timeout = {'buf': b'\x4e\xff', 'val': 20223}
|
|
hard_timeout = {'buf': b'\x80\x16', 'val': 32790}
|
|
priority = {'buf': b'\x70\x5f', 'val': 28767}
|
|
buffer_id = {'buf': b'\x7b\x97\x3a\x09', 'val': 2073508361}
|
|
out_port = {'buf': b'\x11\x7d', 'val': 4477}
|
|
flags = {'buf': b'\x5c\xb9', 'val': 23737}
|
|
rule = nx_match.ClsRule()
|
|
zfill = b'\x00' * 6
|
|
|
|
port = {'buf': b'\x2a\xe0', 'val': 10976}
|
|
actions = [OFPActionOutput(port['val'])]
|
|
|
|
def _get_obj(self, append_action=False):
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
actions = None
|
|
if append_action:
|
|
actions = self.actions
|
|
|
|
c = NXTFlowMod(Datapath,
|
|
self.cookie['val'],
|
|
self.command['val'],
|
|
self.idle_timeout['val'],
|
|
self.hard_timeout['val'],
|
|
self.priority['val'],
|
|
self.buffer_id['val'],
|
|
self.out_port['val'],
|
|
self.flags['val'],
|
|
self.rule,
|
|
actions)
|
|
|
|
return c
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
c = self._get_obj()
|
|
|
|
eq_(self.cookie['val'], c.cookie)
|
|
eq_(self.command['val'], c.command)
|
|
eq_(self.idle_timeout['val'], c.idle_timeout)
|
|
eq_(self.hard_timeout['val'], c.hard_timeout)
|
|
eq_(self.priority['val'], c.priority)
|
|
eq_(self.buffer_id['val'], c.buffer_id)
|
|
eq_(self.out_port['val'], c.out_port)
|
|
eq_(self.flags['val'], c.flags)
|
|
eq_(self.rule.__hash__(), c.rule.__hash__())
|
|
|
|
def test_init_append_actions(self):
|
|
c = self._get_obj(True)
|
|
|
|
action = c.actions[0]
|
|
eq_(ofproto.OFPAT_OUTPUT, action.type)
|
|
eq_(ofproto.OFP_ACTION_OUTPUT_SIZE, action.len)
|
|
eq_(self.port['val'], action.port)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
c = self._get_obj()
|
|
c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, c.version)
|
|
eq_(ofproto.OFPT_VENDOR, c.msg_type)
|
|
eq_(0, c.xid)
|
|
eq_(ofproto_common.NX_EXPERIMENTER_ID, c.vendor)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.NICIRA_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.NX_FLOW_MOD_PACK_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_VENDOR, res[1])
|
|
eq_(len(c.buf), res[2])
|
|
eq_(0, res[3])
|
|
eq_(ofproto_common.NX_EXPERIMENTER_ID, res[4])
|
|
eq_(ofproto.NXT_FLOW_MOD, res[5])
|
|
eq_(self.cookie['val'], res[6])
|
|
eq_(self.command['val'], res[7])
|
|
eq_(self.idle_timeout['val'], res[8])
|
|
eq_(self.hard_timeout['val'], res[9])
|
|
eq_(self.priority['val'], res[10])
|
|
eq_(self.buffer_id['val'], res[11])
|
|
eq_(self.out_port['val'], res[12])
|
|
eq_(self.flags['val'], res[13])
|
|
|
|
def test_serialize_append_actions(self):
|
|
c = self._get_obj(True)
|
|
c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, c.version)
|
|
eq_(ofproto.OFPT_VENDOR, c.msg_type)
|
|
eq_(0, c.xid)
|
|
eq_(ofproto_common.NX_EXPERIMENTER_ID, c.vendor)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.NICIRA_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.NX_FLOW_MOD_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_ACTION_OUTPUT_PACK_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_VENDOR, res[1])
|
|
eq_(len(c.buf), res[2])
|
|
eq_(0, res[3])
|
|
eq_(ofproto_common.NX_EXPERIMENTER_ID, res[4])
|
|
eq_(ofproto.NXT_FLOW_MOD, res[5])
|
|
eq_(self.cookie['val'], res[6])
|
|
eq_(self.command['val'], res[7])
|
|
eq_(self.idle_timeout['val'], res[8])
|
|
eq_(self.hard_timeout['val'], res[9])
|
|
eq_(self.priority['val'], res[10])
|
|
eq_(self.buffer_id['val'], res[11])
|
|
eq_(self.out_port['val'], res[12])
|
|
eq_(self.flags['val'], res[13])
|
|
|
|
# action
|
|
eq_(0, res[14])
|
|
eq_(ofproto.OFPAT_OUTPUT, res[15])
|
|
eq_(ofproto.OFP_ACTION_OUTPUT_SIZE, res[16])
|
|
eq_(self.port['val'], res[17])
|
|
eq_(0xffe5, res[18])
|
|
|
|
|
|
class TestNXTRoleRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXTRoleRequest
|
|
"""
|
|
|
|
# NX_ROLE_PACK_STR
|
|
# '!I'...role
|
|
role = {'buf': b'\x62\x81\x27\x61', 'val': 1652631393}
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = NXTRoleRequest(Datapath, role['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.role['val'], self.c.role)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_VENDOR, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
eq_(ofproto_common.NX_EXPERIMENTER_ID, self.c.vendor)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.NICIRA_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.NX_ROLE_PACK_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_VENDOR, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
eq_(ofproto_common.NX_EXPERIMENTER_ID, res[4])
|
|
eq_(ofproto.NXT_ROLE_REQUEST, res[5])
|
|
eq_(self.role['val'], res[6])
|
|
|
|
|
|
class TestNXTFlowModTableId(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.NXTFlowModTableId
|
|
"""
|
|
|
|
# NX_FLOW_MOD_TABLE_ID_PACK_STR
|
|
# '!B7x'...set_, zfill
|
|
set_ = {'buf': b'\x71', 'val': 113}
|
|
zfill = b'\x00' * 7
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = NXTFlowModTableId(Datapath, set_['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.set_['val'], self.c.set)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_VENDOR, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
eq_(ofproto_common.NX_EXPERIMENTER_ID, self.c.vendor)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.NICIRA_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.NX_FLOW_MOD_TABLE_ID_PACK_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_VENDOR, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
eq_(ofproto_common.NX_EXPERIMENTER_ID, res[4])
|
|
eq_(ofproto.NXT_FLOW_MOD_TABLE_ID, res[5])
|
|
eq_(self.set_['val'], res[6])
|
|
|
|
|
|
class TestOFPSwitchFeatures(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPSwitchFeatures
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPSwitchFeatures(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x06', 'val': ofproto.OFPT_FEATURES_REPLY}
|
|
msg_len_val = ofproto.OFP_SWITCH_FEATURES_SIZE \
|
|
+ ofproto.OFP_PHY_PORT_SIZE
|
|
msg_len = {'buf': b'\x00\x4c', 'val': msg_len_val}
|
|
xid = {'buf': b'\xcc\x0a\x41\xd4', 'val': 3423224276}
|
|
|
|
# OFP_SWITCH_FEATURES_PACK_STR
|
|
# '!QIB3xII'...datapath_id, n_buffers, n_tables,
|
|
# zfill, capabilities, actions
|
|
datapath_id = {'buf': b'\x11\xa3\x72\x63\x61\xde\x39\x81',
|
|
'val': 1270985291017894273}
|
|
n_buffers = {'buf': b'\x80\x14\xd7\xf6', 'val': 2148849654}
|
|
n_tables = {'buf': b'\xe4', 'val': 228}
|
|
zfill = b'\x00' * 3
|
|
capabilities = {'buf': b'\x69\x4f\xe4\xc2', 'val': 1766843586}
|
|
actions = {'buf': b'\x78\x06\xd9\x0c', 'val': 2013714700}
|
|
|
|
# OFP_PHY_PORT_PACK_STR
|
|
# '!H6s16sIIIIII'... port_no, hw_addr, name, config, state
|
|
# curr, advertised, supported, peer
|
|
port_no = {'buf': b'\xe7\x6b', 'val': 59243}
|
|
hw_addr = '3c:d1:2b:8d:3f:d6'
|
|
name = b'name'.ljust(16)
|
|
config = {'buf': b'\x84\xb6\x8c\x53', 'val': 2226555987}
|
|
state = {'buf': b'\x64\x07\xfb\xc9', 'val': 1678244809}
|
|
curr = {'buf': b'\xa9\xe8\x0a\x2b', 'val': 2850556459}
|
|
advertised = {'buf': b'\x78\xb9\x7b\x72', 'val': 2025421682}
|
|
supported = {'buf': b'\x7e\x65\x68\xad', 'val': 2120575149}
|
|
peer = {'buf': b'\xa4\x5b\x8b\xed', 'val': 2757463021}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf'] \
|
|
+ datapath_id['buf'] \
|
|
+ n_buffers['buf'] \
|
|
+ n_tables['buf'] \
|
|
+ zfill \
|
|
+ capabilities['buf'] \
|
|
+ actions['buf'] \
|
|
+ port_no['buf'] \
|
|
+ addrconv.mac.text_to_bin(hw_addr) \
|
|
+ name \
|
|
+ config['buf'] \
|
|
+ state['buf'] \
|
|
+ curr['buf'] \
|
|
+ advertised['buf'] \
|
|
+ supported['buf'] \
|
|
+ peer['buf']
|
|
|
|
res = OFPSwitchFeatures.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(datapath_id['val'], res.datapath_id)
|
|
eq_(n_buffers['val'], res.n_buffers)
|
|
eq_(n_tables['val'], res.n_tables)
|
|
eq_(capabilities['val'], res.capabilities)
|
|
eq_(actions['val'], res.actions)
|
|
|
|
# port
|
|
port = res.ports[port_no['val']]
|
|
eq_(port_no['val'], port.port_no)
|
|
eq_(hw_addr, hw_addr)
|
|
eq_(name, port.name)
|
|
eq_(config['val'], port.config)
|
|
eq_(state['val'], port.state)
|
|
eq_(curr['val'], port.curr)
|
|
eq_(advertised['val'], port.advertised)
|
|
eq_(supported['val'], port.supported)
|
|
eq_(peer['val'], port.peer)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPPortStatus(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPPortStatus
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPPortStatus(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x0c', 'val': ofproto.OFPT_PORT_STATUS}
|
|
msg_len = {'buf': b'\x00\x40',
|
|
'val': ofproto.OFP_PORT_STATUS_SIZE}
|
|
xid = {'buf': b'\x06\x27\x8b\x7b', 'val': 103254907}
|
|
|
|
# OFP_PORT_STATUS_PACK_STR
|
|
# '!B7xH6s16sIIIIII'...reason, zfill, port_no, hw_addr,
|
|
# name, config, state, curr,
|
|
# advertised, supported, peer
|
|
reason = {'buf': b'\x71', 'val': 113}
|
|
zfill = b'\x00' * 7
|
|
port_no = {'buf': b'\x48\xd8', 'val': 18648}
|
|
hw_addr = '41:f7:a3:52:8f:6b'
|
|
name = b'name'.ljust(16)
|
|
config = {'buf': b'\xae\x73\x90\xec', 'val': 2926809324}
|
|
state = {'buf': b'\x41\x37\x32\x1d', 'val': 1094136349}
|
|
curr = {'buf': b'\xa9\x47\x13\x2c', 'val': 2840007468}
|
|
advertised = {'buf': b'\xce\x6b\x4a\x87', 'val': 3463137927}
|
|
supported = {'buf': b'\xb8\x06\x65\xa1', 'val': 3087426977}
|
|
peer = {'buf': b'\x6a\x11\x52\x39', 'val': 1779520057}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf'] \
|
|
+ reason['buf'] \
|
|
+ zfill \
|
|
+ port_no['buf'] \
|
|
+ addrconv.mac.text_to_bin(hw_addr) \
|
|
+ name \
|
|
+ config['buf'] \
|
|
+ state['buf'] \
|
|
+ curr['buf'] \
|
|
+ advertised['buf'] \
|
|
+ supported['buf'] \
|
|
+ peer['buf']
|
|
|
|
res = OFPPortStatus.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(reason['val'], res.reason)
|
|
|
|
# desc
|
|
desc = res.desc
|
|
eq_(port_no['val'], desc.port_no)
|
|
eq_(hw_addr, desc.hw_addr)
|
|
eq_(name, desc.name)
|
|
eq_(config['val'], desc.config)
|
|
eq_(state['val'], desc.state)
|
|
eq_(curr['val'], desc.curr)
|
|
eq_(advertised['val'], desc.advertised)
|
|
eq_(supported['val'], desc.supported)
|
|
eq_(peer['val'], desc.peer)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPPacketIn(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPPacketIn
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPPacketIn(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def _test_parser(self, padding=False):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x0a', 'val': ofproto.OFPT_PACKET_IN}
|
|
msg_len = {'buf': b'\x00\x14',
|
|
'val': ofproto.OFP_PACKET_IN_SIZE}
|
|
xid = {'buf': b'\xd0\x23\x8c\x34', 'val': 3491990580}
|
|
|
|
# OFP_PACKET_IN_PACK_STR
|
|
# '!IHHBx2x'...buffer_id, total_len,
|
|
# in_port, reason, zfill, data
|
|
buffer_id = {'buf': b'\xae\x73\x90\xec', 'val': 2926809324}
|
|
total_len = {'buf': b'\x00\x10', 'val': 16}
|
|
in_port = {'buf': b'\x08\x42', 'val': 2114}
|
|
reason = {'buf': b'\x43', 'val': 67}
|
|
zfill = b'\x00' * 1
|
|
if padding:
|
|
data = b'PACKET IN'.ljust(20)
|
|
else:
|
|
data = b'PACKET IN'.ljust(16)
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf'] \
|
|
+ buffer_id['buf'] \
|
|
+ total_len['buf'] \
|
|
+ in_port['buf'] \
|
|
+ reason['buf'] \
|
|
+ zfill \
|
|
+ data
|
|
|
|
res = OFPPacketIn.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(buffer_id['val'], res.buffer_id)
|
|
eq_(total_len['val'], res.total_len)
|
|
eq_(in_port['val'], res.in_port)
|
|
eq_(reason['val'], res.reason)
|
|
eq_(data[0:16], res.data)
|
|
|
|
return True
|
|
|
|
def test_parser(self):
|
|
ok_(self._test_parser())
|
|
|
|
def test_parser_padding(self):
|
|
ok_(self._test_parser(True))
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPGetConfigReply(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPGetConfigReply
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPGetConfigReply(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x0a', 'val': ofproto.OFPT_GET_CONFIG_REPLY}
|
|
msg_len = {'buf': b'\x00\x14',
|
|
'val': ofproto.OFP_SWITCH_CONFIG_SIZE}
|
|
xid = {'buf': b'\x94\xc4\xd2\xcd', 'val': 2495926989}
|
|
|
|
# OFP_SWITCH_CONFIG_PACK_STR
|
|
# '!HH'...flags, miss_send_len
|
|
flags = {'buf': b'\xa0\xe2', 'val': 41186}
|
|
miss_send_len = {'buf': b'\x36\x0e', 'val': 13838}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf'] \
|
|
+ flags['buf'] \
|
|
+ miss_send_len['buf']
|
|
|
|
res = OFPGetConfigReply.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(flags['val'], res.flags)
|
|
eq_(miss_send_len['val'], res.miss_send_len)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPBarrierReply(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPBarrierReply
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPBarrierReply(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x13', 'val': ofproto.OFPT_BARRIER_REPLY}
|
|
msg_len = {'buf': b'\x00\x08',
|
|
'val': ofproto.OFP_HEADER_SIZE}
|
|
xid = {'buf': b'\x66\xc4\xc3\xac', 'val': 1724171180}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf']
|
|
|
|
res = OFPBarrierReply.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPFlowRemoved(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPFlowRemoved
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPFlowRemoved(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x0a', 'val': ofproto.OFPT_FLOW_REMOVED}
|
|
msg_len = {'buf': b'\x00\x14',
|
|
'val': ofproto.OFP_FLOW_REMOVED_SIZE}
|
|
xid = {'buf': b'\x94\xc4\xd2\xcd', 'val': 2495926989}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf']
|
|
|
|
# OFP_MATCH_PACK_STR
|
|
# '!IH6s6sHBxHBB2xIIHH'...wildcards, in_port, dl_src, dl_dst, dl_vlan,
|
|
# dl_vlan_pcp, dl_type, nw_tos, nw_proto,
|
|
# nw_src, nw_dst, tp_src, tp_dst
|
|
wildcards = {'buf': b'\xd2\x71\x25\x23', 'val': 3530630435}
|
|
in_port = {'buf': b'\x37\x8b', 'val': 14219}
|
|
dl_src = b'\x7f\x85\xc4\x70\x12\xda'
|
|
dl_dst = b'\x0a\x51\x17\x58\xb0\xbb'
|
|
dl_vlan = {'buf': b'\xc1\xf9', 'val': 49657}
|
|
dl_vlan_pcp = {'buf': b'\x79', 'val': 121}
|
|
zfill0 = b'\x00'
|
|
dl_type = {'buf': b'\xa6\x9e', 'val': 42654}
|
|
nw_tos = {'buf': b'\xde', 'val': 222}
|
|
nw_proto = {'buf': b'\xe5', 'val': 229}
|
|
zfil11 = b'\x00' * 2
|
|
nw_src = {'buf': b'\x1b\x6d\x8d\x4b', 'val': 460164427}
|
|
nw_dst = {'buf': b'\xab\x25\xe1\x20', 'val': 2871386400}
|
|
tp_src = {'buf': b'\xd5\xc3', 'val': 54723}
|
|
tp_dst = {'buf': b'\x78\xb9', 'val': 30905}
|
|
|
|
buf += wildcards['buf'] \
|
|
+ in_port['buf'] \
|
|
+ dl_src \
|
|
+ dl_dst \
|
|
+ dl_vlan['buf'] \
|
|
+ dl_vlan_pcp['buf'] \
|
|
+ zfill0 \
|
|
+ dl_type['buf'] \
|
|
+ nw_tos['buf'] \
|
|
+ nw_proto['buf'] \
|
|
+ zfil11 \
|
|
+ nw_src['buf'] \
|
|
+ nw_dst['buf'] \
|
|
+ tp_src['buf'] \
|
|
+ tp_dst['buf']
|
|
|
|
# OFP_FLOW_REMOVED_PACK_STR0
|
|
# '!QHBxIIH2xQQ'...cookie, priority, reason, zfill,
|
|
# duration_sec, duration_nsec, idle_timeout,
|
|
# zfill, packet_count, byte_count
|
|
cookie = {'buf': b'\x02\x79\xba\x00\xef\xab\xee\x44',
|
|
'val': 178378173441633860}
|
|
priority = {'buf': b'\x02\xce', 'val': 718}
|
|
reason = {'buf': b'\xa9', 'val': 169}
|
|
zfill0 = b'\x00' * 1
|
|
duration_sec = {'buf': b'\x86\x24\xa3\xba', 'val': 2250548154}
|
|
duration_nsec = {'buf': b'\x94\x94\xc2\x23', 'val': 2492776995}
|
|
idle_timeout = {'buf': b'\xeb\x7c', 'val': 60284}
|
|
zfill1 = b'\x00' * 2
|
|
packet_count = {'buf': b'\x5a\x0d\xf2\x03\x8e\x0a\xbb\x8d',
|
|
'val': 6489108735192644493}
|
|
byte_count = {'buf': b'\x65\xc8\xd3\x72\x51\xb5\xbb\x7c',
|
|
'val': 7334344481123449724}
|
|
|
|
buf += cookie['buf'] \
|
|
+ priority['buf'] \
|
|
+ reason['buf'] \
|
|
+ zfill0 \
|
|
+ duration_sec['buf'] \
|
|
+ duration_nsec['buf'] \
|
|
+ idle_timeout['buf'] \
|
|
+ zfill1 \
|
|
+ packet_count['buf'] \
|
|
+ byte_count['buf']
|
|
|
|
res = OFPFlowRemoved.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(cookie['val'], res.cookie)
|
|
eq_(priority['val'], res.priority)
|
|
eq_(reason['val'], res.reason)
|
|
eq_(duration_sec['val'], res.duration_sec)
|
|
eq_(duration_nsec['val'], res.duration_nsec)
|
|
eq_(idle_timeout['val'], res.idle_timeout)
|
|
eq_(packet_count['val'], res.packet_count)
|
|
eq_(byte_count['val'], res.byte_count)
|
|
|
|
# match
|
|
match = res.match
|
|
eq_(wildcards['val'], match.wildcards)
|
|
eq_(in_port['val'], match.in_port)
|
|
eq_(dl_src, match.dl_src)
|
|
eq_(dl_dst, match.dl_dst)
|
|
eq_(dl_vlan['val'], match.dl_vlan)
|
|
eq_(dl_vlan_pcp['val'], match.dl_vlan_pcp)
|
|
eq_(dl_type['val'], match.dl_type)
|
|
eq_(nw_tos['val'], match.nw_tos)
|
|
eq_(nw_proto['val'], match.nw_proto)
|
|
eq_(nw_src['val'], match.nw_src)
|
|
eq_(nw_dst['val'], match.nw_dst)
|
|
eq_(tp_src['val'], match.tp_src)
|
|
eq_(tp_dst['val'], match.tp_dst)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPQueueGetConfigReply(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPQueueGetConfigReply
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPQueueGetConfigReply(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x0a',
|
|
'val': ofproto.OFPT_QUEUE_GET_CONFIG_REPLY}
|
|
msg_len_val = ofproto.OFP_QUEUE_GET_CONFIG_REPLY_SIZE \
|
|
+ ofproto.OFP_PACKET_QUEUE_SIZE
|
|
msg_len = {'buf': b'\x00\x14', 'val': msg_len_val}
|
|
xid = {'buf': b'\x94\xc4\xd2\xcd', 'val': 2495926989}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf']
|
|
|
|
# OFP_QUEUE_GET_CONFIG_REPLY_PACK_STR
|
|
# '!H6x'...port, zfill
|
|
port = {'buf': b'\xfe\x66', 'val': 65126}
|
|
zfill = b'\x00' * 6
|
|
|
|
buf += port['buf'] \
|
|
+ zfill
|
|
|
|
# OFP_PACKET_QUEUE_PQCK_STR
|
|
# '!IH2x'...queue_id, len_, zfill
|
|
queue_id = {'buf': b'\x4d\x4b\x3a\xd1', 'val': 1296775889}
|
|
len_ = {'buf': b'\x00\x08',
|
|
'val': ofproto.OFP_QUEUE_PROP_HEADER_SIZE}
|
|
zfill = b'\x00' * 2
|
|
|
|
buf += queue_id['buf'] \
|
|
+ len_['buf'] \
|
|
+ zfill
|
|
|
|
res = OFPQueueGetConfigReply.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(port['val'], res.port)
|
|
|
|
# queue
|
|
queue = res.queues[0]
|
|
eq_(queue_id['val'], queue.queue_id)
|
|
eq_(len_['val'], queue.len)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPDescStatsReply(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPDescStatsReply
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPDescStatsReply(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x11', 'val': ofproto.OFPT_STATS_REPLY}
|
|
msg_len_val = ofproto.OFP_STATS_MSG_SIZE \
|
|
+ ofproto.OFP_DESC_STATS_SIZE
|
|
msg_len = {'buf': b'\x04\x38', 'val': msg_len_val}
|
|
xid = {'buf': b'\x94\xc4\xd2\xcd', 'val': 2495926989}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf']
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
# '!HH'...type_, flags
|
|
type_ = {'buf': b'\x00\x00', 'val': ofproto.OFPST_DESC}
|
|
flags = {'buf': b'\x30\xd9', 'val': 12505}
|
|
|
|
buf += type_['buf'] \
|
|
+ flags['buf']
|
|
|
|
# stats_type_cls = 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
|
|
|
|
res = OFPDescStatsReply.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(type_['val'], res.type)
|
|
eq_(flags['val'], res.flags)
|
|
|
|
# body
|
|
body = res.body
|
|
eq_(mfr_desc, body.mfr_desc)
|
|
eq_(hw_desc, body.hw_desc)
|
|
eq_(sw_desc, body.sw_desc)
|
|
eq_(serial_num, body.serial_num)
|
|
eq_(dp_desc, body.dp_desc)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPFlowStatsReply(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPFlowStatsReply
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPFlowStatsReply(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x11', 'val': ofproto.OFPT_STATS_REPLY}
|
|
msg_len_val = ofproto.OFP_STATS_MSG_SIZE \
|
|
+ ofproto.OFP_FLOW_STATS_SIZE
|
|
msg_len = {'buf': b'\x00\x64', 'val': msg_len_val}
|
|
xid = {'buf': b'\x94\xc4\xd2\xcd', 'val': 2495926989}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf']
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
# '!HH'...type_, flags
|
|
type_ = {'buf': b'\x00\x01', 'val': ofproto.OFPST_FLOW}
|
|
flags = {'buf': b'\x95\xf4', 'val': 38388}
|
|
|
|
buf += type_['buf'] \
|
|
+ flags['buf']
|
|
|
|
# stats_type_cls = OFPFlowStats
|
|
# OFP_FLOW_STATS_0_PACK_STR
|
|
# '!HBx'...length, table_id, zfill
|
|
length = {'buf': b'\x00\x60', 'val': 96}
|
|
table_id = {'buf': b'\x51', 'val': 81}
|
|
zfill = b'\x00'
|
|
|
|
buf += length['buf'] \
|
|
+ table_id['buf'] \
|
|
+ zfill
|
|
|
|
# OFP_MATCH_PACK_STR
|
|
# '!IH6s6sHBxHBB2xIIHH'...
|
|
match = b'\x97\x7c\xa6\x1e' \
|
|
+ b'\x5e\xa0' \
|
|
+ b'\x70\x17\xdc\x80\x59\x9e' \
|
|
+ b'\x79\xc6\x56\x87\x92\x28' \
|
|
+ b'\xb1\x81' \
|
|
+ b'\xbe' \
|
|
+ b'\x00' \
|
|
+ b'\x01\xab' \
|
|
+ b'\x42' \
|
|
+ b'\xfe' \
|
|
+ b'\x00\x00' \
|
|
+ b'\xa4\x5d\x5c\x42' \
|
|
+ b'\xa2\x5c\x2e\x05' \
|
|
+ b'\x5a\x94' \
|
|
+ b'\x64\xd4'
|
|
|
|
buf += match
|
|
|
|
# OFP_FLOW_STATS_1_PACK_STR
|
|
# '!IIHHH6xQQQ'...duration_sec, duration_nsec, priority,
|
|
# idle_timeout, hard_timeout, zfill,
|
|
# cookie, packet_count, byte_count
|
|
duration_sec = {'buf': b'\x94\x19\xb3\xd2', 'val': 2484712402}
|
|
duration_nsec = {'buf': b'\xee\x66\xcf\x7c', 'val': 3999715196}
|
|
priority = {'buf': b'\xe1\xc0', 'val': 57792}
|
|
idle_timeout = {'buf': b'\x8e\x10', 'val': 36368}
|
|
hard_timeout = {'buf': b'\xd4\x99', 'val': 54425}
|
|
zfill = b'\x00' * 6
|
|
cookie = {'buf': b'\x0b\x01\xe8\xe5\xf0\x84\x8a\xe0',
|
|
'val': 793171083674290912}
|
|
packet_count = {'buf': b'\x47\x5c\xc6\x05\x28\xff\x7c\xdb',
|
|
'val': 5142202600015232219}
|
|
byte_count = {'buf': b'\x24\xe9\x4b\xee\xcb\x57\xd9\xc3',
|
|
'val': 2659740543924820419}
|
|
|
|
buf += duration_sec['buf']
|
|
buf += duration_nsec['buf']
|
|
buf += priority['buf']
|
|
buf += idle_timeout['buf']
|
|
buf += hard_timeout['buf']
|
|
buf += zfill
|
|
buf += cookie['buf']
|
|
buf += packet_count['buf']
|
|
buf += byte_count['buf']
|
|
|
|
# <action>_PACK_STR...type_, len_ [others...]
|
|
type = {'buf': b'\x00\x00', 'val': ofproto.OFPAT_OUTPUT}
|
|
len = {'buf': b'\x00\x08',
|
|
'val': ofproto.OFP_ACTION_OUTPUT_SIZE}
|
|
port = {'buf': b'\x59\x2a', 'val': 22826}
|
|
max_len = {'buf': b'\x00\x08',
|
|
'val': ofproto.OFP_ACTION_OUTPUT_SIZE}
|
|
|
|
buf += type['buf'] \
|
|
+ len['buf'] \
|
|
+ port['buf'] \
|
|
+ max_len['buf']
|
|
|
|
res = OFPFlowStatsReply.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(type_['val'], res.type)
|
|
eq_(flags['val'], res.flags)
|
|
|
|
# body
|
|
body = res.body[0]
|
|
eq_(length['val'], body.length)
|
|
eq_(table_id['val'], body.table_id)
|
|
eq_(duration_sec['val'], body.duration_sec)
|
|
eq_(duration_nsec['val'], body.duration_nsec)
|
|
eq_(priority['val'], body.priority)
|
|
eq_(idle_timeout['val'], body.idle_timeout)
|
|
eq_(hard_timeout['val'], body.hard_timeout)
|
|
eq_(cookie['val'], body.cookie)
|
|
eq_(packet_count['val'], body.packet_count)
|
|
eq_(byte_count['val'], body.byte_count)
|
|
|
|
# action
|
|
action = body.actions[0]
|
|
eq_(type['val'], action.type)
|
|
eq_(len['val'], action.len)
|
|
eq_(port['val'], action.port)
|
|
eq_(max_len['val'], action.max_len)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPAggregateStatsReply(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPAggregateStatsReply
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPAggregateStatsReply(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x11', 'val': ofproto.OFPT_STATS_REPLY}
|
|
msg_len_val = ofproto.OFP_STATS_MSG_SIZE \
|
|
+ ofproto.OFP_AGGREGATE_STATS_REPLY_SIZE
|
|
msg_len = {'buf': b'\x00\x4c', 'val': msg_len_val}
|
|
xid = {'buf': b'\xc6\xd6\xce\x38', 'val': 3335966264}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf']
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
# '!HH'...type_, flags
|
|
type_ = {'buf': b'\x00\x02', 'val': ofproto.OFPST_AGGREGATE}
|
|
flags = {'buf': b'\x65\x66', 'val': 25958}
|
|
|
|
buf += type_['buf'] \
|
|
+ flags['buf']
|
|
|
|
# stats_type_cls = OFPAggregateStats
|
|
# OFP_AGGREGATE_STATS_REPLY_PACK_STR
|
|
# '!QQI4x'...packet_count, byte_count, flow_count, zfill
|
|
packet_count = {'buf': b'\x43\x95\x1b\xfb\x0f\xf6\xa7\xdd',
|
|
'val': 4869829337189623773}
|
|
byte_count = {'buf': b'\x36\xda\x2d\x80\x2a\x95\x35\xdd',
|
|
'val': 3952521651464517085}
|
|
flow_count = {'buf': b'\xc3\x0d\xc3\xed', 'val': 3272459245}
|
|
zfill = b'\x00' * 4
|
|
|
|
buf += packet_count['buf'] \
|
|
+ byte_count['buf'] \
|
|
+ flow_count['buf'] \
|
|
+ zfill
|
|
|
|
res = OFPAggregateStatsReply.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(type_['val'], res.type)
|
|
eq_(flags['val'], res.flags)
|
|
|
|
# body
|
|
body = res.body[0]
|
|
eq_(packet_count['val'], body.packet_count)
|
|
eq_(byte_count['val'], body.byte_count)
|
|
eq_(flow_count['val'], body.flow_count)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPTableStatsReply(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPTableStatsReply
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPTableStatsReply(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x11', 'val': ofproto.OFPT_STATS_REPLY}
|
|
msg_len_val = ofproto.OFP_STATS_MSG_SIZE \
|
|
+ ofproto.OFP_TABLE_STATS_SIZE
|
|
msg_len = {'buf': b'\x00\x4c', 'val': msg_len_val}
|
|
xid = {'buf': b'\xd6\xb4\x8d\xe6', 'val': 3602157030}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf']
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
# '!HH'...type_, flags
|
|
type_ = {'buf': b'\x00\x03', 'val': ofproto.OFPST_TABLE}
|
|
flags = {'buf': b'\xb3\xf0', 'val': 46064}
|
|
|
|
buf += type_['buf'] \
|
|
+ flags['buf']
|
|
|
|
# stats_type_cls = OFPTableStats
|
|
# OFP_TABLE_STATS_PACK_STR
|
|
# '!B3x32sIIIQQ'...table_id, zfill, name, wildcards, max_entries,
|
|
# active_count, lookup_count, matched_count
|
|
table_id = {'buf': b'\x5b', 'val': 91}
|
|
zfill = b'\x00' * 3
|
|
name = b'name'.ljust(32)
|
|
wildcards = {'buf': b'\xc5\xaf\x6e\x12', 'val': 3316608530}
|
|
max_entries = {'buf': b'\x95\x6c\x78\x4d', 'val': 2506913869}
|
|
active_count = {'buf': b'\x78\xac\xa8\x1e', 'val': 2024581150}
|
|
lookup_count = {'buf': b'\x40\x1d\x9c\x39\x19\xec\xd4\x1c',
|
|
'val': 4620020561814017052}
|
|
matched_count = {'buf': b'\x27\x35\x02\xb6\xc5\x5e\x17\x65',
|
|
'val': 2825167325263435621}
|
|
|
|
buf += table_id['buf'] \
|
|
+ zfill \
|
|
+ name \
|
|
+ wildcards['buf'] \
|
|
+ max_entries['buf'] \
|
|
+ active_count['buf'] \
|
|
+ lookup_count['buf'] \
|
|
+ matched_count['buf']
|
|
|
|
res = OFPTableStatsReply.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(type_['val'], res.type)
|
|
eq_(flags['val'], res.flags)
|
|
|
|
# body
|
|
body = res.body[0]
|
|
eq_(table_id['val'], body.table_id)
|
|
eq_(name, body.name)
|
|
eq_(wildcards['val'], body.wildcards)
|
|
eq_(max_entries['val'], body.max_entries)
|
|
eq_(active_count['val'], body.active_count)
|
|
eq_(lookup_count['val'], body.lookup_count)
|
|
eq_(matched_count['val'], body.matched_count)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPPortStatsReply(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPPortStatsReply
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPPortStatsReply(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x11', 'val': ofproto.OFPT_STATS_REPLY}
|
|
msg_len_val = ofproto.OFP_STATS_MSG_SIZE \
|
|
+ ofproto.OFP_PORT_STATS_SIZE
|
|
msg_len = {'buf': b'\x00\x74', 'val': msg_len_val}
|
|
xid = {'buf': b'\xc2\xaf\x3d\xff', 'val': 3266264575}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf']
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
# '!HH'...type_, flags
|
|
type_ = {'buf': b'\x00\x04', 'val': ofproto.OFPST_PORT}
|
|
flags = {'buf': b'\xda\xde', 'val': 56030}
|
|
|
|
buf += type_['buf'] \
|
|
+ flags['buf']
|
|
|
|
# stats_type_cls = OFPPortStats
|
|
# OFP_PORT_STATS_PACK_STR
|
|
# '!H6xQQQQQQQQQQQQ'... port_no, zfill, 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
|
|
port_no = {'buf': b'\xe7\x6b', 'val': 59243}
|
|
zfill = b'\x00' * 6
|
|
rx_packets = {'buf': b'\x53\x44\x36\x61\xc4\x86\xc0\x37',
|
|
'val': 5999980397101236279}
|
|
tx_packets = {'buf': b'\x27\xa4\x41\xd7\xd4\x53\x9e\x42',
|
|
'val': 2856480458895760962}
|
|
rx_bytes = {'buf': b'\x55\xa1\x38\x60\x43\x97\x0d\x89',
|
|
'val': 6170274950576278921}
|
|
tx_bytes = {'buf': b'\x77\xe1\xd5\x63\x18\xae\x63\xaa',
|
|
'val': 8638420181865882538}
|
|
rx_dropped = {'buf': b'\x60\xe6\x20\x01\x24\xda\x4e\x5a',
|
|
'val': 6982303461569875546}
|
|
tx_dropped = {'buf': b'\x09\x2d\x5d\x71\x71\xb6\x8e\xc7',
|
|
'val': 661287462113808071}
|
|
rx_errors = {'buf': b'\x2f\x7e\x35\xb3\x66\x3c\x19\x0d',
|
|
'val': 3422231811478788365}
|
|
tx_errors = {'buf': b'\x57\x32\x08\x2f\x88\x32\x40\x6b',
|
|
'val': 6283093430376743019}
|
|
rx_frame_err = {'buf': b'\x0c\x28\x6f\xad\xce\x66\x6e\x8b',
|
|
'val': 876072919806406283}
|
|
rx_over_err = {'buf': b'\x5a\x90\x8f\x9b\xfc\x82\x2e\xa0',
|
|
'val': 6525873760178941600}
|
|
rx_crc_err = {'buf': b'\x73\x3a\x71\x17\xd6\x74\x69\x47',
|
|
'val': 8303073210207070535}
|
|
collisions = {'buf': b'\x2f\x52\x0c\x79\x96\x03\x6e\x79',
|
|
'val': 3409801584220270201}
|
|
|
|
buf += port_no['buf'] \
|
|
+ zfill \
|
|
+ rx_packets['buf'] \
|
|
+ tx_packets['buf'] \
|
|
+ rx_bytes['buf'] \
|
|
+ tx_bytes['buf'] \
|
|
+ rx_dropped['buf'] \
|
|
+ tx_dropped['buf'] \
|
|
+ rx_errors['buf'] \
|
|
+ tx_errors['buf'] \
|
|
+ rx_frame_err['buf'] \
|
|
+ rx_over_err['buf'] \
|
|
+ rx_crc_err['buf'] \
|
|
+ collisions['buf']
|
|
|
|
res = OFPPortStatsReply.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(type_['val'], res.type)
|
|
eq_(flags['val'], res.flags)
|
|
|
|
# body
|
|
body = res.body[0]
|
|
eq_(port_no['val'], body.port_no)
|
|
eq_(rx_packets['val'], body.rx_packets)
|
|
eq_(tx_packets['val'], body.tx_packets)
|
|
eq_(rx_bytes['val'], body.rx_bytes)
|
|
eq_(tx_bytes['val'], body.tx_bytes)
|
|
eq_(rx_dropped['val'], body.rx_dropped)
|
|
eq_(tx_dropped['val'], body.tx_dropped)
|
|
eq_(rx_errors['val'], body.rx_errors)
|
|
eq_(tx_errors['val'], body.tx_errors)
|
|
eq_(rx_frame_err['val'], body.rx_frame_err)
|
|
eq_(rx_over_err['val'], body.rx_over_err)
|
|
eq_(rx_crc_err['val'], body.rx_crc_err)
|
|
eq_(collisions['val'], body.collisions)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPQueueStatsReply(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPQueueStatsReply
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPQueueStatsReply(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x11', 'val': ofproto.OFPT_STATS_REPLY}
|
|
msg_len_val = ofproto.OFP_STATS_MSG_SIZE \
|
|
+ ofproto.OFP_QUEUE_STATS_SIZE
|
|
msg_len = {'buf': b'\x00\x2c', 'val': msg_len_val}
|
|
xid = {'buf': b'\x19\xfc\x28\x6c', 'val': 435955820}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf']
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
# '!HH'...type_, flags
|
|
type_ = {'buf': b'\x00\x05', 'val': ofproto.OFPST_QUEUE}
|
|
flags = {'buf': b'\x3b\x2b', 'val': 15147}
|
|
|
|
buf += type_['buf'] \
|
|
+ flags['buf']
|
|
|
|
# stats_type_cls = OFPQueueStats
|
|
# OFP_QUEUE_STATS_PACK_STR
|
|
# '!H2xIQQQ...port_no, queue_id, tx_bytes, tx_packets, tx_errors
|
|
port_no = {'buf': b'\xe7\x6b', 'val': 59243}
|
|
zfill = b'\x00' * 2
|
|
queue_id = {'buf': b'\x2a\xa8\x7f\x32', 'val': 715685682}
|
|
tx_bytes = {'buf': b'\x77\xe1\xd5\x63\x18\xae\x63\xaa',
|
|
'val': 8638420181865882538}
|
|
tx_packets = {'buf': b'\x27\xa4\x41\xd7\xd4\x53\x9e\x42',
|
|
'val': 2856480458895760962}
|
|
tx_errors = {'buf': b'\x57\x32\x08\x2f\x88\x32\x40\x6b',
|
|
'val': 6283093430376743019}
|
|
|
|
buf += port_no['buf'] \
|
|
+ zfill \
|
|
+ queue_id['buf'] \
|
|
+ tx_bytes['buf'] \
|
|
+ tx_packets['buf'] \
|
|
+ tx_errors['buf']
|
|
|
|
res = OFPQueueStatsReply.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(type_['val'], res.type)
|
|
eq_(flags['val'], res.flags)
|
|
|
|
# body
|
|
body = res.body[0]
|
|
eq_(port_no['val'], body.port_no)
|
|
eq_(queue_id['val'], body.queue_id)
|
|
eq_(tx_bytes['val'], body.tx_bytes)
|
|
eq_(tx_packets['val'], body.tx_packets)
|
|
eq_(tx_errors['val'], body.tx_errors)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPVendorStatsReply(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPVendorStatsReply
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPVendorStatsReply(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
version = {'buf': b'\x01', 'val': ofproto.OFP_VERSION}
|
|
msg_type = {'buf': b'\x11', 'val': ofproto.OFPT_STATS_REPLY}
|
|
# ofproto.OFP_STATS_MSG_SIZE + len(specific_data)
|
|
msg_len = {'buf': b'\x00\x18',
|
|
'val': ofproto.OFP_STATS_MSG_SIZE + 12}
|
|
xid = {'buf': b'\x94\xc4\xd2\xcd', 'val': 2495926989}
|
|
|
|
buf = version['buf'] \
|
|
+ msg_type['buf'] \
|
|
+ msg_len['buf'] \
|
|
+ xid['buf']
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
# '!HH'...type_, flags
|
|
type_ = {'buf': b'\xff\xff', 'val': ofproto.OFPST_VENDOR}
|
|
flags = {'buf': b'\x30\xd9', 'val': 12505}
|
|
|
|
buf += type_['buf'] \
|
|
+ flags['buf']
|
|
|
|
# stats_type_cls = OFPVendorStats
|
|
specific_data = b'specific_data'
|
|
|
|
buf += specific_data
|
|
|
|
res = OFPVendorStatsReply.parser(object,
|
|
version['val'],
|
|
msg_type['val'],
|
|
msg_len['val'],
|
|
xid['val'],
|
|
buf)
|
|
|
|
eq_(version['val'], res.version)
|
|
eq_(msg_type['val'], res.msg_type)
|
|
eq_(msg_len['val'], res.msg_len)
|
|
eq_(xid['val'], res.xid)
|
|
eq_(type_['val'], res.type)
|
|
eq_(flags['val'], res.flags)
|
|
|
|
# body
|
|
body = res.body[0]
|
|
eq_(specific_data, body)
|
|
|
|
def test_serialize(self):
|
|
# Not used.
|
|
pass
|
|
|
|
|
|
class TestOFPFeaturesRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPFeaturesRequest
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPFeaturesRequest(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_FEATURES_REQUEST, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
|
|
fmt = ofproto.OFP_HEADER_PACK_STR
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_FEATURES_REQUEST, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
|
|
|
|
class TestOFPGetConfigRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPGetConfigRequest
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPGetConfigRequest(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_GET_CONFIG_REQUEST, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
|
|
fmt = ofproto.OFP_HEADER_PACK_STR
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_GET_CONFIG_REQUEST, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
|
|
|
|
class TestOFPSetConfig(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPSetConfig
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
# OFP_SWITCH_CONFIG_PACK_STR
|
|
# '!HH'...flags, miss_send_len
|
|
flags = {'buf': b'\xa0\xe2', 'val': 41186}
|
|
miss_send_len = {'buf': b'\x36\x0e', 'val': 13838}
|
|
|
|
c = OFPSetConfig(Datapath,
|
|
flags['val'],
|
|
miss_send_len['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.flags['val'], self.c.flags)
|
|
eq_(self.miss_send_len['val'], self.c.miss_send_len)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_SET_CONFIG, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_SWITCH_CONFIG_PACK_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_SET_CONFIG, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
eq_(self.flags['val'], res[4])
|
|
eq_(self.miss_send_len['val'], res[5])
|
|
|
|
|
|
class TestOFPPacketOut(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPPacketOut
|
|
"""
|
|
|
|
port = 0x2ae0
|
|
actions = [OFPActionOutput(port, max_len=0)]
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def _get_obj(self, buffer_id, in_port, data=None):
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPPacketOut(Datapath,
|
|
buffer_id,
|
|
in_port,
|
|
self.actions,
|
|
data)
|
|
return c
|
|
|
|
def test_init(self):
|
|
buffer_id = 0xffffffff
|
|
in_port = 0x40455
|
|
data = 'Message'
|
|
|
|
c = self._get_obj(buffer_id, in_port, data)
|
|
|
|
eq_(buffer_id, c.buffer_id)
|
|
eq_(in_port, c.in_port)
|
|
eq_(data, c.data)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
buffer_id = 0xffffffff
|
|
in_port = 0x9e07
|
|
data = b'Message'
|
|
|
|
c = self._get_obj(buffer_id, in_port, 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.replace('!', '') \
|
|
+ ofproto.OFP_PACKET_OUT_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_ACTION_OUTPUT_PACK_STR.replace('!', '') \
|
|
+ str(len(data)) + 's'
|
|
|
|
res = struct.unpack(fmt, six.binary_type(c.buf))
|
|
|
|
# OFP_HEADER_PACK_STR
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_PACKET_OUT, res[1])
|
|
eq_(len(c.buf), res[2])
|
|
eq_(0, res[3])
|
|
|
|
# OFP_PACKET_OUT_PACK_STR
|
|
eq_(buffer_id, res[4])
|
|
eq_(in_port, res[5])
|
|
eq_(ofproto.OFP_ACTION_OUTPUT_SIZE, res[6])
|
|
|
|
# OFP_ACTION_OUTPUT_PACK_STR
|
|
eq_(ofproto.OFPAT_OUTPUT, res[7])
|
|
eq_(ofproto.OFP_ACTION_OUTPUT_SIZE, res[8])
|
|
eq_(self.port, res[9])
|
|
eq_(0, res[10])
|
|
|
|
# data
|
|
eq_(data, res[11])
|
|
|
|
@raises(AssertionError)
|
|
def test_serialize_check_buffer_id(self):
|
|
buffer_id = 0xffffff00
|
|
in_port = 0xaa92
|
|
data = 'Message'
|
|
|
|
c = self._get_obj(buffer_id, in_port, data)
|
|
c.serialize()
|
|
|
|
|
|
class TestOFPFlowMod(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPFlowMod
|
|
"""
|
|
|
|
# OFP_FLOW_MOD_PACK_STR0
|
|
# '!QHHHHIHH'...cookie, command, idle_timeout, hard_timeout,
|
|
# priority, buffer_id, out_port, flags
|
|
cookie = {'buf': b'\x1d\x86\xce\x6e\x8d\xc0\xbe\xa8',
|
|
'val': 2127614848199081640}
|
|
command = {'buf': b'\xe1\x55', 'val': 57685}
|
|
idle_timeout = {'buf': b'\xf3\x6d', 'val': 62317}
|
|
hard_timeout = {'buf': b'\x1c\xc5', 'val': 7365}
|
|
priority = {'buf': b'\x9c\xe3', 'val': 40163}
|
|
buffer_id = {'buf': b'\xf0\xa1\x80\x33', 'val': 4037115955}
|
|
out_port = {'buf': b'\xfe\x0d', 'val': 65037}
|
|
flags = {'buf': b'\x00\x87', 'val': 135}
|
|
|
|
# OFP_MATCH_PACK_STR
|
|
# '!IH6s6sHBxHBB2xIIHH'...wildcards, in_port, dl_src, dl_dst, dl_vlan,
|
|
# dl_vlan_pcp, dl_type, nw_tos, nw_proto,
|
|
# nw_src, nw_dst, tp_src, tp_dst
|
|
wildcards = {'buf': b'\xd2\x71\x25\x23', 'val': 3530630435}
|
|
in_port = {'buf': b'\x37\x8b', 'val': 14219}
|
|
dl_src = b'\xdf\xcf\xe1\x5d\xcf\xc0'
|
|
dl_dst = b'\x76\xb3\xfb\xc6\x21\x2f'
|
|
dl_vlan = {'buf': b'\xc1\xf9', 'val': 49657}
|
|
dl_vlan_pcp = {'buf': b'\x79', 'val': 121}
|
|
zfill0 = b'\x00'
|
|
dl_type = {'buf': b'\xa6\x9e', 'val': 42654}
|
|
nw_tos = {'buf': b'\xde', 'val': 222}
|
|
nw_proto = {'buf': b'\xe5', 'val': 229}
|
|
zfil11 = b'\x00' * 2
|
|
nw_src = {'buf': b'\x1b\x6d\x8d\x4b', 'val': 460164427}
|
|
nw_dst = {'buf': b'\xab\x25\xe1\x20', 'val': 2871386400}
|
|
tp_src = {'buf': b'\xd5\xc3', 'val': 54723}
|
|
tp_dst = {'buf': b'\x78\xb9', 'val': 30905}
|
|
|
|
match = OFPMatch(wildcards['val'],
|
|
in_port['val'],
|
|
dl_src,
|
|
dl_dst,
|
|
dl_vlan['val'],
|
|
dl_vlan_pcp['val'],
|
|
dl_type['val'],
|
|
nw_tos['val'],
|
|
nw_proto['val'],
|
|
nw_src['val'],
|
|
nw_dst['val'],
|
|
tp_src['val'],
|
|
tp_dst['val'])
|
|
|
|
port = 0x2ae0
|
|
actions = [OFPActionOutput(port, max_len=1000)]
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def _get_obj(self, actions=None):
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPFlowMod(Datapath,
|
|
self.match,
|
|
self.cookie['val'],
|
|
self.command['val'],
|
|
self.idle_timeout['val'],
|
|
self.hard_timeout['val'],
|
|
self.priority['val'],
|
|
self.buffer_id['val'],
|
|
self.out_port['val'],
|
|
self.flags['val'],
|
|
actions)
|
|
|
|
return c
|
|
|
|
def test_init(self):
|
|
c = self._get_obj()
|
|
|
|
eq_(self.cookie['val'], c.cookie)
|
|
eq_(self.command['val'], c.command)
|
|
eq_(self.idle_timeout['val'], c.idle_timeout)
|
|
eq_(self.hard_timeout['val'], c.hard_timeout)
|
|
eq_(self.priority['val'], c.priority)
|
|
eq_(self.buffer_id['val'], c.buffer_id)
|
|
eq_(self.out_port['val'], c.out_port)
|
|
eq_(self.flags['val'], c.flags)
|
|
|
|
def test_init_actions(self):
|
|
c = self._get_obj(self.actions)
|
|
action = c.actions[0]
|
|
|
|
eq_(self.port, action.port)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
c = self._get_obj(self.actions)
|
|
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.replace('!', '') \
|
|
+ ofproto.OFP_MATCH_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_FLOW_MOD_PACK_STR0.replace('!', '') \
|
|
+ ofproto.OFP_ACTION_OUTPUT_PACK_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(c.buf))
|
|
|
|
# OFP_HEADER_PACK_STR
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_FLOW_MOD, res[1])
|
|
eq_(len(c.buf), res[2])
|
|
eq_(0, res[3])
|
|
|
|
# OFP_MATCH_PACK_STR
|
|
eq_(self.wildcards['val'], res[4])
|
|
eq_(self.in_port['val'], res[5])
|
|
eq_(self.dl_src, res[6])
|
|
eq_(self.dl_dst, res[7])
|
|
eq_(self.dl_vlan['val'], res[8])
|
|
eq_(self.dl_vlan_pcp['val'], res[9])
|
|
eq_(self.dl_type['val'], res[10])
|
|
eq_(self.nw_tos['val'], res[11])
|
|
eq_(self.nw_proto['val'], res[12])
|
|
eq_(self.nw_src['val'], res[13])
|
|
eq_(self.nw_dst['val'], res[14])
|
|
eq_(self.tp_src['val'], res[15])
|
|
eq_(self.tp_dst['val'], res[16])
|
|
|
|
# OFP_FLOW_MOD_PACK_STR0
|
|
eq_(self.cookie['val'], res[17])
|
|
eq_(self.command['val'], res[18])
|
|
eq_(self.idle_timeout['val'], res[19])
|
|
eq_(self.hard_timeout['val'], res[20])
|
|
eq_(self.priority['val'], res[21])
|
|
eq_(self.buffer_id['val'], res[22])
|
|
eq_(self.out_port['val'], res[23])
|
|
eq_(self.flags['val'], res[24])
|
|
|
|
# OFP_ACTION_OUTPUT_PACK_STR
|
|
eq_(ofproto.OFPAT_OUTPUT, res[25])
|
|
eq_(ofproto.OFP_ACTION_OUTPUT_SIZE, res[26])
|
|
eq_(self.port, res[27])
|
|
eq_(1000, res[28])
|
|
|
|
|
|
class TestOFPBarrierRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPBarrierRequest
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
c = OFPBarrierRequest(Datapath)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
pass
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_BARRIER_REQUEST, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
|
|
fmt = ofproto.OFP_HEADER_PACK_STR
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_BARRIER_REQUEST, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
|
|
|
|
class TestOFPQueueGetConfigRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPQueueGetConfigRequest
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
# OFP_QUEUE_GET_CONFIG_REQUEST_PACK_STR
|
|
# '!H2x'...port, zfill
|
|
port = {'buf': b'\xa0\xe2', 'val': 41186}
|
|
zfill = b'\x00' * 2
|
|
|
|
c = OFPQueueGetConfigRequest(Datapath,
|
|
port['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(self.port['val'], self.c.port)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_QUEUE_GET_CONFIG_REQUEST, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
|
|
a = ofproto.OFP_HEADER_PACK_STR.replace('!', '')
|
|
b = ofproto.OFP_QUEUE_GET_CONFIG_REQUEST_PACK_STR.replace('!', '')
|
|
fmt = '!' + a + b
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_QUEUE_GET_CONFIG_REQUEST, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
eq_(self.port['val'], res[4])
|
|
|
|
|
|
class TestOFPDescStatsRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPDescStatsRequest
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
flags = {'buf': b'\x00\x00', 'val': 0}
|
|
|
|
c = OFPDescStatsRequest(Datapath, flags['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(ofproto.OFPST_DESC, self.c.type)
|
|
eq_(self.flags['val'], self.c.flags)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_STATS_REQUEST, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_STATS_MSG_PACK_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
|
|
# OFP_HEADER_PACK_STR
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_STATS_REQUEST, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
eq_(ofproto.OFPST_DESC, res[4])
|
|
eq_(self.flags['val'], res[5])
|
|
|
|
|
|
class TestOFPFlowStatsRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPFlowStatsRequest
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
flags = {'buf': b'\x00\x00', 'val': 0}
|
|
|
|
# OFP_MATCH_PACK_STR
|
|
# '!IH6s6sHBxHBB2xIIHH'...wildcards, in_port, dl_src, dl_dst, dl_vlan,
|
|
# dl_vlan_pcp, dl_type, nw_tos, nw_proto,
|
|
# nw_src, nw_dst, tp_src, tp_dst
|
|
wildcards = {'buf': b'\xd2\x71\x25\x23', 'val': 3530630435}
|
|
in_port = {'buf': b'\x37\x8b', 'val': 14219}
|
|
dl_src = b'\x58\xd0\x8a\x69\xa4\xfc'
|
|
dl_dst = b'\xb6\xe2\xef\xb1\xa6\x2d'
|
|
dl_vlan = {'buf': b'\xc1\xf9', 'val': 49657}
|
|
dl_vlan_pcp = {'buf': b'\x79', 'val': 121}
|
|
zfill0 = b'\x00'
|
|
dl_type = {'buf': b'\xa6\x9e', 'val': 42654}
|
|
nw_tos = {'buf': b'\xde', 'val': 222}
|
|
nw_proto = {'buf': b'\xe5', 'val': 229}
|
|
zfil11 = b'\x00' * 2
|
|
nw_src = {'buf': b'\x1b\x6d\x8d\x4b', 'val': 460164427}
|
|
nw_dst = {'buf': b'\xab\x25\xe1\x20', 'val': 2871386400}
|
|
tp_src = {'buf': b'\xd5\xc3', 'val': 54723}
|
|
tp_dst = {'buf': b'\x78\xb9', 'val': 30905}
|
|
|
|
match = OFPMatch(wildcards['val'],
|
|
in_port['val'],
|
|
dl_src,
|
|
dl_dst,
|
|
dl_vlan['val'],
|
|
dl_vlan_pcp['val'],
|
|
dl_type['val'],
|
|
nw_tos['val'],
|
|
nw_proto['val'],
|
|
nw_src['val'],
|
|
nw_dst['val'],
|
|
tp_src['val'],
|
|
tp_dst['val'])
|
|
|
|
# OFP_FLOW_STATS_REQUEST_ID_PORT_STR
|
|
# '!BxH'...table_id, zfill, out_port
|
|
table_id = {'buf': b'\xd1', 'val': 209}
|
|
zfill = b'\x00' * 1
|
|
out_port = {'buf': b'\xe4\x9a', 'val': 58522}
|
|
|
|
c = OFPFlowStatsRequest(Datapath,
|
|
flags['val'],
|
|
match,
|
|
table_id['val'],
|
|
out_port['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(ofproto.OFPST_FLOW, self.c.type)
|
|
eq_(self.flags['val'], self.c.flags)
|
|
eq_(self.table_id['val'], self.c.table_id)
|
|
eq_(self.out_port['val'], self.c.out_port)
|
|
|
|
# match
|
|
match = self.c.match
|
|
eq_(self.match.__hash__(), match.__hash__())
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_STATS_REQUEST, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_STATS_MSG_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_MATCH_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_FLOW_STATS_REQUEST_ID_PORT_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
|
|
# OFP_HEADER_PACK_STR
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_STATS_REQUEST, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
eq_(ofproto.OFPST_FLOW, res[4])
|
|
eq_(self.flags['val'], res[5])
|
|
|
|
# OFP_MATCH_PACK_STR
|
|
eq_(self.wildcards['val'], res[6])
|
|
eq_(self.in_port['val'], res[7])
|
|
eq_(self.dl_src, res[8])
|
|
eq_(self.dl_dst, res[9])
|
|
eq_(self.dl_vlan['val'], res[10])
|
|
eq_(self.dl_vlan_pcp['val'], res[11])
|
|
eq_(self.dl_type['val'], res[12])
|
|
eq_(self.nw_tos['val'], res[13])
|
|
eq_(self.nw_proto['val'], res[14])
|
|
eq_(self.nw_src['val'], res[15])
|
|
eq_(self.nw_dst['val'], res[16])
|
|
eq_(self.tp_src['val'], res[17])
|
|
eq_(self.tp_dst['val'], res[18])
|
|
|
|
# OFP_FLOW_STATS_REQUEST_ID_PORT_STR
|
|
eq_(self.table_id['val'], res[19])
|
|
eq_(self.out_port['val'], res[20])
|
|
|
|
|
|
class TestOFPAggregateStatsRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPAggregateStatsRequest
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
flags = {'buf': b'\x00\x00', 'val': 0}
|
|
|
|
# OFP_MATCH_PACK_STR
|
|
# '!IH6s6sHBxHBB2xIIHH'...wildcards, in_port, dl_src, dl_dst, dl_vlan,
|
|
# dl_vlan_pcp, dl_type, nw_tos, nw_proto,
|
|
# nw_src, nw_dst, tp_src, tp_dst
|
|
wildcards = {'buf': b'\xea\x66\x4a\xd4', 'val': 3932572372}
|
|
in_port = {'buf': b'\x64\xac', 'val': 25772}
|
|
dl_src = b'\x90\x13\x60\x5e\x20\x4d'
|
|
dl_dst = b'\xb5\x5d\x14\x5e\xb9\x22'
|
|
dl_vlan = {'buf': b'\x8b\xeb', 'val': 35819}
|
|
dl_vlan_pcp = {'buf': b'\xe8', 'val': 232}
|
|
zfill0 = b'\x00'
|
|
dl_type = {'buf': b'\62\xc9', 'val': 25289}
|
|
nw_tos = {'buf': b'\xb5', 'val': 181}
|
|
nw_proto = {'buf': b'\xc4', 'val': 196}
|
|
zfil11 = b'\x00' * 2
|
|
nw_src = {'buf': b'\xb7\xd1\xb7\xef', 'val': 3083974639}
|
|
nw_dst = {'buf': b'\x7c\xc6\x18\x15', 'val': 2093357077}
|
|
tp_src = {'buf': b'\x26\x9a', 'val': 9882}
|
|
tp_dst = {'buf': b'\x7a\x89', 'val': 31369}
|
|
|
|
match = OFPMatch(wildcards['val'],
|
|
in_port['val'],
|
|
dl_src,
|
|
dl_dst,
|
|
dl_vlan['val'],
|
|
dl_vlan_pcp['val'],
|
|
dl_type['val'],
|
|
nw_tos['val'],
|
|
nw_proto['val'],
|
|
nw_src['val'],
|
|
nw_dst['val'],
|
|
tp_src['val'],
|
|
tp_dst['val'])
|
|
|
|
# OFP_FLOW_STATS_REQUEST_ID_PORT_STR
|
|
# '!BxH'...table_id, zfill, out_port
|
|
table_id = {'buf': b'\xd1', 'val': 209}
|
|
zfill = b'\x00' * 1
|
|
out_port = {'buf': b'\xb5\xe8', 'val': 46568}
|
|
|
|
c = OFPAggregateStatsRequest(Datapath,
|
|
flags['val'],
|
|
match,
|
|
table_id['val'],
|
|
out_port['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(ofproto.OFPST_AGGREGATE, self.c.type)
|
|
eq_(self.flags['val'], self.c.flags)
|
|
eq_(self.table_id['val'], self.c.table_id)
|
|
eq_(self.out_port['val'], self.c.out_port)
|
|
|
|
# match
|
|
match = self.c.match
|
|
eq_(self.match.__hash__(), match.__hash__())
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_STATS_REQUEST, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_STATS_MSG_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_MATCH_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_FLOW_STATS_REQUEST_ID_PORT_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
|
|
# OFP_HEADER_PACK_STR
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_STATS_REQUEST, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
eq_(ofproto.OFPST_AGGREGATE, res[4])
|
|
eq_(self.flags['val'], res[5])
|
|
|
|
# OFP_MATCH_PACK_STR
|
|
eq_(self.wildcards['val'], res[6])
|
|
eq_(self.in_port['val'], res[7])
|
|
eq_(self.dl_src, res[8])
|
|
eq_(self.dl_dst, res[9])
|
|
eq_(self.dl_vlan['val'], res[10])
|
|
eq_(self.dl_vlan_pcp['val'], res[11])
|
|
eq_(self.dl_type['val'], res[12])
|
|
eq_(self.nw_tos['val'], res[13])
|
|
eq_(self.nw_proto['val'], res[14])
|
|
eq_(self.nw_src['val'], res[15])
|
|
eq_(self.nw_dst['val'], res[16])
|
|
eq_(self.tp_src['val'], res[17])
|
|
eq_(self.tp_dst['val'], res[18])
|
|
|
|
# OFP_FLOW_STATS_REQUEST_ID_PORT_STR
|
|
eq_(self.table_id['val'], res[19])
|
|
eq_(self.out_port['val'], res[20])
|
|
|
|
|
|
class TestOFPTableStatsRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPTableStatsRequest
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
flags = {'buf': b'\x00\x00', 'val': 0}
|
|
|
|
c = OFPTableStatsRequest(Datapath, flags['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(ofproto.OFPST_TABLE, self.c.type)
|
|
eq_(self.flags['val'], self.c.flags)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_STATS_REQUEST, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_STATS_MSG_PACK_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
|
|
# OFP_HEADER_PACK_STR
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_STATS_REQUEST, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
eq_(ofproto.OFPST_TABLE, res[4])
|
|
eq_(self.flags['val'], res[5])
|
|
|
|
|
|
class TestOFPPortStatsRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPPortStatsRequest
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
flags = {'buf': b'\x00\x00', 'val': 0}
|
|
|
|
# OFP_PORT_STATS_REQUEST_PACK_STR
|
|
# '!H6x'...port_no, zfill
|
|
port_no = {'buf': b'\x6d\x27', 'val': 27943}
|
|
|
|
c = OFPPortStatsRequest(Datapath,
|
|
flags['val'],
|
|
port_no['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(ofproto.OFPST_PORT, self.c.type)
|
|
eq_(self.flags['val'], self.c.flags)
|
|
eq_(self.port_no['val'], self.c.port_no)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_STATS_REQUEST, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_STATS_MSG_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_PORT_STATS_REQUEST_PACK_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
|
|
# OFP_HEADER_PACK_STR
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_STATS_REQUEST, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
eq_(ofproto.OFPST_PORT, res[4])
|
|
eq_(self.flags['val'], res[5])
|
|
|
|
# OFP_PORT_STATS_REQUEST_PACK_STR
|
|
eq_(self.port_no['val'], res[6])
|
|
|
|
|
|
class TestOFPQueueStatsRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPQueueStatsRequest
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
flags = {'buf': b'\x00\x00', 'val': 0}
|
|
|
|
# OFP_QUEUE_STATS_REQUEST_PACK_STR
|
|
# '!HxxI'...port_no, zfill, zfill, queue_id
|
|
port_no = {'buf': b'\x0c\x2d', 'val': 3117}
|
|
queue_id = {'buf': b'\x1b\xe6\xba\x36', 'val': 468105782}
|
|
|
|
c = OFPQueueStatsRequest(Datapath,
|
|
flags['val'],
|
|
port_no['val'],
|
|
queue_id['val'])
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(ofproto.OFPST_QUEUE, self.c.type)
|
|
eq_(self.flags['val'], self.c.flags)
|
|
eq_(self.port_no['val'], self.c.port_no)
|
|
eq_(self.queue_id['val'], self.c.queue_id)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_STATS_REQUEST, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_STATS_MSG_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_QUEUE_STATS_REQUEST_PACK_STR.replace('!', '')
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
|
|
# OFP_HEADER_PACK_STR
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_STATS_REQUEST, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
eq_(ofproto.OFPST_QUEUE, res[4])
|
|
eq_(self.flags['val'], res[5])
|
|
|
|
# OFP_QUEUE_STATS_REQUEST_PACK_STR
|
|
eq_(self.port_no['val'], res[6])
|
|
eq_(self.queue_id['val'], res[7])
|
|
|
|
|
|
class TestOFPVendorStatsRequest(unittest.TestCase):
|
|
""" Test case for ofproto_v1_0_parser.OFPVendorStatsRequest
|
|
"""
|
|
|
|
class Datapath(object):
|
|
ofproto = ofproto # copy to class attribute
|
|
ofproto_parser = ofproto_v1_0_parser
|
|
|
|
flags = {'buf': b'\x00\x00', 'val': 0}
|
|
|
|
# OFP_VENDOR_STATS_MSG_PACK_STR
|
|
# '!I'...vendor
|
|
vendor = {'buf': b'\xff\xff\xff\xff', 'val': ofproto.OFPAT_VENDOR}
|
|
|
|
specific_data = b'specific_data'
|
|
|
|
c = OFPVendorStatsRequest(Datapath,
|
|
flags['val'],
|
|
vendor['val'],
|
|
specific_data)
|
|
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def test_init(self):
|
|
eq_(ofproto.OFPST_VENDOR, self.c.type)
|
|
eq_(self.flags['val'], self.c.flags)
|
|
eq_(self.vendor['val'], self.c.vendor)
|
|
eq_(self.specific_data, self.c.specific_data)
|
|
|
|
def test_parser(self):
|
|
# Not used.
|
|
pass
|
|
|
|
def test_serialize(self):
|
|
self.c.serialize()
|
|
|
|
eq_(ofproto.OFP_VERSION, self.c.version)
|
|
eq_(ofproto.OFPT_STATS_REQUEST, self.c.msg_type)
|
|
eq_(0, self.c.xid)
|
|
|
|
fmt = '!' \
|
|
+ ofproto.OFP_HEADER_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_STATS_MSG_PACK_STR.replace('!', '') \
|
|
+ ofproto.OFP_VENDOR_STATS_MSG_PACK_STR.replace('!', '') \
|
|
+ str(len(self.specific_data)) + 's'
|
|
|
|
res = struct.unpack(fmt, six.binary_type(self.c.buf))
|
|
|
|
# OFP_HEADER_PACK_STR
|
|
eq_(ofproto.OFP_VERSION, res[0])
|
|
eq_(ofproto.OFPT_STATS_REQUEST, res[1])
|
|
eq_(len(self.c.buf), res[2])
|
|
eq_(0, res[3])
|
|
|
|
# OFP_STATS_MSG_PACK_STR
|
|
eq_(ofproto.OFPST_VENDOR, res[4])
|
|
eq_(self.flags['val'], res[5])
|
|
|
|
# OFP_VENDOR_STATS_MSG_PACK_STR
|
|
eq_(self.vendor['val'], res[6])
|
|
|
|
# specific_data
|
|
eq_(self.specific_data, res[7])
|