mirrors/ryu
1
0
Fork 0
mirror of https://github.com/faucetsdn/ryu.git synced 2026-01-30 13:01:23 +01:00
Code Issues Projects Releases Wiki Activity

test: fix pep8 1.3.3 warnings

Browse Source 
Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
This commit is contained in:
FUJITA Tomonori 2012-08-22 14:43:37 +09:00
parent c8cd4226d7
commit cccd01f5ea
9 changed files with 258 additions and 260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ryu/tests/integrated/test_add_flow_v10.py
View File

@ -68,7 +68,7 @@ class RunTest(tester.TestFlowBase):
action = actions[0]
if action.cls_action_type != type_:
return "Action type error. send:%s, val:%s" \
% (type_, action.cls_action_type)
% (type_, action.cls_action_type)
except IndexError:
return "Action is not setting."
@ -84,14 +84,14 @@ class RunTest(tester.TestFlowBase):
if f_value != value:
return "Value error. send:%s=%s val:%s" \
% (name, value, f_value)
% (name, value, f_value)
return True
def _verify_rule(self, rule, name, value):
f_value = getattr(rule, name)
if f_value != value:
return "Value error. send:%s=%s val:%s" \
% (name, value, f_value)
% (name, value, f_value)
return True
def verify_default(self, dp, stats):

6
ryu/tests/integrated/test_add_flow_v12_actions.py
View File

@ -73,7 +73,7 @@ class RunTest(tester.TestFlowBase):
action = stats[0].instructions[0].actions[0]
if action.cls_action_type != type_:
return "Action type error. send:%s, val:%s" \
% (type_, action.cls_action_type)
% (type_, action.cls_action_type)
except IndexError:
return "Action is not setting."
@ -87,12 +87,12 @@ class RunTest(tester.TestFlowBase):
if name == 'field':
if s_val.header != field:
return "Field error. send:%s val:%s" \
% (field, s_val.field)
% (field, s_val.field)
s_val = s_val.value
if name and s_val != value:
return "Value error. send:%s=%s val:%s" \
% (name, value, s_val)
% (name, value, s_val)
return True

8
ryu/tests/integrated/test_add_flow_v12_matches.py
View File

@ -64,11 +64,11 @@ class RunTest(tester.TestFlowBase):
if f_value == value and f_mask == mask:
return True
elif value == None:
elif value is None:
return "Field[%s] is setting." % (headers, )
else:
return "Value error. send: (%s/%s), val:(%s/%s)" \
% (value, mask, f_value, f_mask)
% (value, mask, f_value, f_mask)
def test_rule_set_dl_dst(self, dp):
dl_dst = 'e2:7a:09:79:0b:0f'
@ -861,7 +861,7 @@ class RunTest(tester.TestFlowBase):
mask = 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:0'
mask_int = self.ipv6_to_int(mask)
ipv6_src_masked = [x & y for (x, y) in
itertools.izip(ipv6_src_int, mask_int)]
itertools.izip(ipv6_src_int, mask_int)]
self._verify = [(dp.ofproto.OXM_OF_IPV6_SRC,
dp.ofproto.OXM_OF_IPV6_SRC_W, ),
ipv6_src_masked, mask_int]
@ -921,7 +921,7 @@ class RunTest(tester.TestFlowBase):
mask = 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:0'
mask_int = self.ipv6_to_int(mask)
ipv6_dst_masked = [x & y for (x, y) in
itertools.izip(ipv6_dst_int, mask_int)]
itertools.izip(ipv6_dst_int, mask_int)]
self._verify = [(dp.ofproto.OXM_OF_IPV6_DST,
dp.ofproto.OXM_OF_IPV6_DST_W, ),
ipv6_dst_masked, mask_int]

34
ryu/tests/integrated/test_request_reply_v12.py
View File

@ -76,7 +76,7 @@ class RunTest(tester.TestFlowBase):
verify_func = getattr(self, v)
result = verify_func(dp, msg)
if result == True:
if result is True:
self.unclear -= 1
self.results[self.current] = result
@ -136,9 +136,11 @@ class RunTest(tester.TestFlowBase):
out_group = dp.ofproto.OFPG_ANY
m = dp.ofproto_parser.OFPFlowMod(dp, cookie, cookie_mask,
table_id, command, idle_timeout, hard_timeout,
priority, buffer_id, out_port, out_group,
flags, match, inst)
table_id, command,
idle_timeout, hard_timeout,
priority, buffer_id,
out_port, out_group,
flags, match, inst)
dp.send_msg(m)
@ -157,8 +159,8 @@ class RunTest(tester.TestFlowBase):
self._verify = dp.ofproto.OFPST_AGGREGATE
match = dp.ofproto_parser.OFPMatch()
m = dp.ofproto_parser.OFPAggregateStatsRequest(
dp, dp.ofproto.OFPTT_ALL, dp.ofproto.OFPP_ANY,
dp.ofproto.OFPG_ANY, 0, 0, match)
dp, dp.ofproto.OFPTT_ALL, dp.ofproto.OFPP_ANY,
dp.ofproto.OFPG_ANY, 0, 0, match)
dp.send_msg(m)
def test_table_stats_request(self, dp):
@ -246,8 +248,8 @@ class RunTest(tester.TestFlowBase):
dp.send_barrier()
match = dp.ofproto_parser.OFPMatch()
m = dp.ofproto_parser.OFPAggregateStatsRequest(
dp, dp.ofproto.OFPTT_ALL, dp.ofproto.OFPP_ANY,
dp.ofproto.OFPG_ANY, 0, 0, match)
dp, dp.ofproto.OFPTT_ALL, dp.ofproto.OFPP_ANY,
dp.ofproto.OFPG_ANY, 0, 0, match)
dp.send_msg(m)
def verify_aggregate_stats_flow_count(self, dp, msg):
@ -265,8 +267,8 @@ class RunTest(tester.TestFlowBase):
out_port = 2
match = dp.ofproto_parser.OFPMatch()
m = dp.ofproto_parser.OFPAggregateStatsRequest(
dp, dp.ofproto.OFPTT_ALL, out_port,
dp.ofproto.OFPG_ANY, 0, 0, match)
dp, dp.ofproto.OFPTT_ALL, out_port,
dp.ofproto.OFPG_ANY, 0, 0, match)
dp.send_msg(m)
def verify_aggregate_stats_flow_count_out_port(self, dp, msg):
@ -424,12 +426,10 @@ class RunTest(tester.TestFlowBase):
a2 = dp.ofproto_parser.OFPActionOutput(2, 1500)
# table_id, cookie, priority, dl_dst, action)
tables = {
0: [0xffff, 10, '\xee' * 6, a1],
tables = {0: [0xffff, 10, '\xee' * 6, a1],
1: [0xff00, 10, '\xee' * 6, a2],
2: [0xf000, 100, '\xee' * 6, a1],
3: [0x0000, 10, '\xff' * 6, a1],
}
3: [0x0000, 10, '\xff' * 6, a1]}
self._verify = tables
for table_id, val in tables.items():
@ -666,7 +666,7 @@ class RunTest(tester.TestFlowBase):
msg = ev.msg
dp = msg.datapath
if self._verify == dp.ofproto.OFPST_TABLE:
self.table_stats = msg.body[0]
self.table_stats = msg.body
self.start_next_test(dp)
else:
self.run_verify(ev)
@ -696,8 +696,8 @@ class RunTest(tester.TestFlowBase):
if self.capabilities is None:
m = dp.ofproto_parser.OFPFeaturesRequest(dp)
dp.send_msg(m)
elif self.capabilities & dp.ofproto.OFPC_TABLE_STATS \
and self.table_stats is None:
elif (self.capabilities & dp.ofproto.OFPC_TABLE_STATS > 0 and
self.table_stats is None):
self._verify = dp.ofproto.OFPST_TABLE
m = dp.ofproto_parser.OFPTableStatsRequest(dp)
dp.send_msg(m)

14
ryu/tests/integrated/tester.py
View File

@ -49,9 +49,7 @@ class TestFlowBase(app_manager.RyuApp):
To check flows of switch.
"""
_CONTEXTS = {
'dpset': dpset.DPSet,
}
_CONTEXTS = {'dpset': dpset.DPSet}
def __init__(self, *args, **kwargs):
super(TestFlowBase, self).__init__(*args, **kwargs)
@ -70,8 +68,7 @@ class TestFlowBase(app_manager.RyuApp):
match = dp.ofproto_parser.OFPMatch(dp.ofproto.OFPFW_ALL,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0)
m = dp.ofproto_parser.OFPFlowMod(
dp, match, 0,
m = dp.ofproto_parser.OFPFlowMod(dp, match, 0,
dp.ofproto.OFPFC_DELETE,
0, 0, 0, 0,
dp.ofproto.OFPP_NONE, 0, None)
@ -91,9 +88,8 @@ class TestFlowBase(app_manager.RyuApp):
match = dp.ofproto_parser.OFPMatch(dp.ofproto.OFPFW_ALL,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0)
m = dp.ofproto_parser.OFPFlowStatsRequest(
dp, 0, match,
0, dp.ofproto.OFPP_NONE)
m = dp.ofproto_parser.OFPFlowStatsRequest(dp, 0, match,
0, dp.ofproto.OFPP_NONE)
elif dp.ofproto == ofproto_v1_2:
match = dp.ofproto_parser.OFPMatch()
m = dp.ofproto_parser.OFPFlowStatsRequest(dp, dp.ofproto.OFPTT_ALL,
@ -142,7 +138,7 @@ class TestFlowBase(app_manager.RyuApp):
verify_func = getattr(self, v)
result = verify_func(dp, msg.body)
if result == True:
if result is True:
self.unclear -= 1
self.results[self.current] = result

17
ryu/tests/test_lib.py
View File

@ -9,6 +9,7 @@ import logging
from nose import result
from nose import core
from nose import config
from nose.plugins.skip import SkipTest
class _AnsiColorizer(object):
@ -65,9 +66,9 @@ class _Win32Colorizer(object):
See _AnsiColorizer docstring.
"""
def __init__(self, stream):
from win32console import GetStdHandle, STD_OUT_HANDLE, \
FOREGROUND_RED, FOREGROUND_BLUE, FOREGROUND_GREEN, \
FOREGROUND_INTENSITY
from win32console import GetStdHandle, STD_OUT_HANDLE
from win32console import FOREGROUND_RED, FOREGROUND_BLUE
from win32console import FOREGROUND_GREEN, FOREGROUND_INTENSITY
red, green, blue, bold = (FOREGROUND_RED, FOREGROUND_GREEN,
FOREGROUND_BLUE, FOREGROUND_INTENSITY)
self.stream = stream
@ -217,9 +218,9 @@ class RyuTestResult(result.TextTestResult):
class RyuTestRunner(core.TextTestRunner):
def _makeResult(self):
return RyuTestResult(self.stream,
self.descriptions,
self.verbosity,
self.config)
self.descriptions,
self.verbosity,
self.config)
def run_tests(c=None):
@ -239,6 +240,6 @@ def run_tests(c=None):
return True
runner = RyuTestRunner(stream=c.stream,
verbosity=c.verbosity,
config=c)
verbosity=c.verbosity,
config=c)
return not core.run(config=c, testRunner=runner)

50
ryu/tests/unit/ofproto/test_ofproto_parser.py
View File

@ -32,25 +32,27 @@ class TestOfproto_Parser(unittest.TestCase):
def setUp(self):
LOG.debug('setUp')
self.bufHello = binascii.unhexlify('0100000800000001')
self.bufFeaturesReply = binascii.unhexlify(
'010600b0000000020000000000000abc' \
+ '00000100010000000000008700000fff' \
+ '0002aefa39d2b9177472656d61302d30' \
+ '00000000000000000000000000000000' \
+ '000000c0000000000000000000000000' \
+ 'fffe723f9a764cc87673775f30786162' \
+ '63000000000000000000000100000001' \
+ '00000082000000000000000000000000' \
+ '00012200d6c5a1947472656d61312d30' \
+ '00000000000000000000000000000000' \
+ '000000c0000000000000000000000000')
self.bufPacketIn = binascii.unhexlify(
'010a005200000000000001010040' \
+ '00020000000000000002000000000001' \
+ '080045000032000000004011f967c0a8' \
+ '0001c0a8000200010001001e00000000' \
+ '00000000000000000000000000000000' \
+ '00000000')
fr = '010600b0000000020000000000000abc' \
+ '00000100010000000000008700000fff' \
+ '0002aefa39d2b9177472656d61302d30' \
+ '00000000000000000000000000000000' \
+ '000000c0000000000000000000000000' \
+ 'fffe723f9a764cc87673775f30786162' \
+ '63000000000000000000000100000001' \
+ '00000082000000000000000000000000' \
+ '00012200d6c5a1947472656d61312d30' \
+ '00000000000000000000000000000000' \
+ '000000c0000000000000000000000000'
self.bufFeaturesReply = binascii.unhexlify(fr)
pi = '010a005200000000000001010040' \
+ '00020000000000000002000000000001' \
+ '080045000032000000004011f967c0a8' \
+ '0001c0a8000200010001001e00000000' \
+ '00000000000000000000000000000000' \
+ '00000000'
self.bufPacketIn = binascii.unhexlify(pi)
def tearDown(self):
LOG.debug('tearDown')
@ -160,12 +162,10 @@ class TestMsgBase(unittest.TestCase):
def _test_parser(self, msg_type=ofproto_v1_0.OFPT_HELLO):
xid = 2183948390
res = ofproto_v1_0_parser.OFPHello.parser(object, \
ofproto_v1_0.OFP_VERSION, \
msg_type, \
ofproto_v1_0.OFP_HEADER_SIZE, \
xid, \
str().zfill(ofproto_v1_0.OFP_HEADER_SIZE))
res = ofproto_v1_0_parser.OFPHello.parser(
object, ofproto_v1_0.OFP_VERSION, msg_type,
ofproto_v1_0.OFP_HEADER_SIZE, xid,
str().zfill(ofproto_v1_0.OFP_HEADER_SIZE))
eq_(ofproto_v1_0.OFP_VERSION, res.version)
eq_(ofproto_v1_0.OFPT_HELLO, res.msg_type)

312
ryu/tests/unit/ofproto/test_parser_v10.py
View File

@ -229,9 +229,9 @@ class TestOFPActionHeader(unittest.TestCase):
len = {'buf': '\x00\x08', 'val': ofproto_v1_0.OFP_ACTION_HEADER_SIZE}
zfill = '\x00' * 4
buf = type['buf'] + \
len['buf'] + \
zfill
buf = type['buf'] \
+ len['buf'] \
+ zfill
c = OFPActionHeader(type['val'], len['val'])
@ -362,9 +362,9 @@ class TestOFPActionVlanVid(unittest.TestCase):
type_ = {'buf': '\x00\x02', 'val': 2}
buf = type_['buf'] \
+ self.len_['buf'] \
+ self.vlan_vid['buf'] \
+ self.zfill
+ self.len_['buf'] \
+ self.vlan_vid['buf'] \
+ self.zfill
self.c.parser(buf, 0)
@ -373,9 +373,9 @@ class TestOFPActionVlanVid(unittest.TestCase):
len_ = {'buf': '\x00\x07', 'val': 7}
buf = self.type_['buf'] \
+ len_['buf'] \
+ self.vlan_vid['buf'] \
+ self.zfill
+ len_['buf'] \
+ self.vlan_vid['buf'] \
+ self.zfill
self.c.parser(buf, 0)
@ -427,9 +427,9 @@ class TestOFPActionVlanPcp(unittest.TestCase):
type_ = {'buf': '\x00\x01', 'val': 1}
buf = type_['buf'] \
+ self.len_['buf'] \
+ self.vlan_pcp['buf'] \
+ self.zfill
+ self.len_['buf'] \
+ self.vlan_pcp['buf'] \
+ self.zfill
self.c.parser(buf, 0)
@ -438,9 +438,9 @@ class TestOFPActionVlanPcp(unittest.TestCase):
len_ = {'buf': '\x00\x07', 'val': 7}
buf = self.type_['buf'] \
+ len_['buf'] \
+ self.vlan_pcp['buf'] \
+ self.zfill
+ len_['buf'] \
+ self.vlan_pcp['buf'] \
+ self.zfill
self.c.parser(buf, 0)
@ -697,8 +697,8 @@ class TestOFPActionSetNwSrc(unittest.TestCase):
type_ = {'buf': '\x00\x05', 'val': 5}
buf = type_['buf'] \
+ self.len_['buf'] \
+ self.nw_addr['buf']
+ self.len_['buf'] \
+ self.nw_addr['buf']
self.c.parser(buf, 0)
@ -707,8 +707,8 @@ class TestOFPActionSetNwSrc(unittest.TestCase):
len_ = {'buf': '\x00\x10', 'val': 16}
buf = self.type_['buf'] \
+ len_['buf'] \
+ self.nw_addr['buf']
+ len_['buf'] \
+ self.nw_addr['buf']
self.c.parser(buf, 0)
@ -768,8 +768,8 @@ class TestOFPActionSetNwDst(unittest.TestCase):
type_ = {'buf': '\x00\x05', 'val': 5}
buf = type_['buf'] \
+ self.len_['buf'] \
+ self.nw_addr['buf']
+ self.len_['buf'] \
+ self.nw_addr['buf']
self.c.parser(buf, 0)
@ -778,8 +778,8 @@ class TestOFPActionSetNwDst(unittest.TestCase):
len_ = {'buf': '\x00\x10', 'val': 16}
buf = self.type_['buf'] \
+ len_['buf'] \
+ self.nw_addr['buf']
+ len_['buf'] \
+ self.nw_addr['buf']
self.c.parser(buf, 0)
@ -831,9 +831,9 @@ class TestOFPActionSetNwTos(unittest.TestCase):
type_ = {'buf': '\x00\x05', 'val': 5}
buf = type_['buf'] \
+ self.len_['buf'] \
+ self.tos['buf'] \
+ self.zfill
+ self.len_['buf'] \
+ self.tos['buf'] \
+ self.zfill
self.c.parser(buf, 0)
@ -842,9 +842,9 @@ class TestOFPActionSetNwTos(unittest.TestCase):
len_ = {'buf': '\x00\x07', 'val': 7}
buf = self.type_['buf'] \
+ len_['buf'] \
+ self.tos['buf'] \
+ self.zfill
+ len_['buf'] \
+ self.tos['buf'] \
+ self.zfill
self.c.parser(buf, 0)
@ -907,9 +907,9 @@ class TestOFPActionSetTpSrc(unittest.TestCase):
type_ = {'buf': '\x00\x07', 'val': 7}
buf = type_['buf'] \
+ self.len_['buf'] \
+ self.tp['buf'] \
+ self.zfill
+ self.len_['buf'] \
+ self.tp['buf'] \
+ self.zfill
self.c.parser(buf, 0)
@ -918,9 +918,9 @@ class TestOFPActionSetTpSrc(unittest.TestCase):
len_ = {'buf': '\x00\x07', 'val': 7}
buf = self.type_['buf'] \
+ len_['buf'] \
+ self.tp['buf'] \
+ self.zfill
+ len_['buf'] \
+ self.tp['buf'] \
+ self.zfill
self.c.parser(buf, 0)
@ -983,9 +983,9 @@ class TestOFPActionSetTpDst(unittest.TestCase):
type_ = {'buf': '\x00\x10', 'val': 16}
buf = type_['buf'] \
+ self.len_['buf'] \
+ self.tp['buf'] \
+ self.zfill
+ self.len_['buf'] \
+ self.tp['buf'] \
+ self.zfill
self.c.parser(buf, 0)
@ -994,9 +994,9 @@ class TestOFPActionSetTpDst(unittest.TestCase):
len_ = {'buf': '\x00\x07', 'val': 7}
buf = self.type_['buf'] \
+ len_['buf'] \
+ self.tp['buf'] \
+ self.zfill
+ len_['buf'] \
+ self.tp['buf'] \
+ self.zfill
self.c.parser(buf, 0)
@ -1053,10 +1053,10 @@ class TestOFPActionEnqueue(unittest.TestCase):
type_ = {'buf': '\x00\x0a', 'val': 10}
buf = type_['buf'] \
+ self.len_['buf'] \
+ self.port['buf'] \
+ self.zfill \
+ self.queue_id['buf']
+ self.len_['buf'] \
+ self.port['buf'] \
+ self.zfill \
+ self.queue_id['buf']
self.c.parser(buf, 0)
@ -1065,10 +1065,10 @@ class TestOFPActionEnqueue(unittest.TestCase):
len_ = {'buf': '\x00\x05', 'val': 5}
buf = self.type_['buf'] \
+ len_['buf'] \
+ self.port['buf'] \
+ self.zfill \
+ self.queue_id['buf']
+ len_['buf'] \
+ self.port['buf'] \
+ self.zfill \
+ self.queue_id['buf']
self.c.parser(buf, 0)
@ -2127,20 +2127,20 @@ class TestOFPFlowStats(unittest.TestCase):
# OFP_MATCH_PACK_STR
# '!IH6s6sHBxHBB2xIIHH'...
match = '\x97\x7c\xa6\x1e' \
+ '\x5e\xa0' \
+ '\x7a\x3e\xed\x30\x4a\x90' \
+ '\x96\x8e\x67\xbe\x2f\xe2' \
+ '\xb1\x81' \
+ '\xbe' \
+ '\x00' \
+ '\x01\xab' \
+ '\x42' \
+ '\xfe' \
+ '\x00\x00' \
+ '\xa4\x5d\x5c\x42' \
+ '\xa2\x5c\x2e\x05' \
+ '\x5a\x94' \
+ '\x64\xd4'
+ '\x5e\xa0' \
+ '\x7a\x3e\xed\x30\x4a\x90' \
+ '\x96\x8e\x67\xbe\x2f\xe2' \
+ '\xb1\x81' \
+ '\xbe' \
+ '\x00' \
+ '\x01\xab' \
+ '\x42' \
+ '\xfe' \
+ '\x00\x00' \
+ '\xa4\x5d\x5c\x42' \
+ '\xa2\x5c\x2e\x05' \
+ '\x5a\x94' \
+ '\x64\xd4'
# OFP_FLOW_STATS_1_PACK_STR
# '!IIHHH6xQQQ'...duration_sec, duration_nsec, priority,
@ -2157,7 +2157,7 @@ class TestOFPFlowStats(unittest.TestCase):
packet_count = {'buf': '\x47\x5c\xc6\x05\x28\xff\x7c\xdb',
'val': 5142202600015232219}
byte_count = {'buf': '\x24\xe9\x4b\xee\xcb\x57\xd9\xc3',
'val': 2659740543924820419}
'val': 2659740543924820419}
# <action>_PACK_STR...type_, len_ [others...]
type = {'buf': '\x00\x00', 'val': ofproto_v1_0.OFPAT_OUTPUT}
@ -2184,17 +2184,17 @@ class TestOFPFlowStats(unittest.TestCase):
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']
+ 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
@ -2534,20 +2534,18 @@ class TestOFPQueuePropNone(unittest.TestCase):
def test_init(self):
cls = OFPQueuePropHeader._QUEUE_PROPERTIES[self.c.cls_prop_type]
ok_(self.property['val'] \
== self.c.cls_prop_type \
== self.c.property \
== cls.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)
ok_(self.len['val'] \
== self.c.cls_prop_len \
== self.c.len \
== cls.cls_prop_len)
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
+ self.len['buf'] \
+ self.zfill
ok_(self.c.parser(buf, 0))
@ -2591,14 +2589,12 @@ class TestOFPQueuePropMinRate(unittest.TestCase):
def test_init(self):
cls = OFPQueuePropHeader._QUEUE_PROPERTIES[self.c.cls_prop_type]
ok_(self.rate['val'] \
== self.c.cls_prop_type \
== self.c.rate \
== cls.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)
ok_(self.len['val'] \
== self.c.cls_prop_len \
== cls.cls_prop_len)
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)
@ -2700,11 +2696,11 @@ class TestOFPHello(unittest.TestCase):
def test_parser(self):
xid = 2183948390
res = OFPHello.parser(object, \
ofproto_v1_0.OFP_VERSION, \
ofproto_v1_0.OFPT_HELLO, \
ofproto_v1_0.OFP_HEADER_SIZE, \
xid, \
res = OFPHello.parser(object,
ofproto_v1_0.OFP_VERSION,
ofproto_v1_0.OFPT_HELLO,
ofproto_v1_0.OFP_HEADER_SIZE,
xid,
str().zfill(ofproto_v1_0.OFP_HEADER_SIZE))
eq_(ofproto_v1_0.OFP_VERSION, res.version)
@ -2868,11 +2864,11 @@ class TestOFPEchoRequest(unittest.TestCase):
+ data
res = OFPEchoRequest.parser(object,
version['val'],
msg_type['val'],
msg_len['val'],
xid['val'],
buf)
version['val'],
msg_type['val'],
msg_len['val'],
xid['val'],
buf)
eq_(version['val'], res.version)
eq_(msg_type['val'], res.msg_type)
@ -2954,11 +2950,11 @@ class TestOFPEchoReply(unittest.TestCase):
+ data
res = OFPEchoReply.parser(object,
version['val'],
msg_type['val'],
msg_len['val'],
xid['val'],
buf)
version['val'],
msg_type['val'],
msg_len['val'],
xid['val'],
buf)
eq_(version['val'], res.version)
eq_(msg_type['val'], res.msg_type)
@ -3479,9 +3475,9 @@ class TestOFPSwitchFeatures(unittest.TestCase):
def test_parser(self):
version = {'buf': '\x01', 'val': ofproto_v1_0.OFP_VERSION}
msg_type = {'buf': '\x06', 'val': ofproto_v1_0.OFPT_FEATURES_REPLY}
msg_len = {'buf': '\x00\x4c',
'val': ofproto_v1_0.OFP_SWITCH_FEATURES_SIZE \
+ ofproto_v1_0.OFP_PHY_PORT_SIZE}
msg_len_val = ofproto_v1_0.OFP_SWITCH_FEATURES_SIZE \
+ ofproto_v1_0.OFP_PHY_PORT_SIZE
msg_len = {'buf': '\x00\x4c', 'val': msg_len_val}
xid = {'buf': '\xcc\x0a\x41\xd4', 'val': 3423224276}
# OFP_SWITCH_FEATURES_PACK_STR
@ -4109,9 +4105,9 @@ class TestOFPQueueGetConfigReply(unittest.TestCase):
version = {'buf': '\x01', 'val': ofproto_v1_0.OFP_VERSION}
msg_type = {'buf': '\x0a',
'val': ofproto_v1_0.OFPT_QUEUE_GET_CONFIG_REPLY}
msg_len = {'buf': '\x00\x14',
'val': ofproto_v1_0.OFP_QUEUE_GET_CONFIG_REPLY_SIZE \
+ ofproto_v1_0.OFP_PACKET_QUEUE_SIZE}
msg_len_val = ofproto_v1_0.OFP_QUEUE_GET_CONFIG_REPLY_SIZE \
+ ofproto_v1_0.OFP_PACKET_QUEUE_SIZE
msg_len = {'buf': '\x00\x14', 'val': msg_len_val}
xid = {'buf': '\x94\xc4\xd2\xcd', 'val': 2495926989}
buf = version['buf'] \
@ -4200,9 +4196,9 @@ class TestOFPDescStatsReply(unittest.TestCase):
def test_parser(self):
version = {'buf': '\x01', 'val': ofproto_v1_0.OFP_VERSION}
msg_type = {'buf': '\x11', 'val': ofproto_v1_0.OFPT_STATS_REPLY}
msg_len = {'buf': '\x04\x38',
'val': ofproto_v1_0.OFP_STATS_MSG_SIZE \
+ ofproto_v1_0.OFP_DESC_STATS_SIZE}
msg_len_val = ofproto_v1_0.OFP_STATS_MSG_SIZE \
+ ofproto_v1_0.OFP_DESC_STATS_SIZE
msg_len = {'buf': '\x04\x38', 'val': msg_len_val}
xid = {'buf': '\x94\xc4\xd2\xcd', 'val': 2495926989}
buf = version['buf'] \
@ -4300,9 +4296,9 @@ class TestOFPFlowStatsReply(unittest.TestCase):
def test_parser(self):
version = {'buf': '\x01', 'val': ofproto_v1_0.OFP_VERSION}
msg_type = {'buf': '\x11', 'val': ofproto_v1_0.OFPT_STATS_REPLY}
msg_len = {'buf': '\x00\x64',
'val': ofproto_v1_0.OFP_STATS_MSG_SIZE \
+ ofproto_v1_0.OFP_FLOW_STATS_SIZE}
msg_len_val = ofproto_v1_0.OFP_STATS_MSG_SIZE \
+ ofproto_v1_0.OFP_FLOW_STATS_SIZE
msg_len = {'buf': '\x00\x64', 'val': msg_len_val}
xid = {'buf': '\x94\xc4\xd2\xcd', 'val': 2495926989}
buf = version['buf'] \
@ -4332,20 +4328,20 @@ class TestOFPFlowStatsReply(unittest.TestCase):
# OFP_MATCH_PACK_STR
# '!IH6s6sHBxHBB2xIIHH'...
match = '\x97\x7c\xa6\x1e' \
+ '\x5e\xa0' \
+ '\x70\x17\xdc\x80\x59\x9e' \
+ '\x79\xc6\x56\x87\x92\x28' \
+ '\xb1\x81' \
+ '\xbe' \
+ '\x00' \
+ '\x01\xab' \
+ '\x42' \
+ '\xfe' \
+ '\x00\x00' \
+ '\xa4\x5d\x5c\x42' \
+ '\xa2\x5c\x2e\x05' \
+ '\x5a\x94' \
+ '\x64\xd4'
+ '\x5e\xa0' \
+ '\x70\x17\xdc\x80\x59\x9e' \
+ '\x79\xc6\x56\x87\x92\x28' \
+ '\xb1\x81' \
+ '\xbe' \
+ '\x00' \
+ '\x01\xab' \
+ '\x42' \
+ '\xfe' \
+ '\x00\x00' \
+ '\xa4\x5d\x5c\x42' \
+ '\xa2\x5c\x2e\x05' \
+ '\x5a\x94' \
+ '\x64\xd4'
buf += match
@ -4364,17 +4360,17 @@ class TestOFPFlowStatsReply(unittest.TestCase):
packet_count = {'buf': '\x47\x5c\xc6\x05\x28\xff\x7c\xdb',
'val': 5142202600015232219}
byte_count = {'buf': '\x24\xe9\x4b\xee\xcb\x57\xd9\xc3',
'val': 2659740543924820419}
'val': 2659740543924820419}
buf += duration_sec['buf'] \
+ duration_nsec['buf'] \
+ priority['buf'] \
+ idle_timeout['buf'] \
+ hard_timeout['buf'] \
+ zfill \
+ cookie['buf'] \
+ packet_count['buf'] \
+ byte_count['buf']
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': '\x00\x00', 'val': ofproto_v1_0.OFPAT_OUTPUT}
@ -4467,9 +4463,9 @@ class TestOFPAggregateStatsReply(unittest.TestCase):
def test_parser(self):
version = {'buf': '\x01', 'val': ofproto_v1_0.OFP_VERSION}
msg_type = {'buf': '\x11', 'val': ofproto_v1_0.OFPT_STATS_REPLY}
msg_len = {'buf': '\x00\x4c',
'val': ofproto_v1_0.OFP_STATS_MSG_SIZE \
+ ofproto_v1_0.OFP_AGGREGATE_STATS_REPLY_SIZE}
msg_len_val = ofproto_v1_0.OFP_STATS_MSG_SIZE \
+ ofproto_v1_0.OFP_AGGREGATE_STATS_REPLY_SIZE
msg_len = {'buf': '\x00\x4c', 'val': msg_len_val}
xid = {'buf': '\xc6\xd6\xce\x38', 'val': 3335966264}
buf = version['buf'] \
@ -4564,9 +4560,9 @@ class TestOFPTableStatsReply(unittest.TestCase):
def test_parser(self):
version = {'buf': '\x01', 'val': ofproto_v1_0.OFP_VERSION}
msg_type = {'buf': '\x11', 'val': ofproto_v1_0.OFPT_STATS_REPLY}
msg_len = {'buf': '\x00\x4c',
'val': ofproto_v1_0.OFP_STATS_MSG_SIZE \
+ ofproto_v1_0.OFP_TABLE_STATS_SIZE}
msg_len_val = ofproto_v1_0.OFP_STATS_MSG_SIZE \
+ ofproto_v1_0.OFP_TABLE_STATS_SIZE
msg_len = {'buf': '\x00\x4c', 'val': msg_len_val}
xid = {'buf': '\xd6\xb4\x8d\xe6', 'val': 3602157030}
buf = version['buf'] \
@ -4674,9 +4670,9 @@ class TestOFPPortStatsReply(unittest.TestCase):
def test_parser(self):
version = {'buf': '\x01', 'val': ofproto_v1_0.OFP_VERSION}
msg_type = {'buf': '\x11', 'val': ofproto_v1_0.OFPT_STATS_REPLY}
msg_len = {'buf': '\x00\x74',
'val': ofproto_v1_0.OFP_STATS_MSG_SIZE \
+ ofproto_v1_0.OFP_PORT_STATS_SIZE}
msg_len_val = ofproto_v1_0.OFP_STATS_MSG_SIZE \
+ ofproto_v1_0.OFP_PORT_STATS_SIZE
msg_len = {'buf': '\x00\x74', 'val': msg_len_val}
xid = {'buf': '\xc2\xaf\x3d\xff', 'val': 3266264575}
buf = version['buf'] \
@ -4814,9 +4810,9 @@ class TestOFPQueueStatsReply(unittest.TestCase):
def test_parser(self):
version = {'buf': '\x01', 'val': ofproto_v1_0.OFP_VERSION}
msg_type = {'buf': '\x11', 'val': ofproto_v1_0.OFPT_STATS_REPLY}
msg_len = {'buf': '\x00\x2c',
'val': ofproto_v1_0.OFP_STATS_MSG_SIZE \
+ ofproto_v1_0.OFP_QUEUE_STATS_SIZE}
msg_len_val = ofproto_v1_0.OFP_STATS_MSG_SIZE \
+ ofproto_v1_0.OFP_QUEUE_STATS_SIZE
msg_len = {'buf': '\x00\x2c', 'val': msg_len_val}
xid = {'buf': '\x19\xfc\x28\x6c', 'val': 435955820}
buf = version['buf'] \
@ -5430,9 +5426,9 @@ class TestOFPQueueGetConfigRequest(unittest.TestCase):
eq_(ofproto_v1_0.OFPT_QUEUE_GET_CONFIG_REQUEST, self.c.msg_type)
eq_(0, self.c.xid)
fmt = '!' \
+ ofproto_v1_0.OFP_HEADER_PACK_STR.replace('!', '') \
+ ofproto_v1_0.OFP_QUEUE_GET_CONFIG_REQUEST_PACK_STR.replace('!', '')
a = ofproto_v1_0.OFP_HEADER_PACK_STR.replace('!', '')
b = ofproto_v1_0.OFP_QUEUE_GET_CONFIG_REQUEST_PACK_STR.replace('!', '')
fmt = '!' + a + b
res = struct.unpack(fmt, str(self.c.buf))
eq_(ofproto_v1_0.OFP_VERSION, res[0])

71
ryu/tests/unit/ofproto/test_parser_v12.py
View File

@ -86,11 +86,11 @@ class TestOFPHello(unittest.TestCase):
def test_parser(self):
xid = 2183948390
res = OFPHello.parser(object, \
ofproto_v1_2.OFP_VERSION, \
ofproto_v1_2.OFPT_HELLO, \
ofproto_v1_2.OFP_HEADER_SIZE, \
xid, \
res = OFPHello.parser(object,
ofproto_v1_2.OFP_VERSION,
ofproto_v1_2.OFPT_HELLO,
ofproto_v1_2.OFP_HEADER_SIZE,
xid,
str().zfill(ofproto_v1_2.OFP_HEADER_SIZE))
eq_(ofproto_v1_2.OFP_VERSION, res.version)
@ -380,7 +380,7 @@ class TestOFPPort(unittest.TestCase):
fmt = ofproto_v1_2.OFP_PORT_PACK_STR
buf = pack(fmt, port_no, hw_addr, name, config, state, curr,
advertised, supported, peer, curr_speed, max_speed)
advertised, supported, peer, curr_speed, max_speed)
c = OFPPort(port_no, hw_addr, name, config, state, curr,
advertised, supported, peer, curr_speed, max_speed)
@ -482,7 +482,7 @@ class TestOFPSwitchFeatures(unittest.TestCase):
version = ofproto_v1_2.OFP_VERSION
msg_type = ofproto_v1_2.OFPT_FEATURES_REPLY
msg_len = ofproto_v1_2.OFP_SWITCH_FEATURES_SIZE \
+ ofproto_v1_2.OFP_PORT_SIZE
+ ofproto_v1_2.OFP_PORT_SIZE
xid = 2495926989
fmt = ofproto_v1_2.OFP_HEADER_PACK_STR
@ -1130,7 +1130,7 @@ class TestOFPInstructionActions(unittest.TestCase):
# '!HH4x'...type, len, pad(4)
type_ = ofproto_v1_2.OFPIT_WRITE_ACTIONS
len_ = ofproto_v1_2.OFP_INSTRUCTION_ACTIONS_SIZE \
+ ofproto_v1_2.OFP_ACTION_OUTPUT_SIZE
+ ofproto_v1_2.OFP_ACTION_OUTPUT_SIZE
fmt = ofproto_v1_2.OFP_INSTRUCTION_ACTIONS_PACK_STR
buf = pack(fmt, type_, len_)
@ -1835,7 +1835,7 @@ class TestOFPBucket(unittest.TestCase):
# OFP_BUCKET_PACK_STR
# '!HHII4x'...len, weight, watch_port, watch_group, pad(4)
len_ = ofproto_v1_2.OFP_BUCKET_SIZE \
+ ofproto_v1_2.OFP_ACTION_OUTPUT_SIZE
+ ofproto_v1_2.OFP_ACTION_OUTPUT_SIZE
weight = 4386
watch_port = 6606
watch_group = 3
@ -2010,8 +2010,8 @@ class TestOFPPortMod(unittest.TestCase):
eq_(0, self.c.xid)
fmt = '!' \
+ ofproto_v1_2.OFP_HEADER_PACK_STR.replace('!', '') \
+ ofproto_v1_2.OFP_PORT_MOD_PACK_STR.replace('!', '')
+ ofproto_v1_2.OFP_HEADER_PACK_STR.replace('!', '') \
+ ofproto_v1_2.OFP_PORT_MOD_PACK_STR.replace('!', '')
res = struct.unpack(fmt, str(self.c.buf))
@ -2059,8 +2059,8 @@ class TestOFPTableMod(unittest.TestCase):
eq_(0, self.c.xid)
fmt = '!' \
+ ofproto_v1_2.OFP_HEADER_PACK_STR.replace('!', '') \
+ ofproto_v1_2.OFP_TABLE_MOD_PACK_STR.replace('!', '')
+ ofproto_v1_2.OFP_HEADER_PACK_STR.replace('!', '') \
+ ofproto_v1_2.OFP_TABLE_MOD_PACK_STR.replace('!', '')
res = struct.unpack(fmt, str(self.c.buf))
@ -2321,8 +2321,9 @@ class TestOFPFlowStatsRequest(unittest.TestCase):
eq_(res[0], ofproto_v1_2.OFP_VERSION)
eq_(res[1], ofproto_v1_2.OFPT_STATS_REQUEST)
eq_(res[2], ofproto_v1_2.OFP_STATS_REPLY_SIZE \
+ ofproto_v1_2.OFP_FLOW_STATS_REQUEST_SIZE)
size = ofproto_v1_2.OFP_STATS_REPLY_SIZE \
+ ofproto_v1_2.OFP_FLOW_STATS_REQUEST_SIZE
eq_(res[2], size)
eq_(res[3], 0)
eq_(res[4], ofproto_v1_2.OFPST_FLOW)
eq_(res[5], 0)
@ -2342,7 +2343,7 @@ class TestOFPFlowStats(unittest.TestCase):
# priority, idle_timeoutl, hard_timeout, pad(6),
# cookie, packet_count, byte_count
length = ofproto_v1_2.OFP_FLOW_STATS_SIZE \
+ ofproto_v1_2.OFP_INSTRUCTION_GOTO_TABLE_SIZE
+ ofproto_v1_2.OFP_INSTRUCTION_GOTO_TABLE_SIZE
table_id = 81
duration_sec = 2484712402
duration_nsec = 3999715196
@ -2464,8 +2465,9 @@ class TestOFPAggregateStatsRequest(unittest.TestCase):
eq_(res[0], ofproto_v1_2.OFP_VERSION)
eq_(res[1], ofproto_v1_2.OFPT_STATS_REQUEST)
eq_(res[2], ofproto_v1_2.OFP_STATS_REPLY_SIZE +
ofproto_v1_2.OFP_AGGREGATE_STATS_REQUEST_SIZE)
size = ofproto_v1_2.OFP_STATS_REPLY_SIZE \
+ ofproto_v1_2.OFP_AGGREGATE_STATS_REQUEST_SIZE
eq_(res[2], size)
eq_(res[3], 0)
eq_(res[4], ofproto_v1_2.OFPST_AGGREGATE)
eq_(res[5], 0)
@ -2632,8 +2634,9 @@ class TestOFPPortStatsRequest(unittest.TestCase):
eq_(res[0], ofproto_v1_2.OFP_VERSION)
eq_(res[1], ofproto_v1_2.OFPT_STATS_REQUEST)
eq_(res[2], ofproto_v1_2.OFP_STATS_REQUEST_SIZE \
+ ofproto_v1_2.OFP_PORT_STATS_REQUEST_SIZE)
size = ofproto_v1_2.OFP_STATS_REQUEST_SIZE \
+ ofproto_v1_2.OFP_PORT_STATS_REQUEST_SIZE
eq_(res[2], size)
eq_(res[3], 0)
eq_(res[4], ofproto_v1_2.OFPST_PORT)
eq_(res[5], 0)
@ -2735,8 +2738,9 @@ class TestOFPQueueStatsRequest(unittest.TestCase):
eq_(res[0], ofproto_v1_2.OFP_VERSION)
eq_(res[1], ofproto_v1_2.OFPT_STATS_REQUEST)
eq_(res[2], ofproto_v1_2.OFP_STATS_REQUEST_SIZE \
+ ofproto_v1_2.OFP_QUEUE_STATS_REQUEST_SIZE)
size = ofproto_v1_2.OFP_STATS_REQUEST_SIZE \
+ ofproto_v1_2.OFP_QUEUE_STATS_REQUEST_SIZE
eq_(res[2], size)
eq_(res[3], 0)
eq_(res[4], ofproto_v1_2.OFPST_QUEUE)
eq_(res[5], 0)
@ -2847,8 +2851,9 @@ class TestOFPGroupStatsRequest(unittest.TestCase):
eq_(res[0], ofproto_v1_2.OFP_VERSION)
eq_(res[1], ofproto_v1_2.OFPT_STATS_REQUEST)
eq_(res[2], ofproto_v1_2.OFP_STATS_REQUEST_SIZE \
+ ofproto_v1_2.OFP_GROUP_STATS_REQUEST_SIZE)
size = ofproto_v1_2.OFP_STATS_REQUEST_SIZE \
+ ofproto_v1_2.OFP_GROUP_STATS_REQUEST_SIZE
eq_(res[2], size)
eq_(res[3], 0)
eq_(res[4], ofproto_v1_2.OFPST_GROUP)
eq_(res[5], 0)
@ -2861,7 +2866,7 @@ class TestOFPGroupStats(unittest.TestCase):
# OFP_GROUP_STATS_PACK_STR = '!H2xII4xQQ'
length = ofproto_v1_2.OFP_GROUP_STATS_SIZE \
+ ofproto_v1_2.OFP_BUCKET_COUNTER_SIZE
+ ofproto_v1_2.OFP_BUCKET_COUNTER_SIZE
group_id = 6606
ref_count = 2102
packet_count = 6489108735192644493
@ -2931,8 +2936,8 @@ class TestOFPGroupDescStats(unittest.TestCase):
# OFP_GROUP_DESC_STATS_PACK_STR = '!HBxI'
length = ofproto_v1_2.OFP_GROUP_DESC_STATS_SIZE \
+ ofproto_v1_2.OFP_BUCKET_SIZE \
+ ofproto_v1_2.OFP_ACTION_OUTPUT_SIZE
+ ofproto_v1_2.OFP_BUCKET_SIZE \
+ ofproto_v1_2.OFP_ACTION_OUTPUT_SIZE
type_ = ofproto_v1_2.OFPGT_ALL
group_id = 6606
@ -3122,9 +3127,9 @@ class TestOFPQueueGetConfigRequest(unittest.TestCase):
eq_(ofproto_v1_2.OFPT_QUEUE_GET_CONFIG_REQUEST, self.c.msg_type)
eq_(0, self.c.xid)
fmt = '!' \
+ ofproto_v1_2.OFP_HEADER_PACK_STR.replace('!', '') \
+ ofproto_v1_2.OFP_QUEUE_GET_CONFIG_REQUEST_PACK_STR.replace('!', '')
a = ofproto_v1_2.OFP_HEADER_PACK_STR.replace('!', '')
b = ofproto_v1_2.OFP_QUEUE_GET_CONFIG_REQUEST_PACK_STR.replace('!', '')
fmt = '!' + a + b
res = struct.unpack(fmt, str(self.c.buf))
@ -3178,8 +3183,8 @@ class TestOFPQueueGetConfigReply(unittest.TestCase):
version = ofproto_v1_2.OFP_VERSION
msg_type = ofproto_v1_2.OFPT_QUEUE_GET_CONFIG_REPLY
msg_len = ofproto_v1_2.OFP_QUEUE_GET_CONFIG_REPLY_SIZE \
+ ofproto_v1_2.OFP_PACKET_QUEUE_SIZE \
+ ofproto_v1_2.OFP_QUEUE_PROP_HEADER_SIZE
+ ofproto_v1_2.OFP_PACKET_QUEUE_SIZE \
+ ofproto_v1_2.OFP_QUEUE_PROP_HEADER_SIZE
xid = 2495926989
fmt = ofproto_v1_2.OFP_HEADER_PACK_STR
@ -3206,7 +3211,7 @@ class TestOFPQueueGetConfigReply(unittest.TestCase):
queue_id = 6606
queue_port = 41186
queue_len = ofproto_v1_2.OFP_PACKET_QUEUE_SIZE \
+ ofproto_v1_2.OFP_QUEUE_PROP_HEADER_SIZE
+ ofproto_v1_2.OFP_QUEUE_PROP_HEADER_SIZE
queues = [OFPPacketQueue(queue_id, queue_port, queue_len, properties)]
fmt = ofproto_v1_2.OFP_PACKET_QUEUE_PACK_STR