ryu/build/lib.linux-armv7l-2.7/ryu/tests/unit/packet/test_slow.py

   1 # Copyright (C) 2013 Nippon Telegraph and Telephone Corporation.
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #    http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  12 # implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15
  16 # vim: tabstop=4 shiftwidth=4 softtabstop=4
  17
  18 import copy
  19 import logging
  20 from struct import pack, unpack_from
  21 import unittest
  22
  23 from nose.tools import ok_, eq_, raises
  24 from ryu.ofproto import ether
  25 from ryu.lib.packet.ethernet import ethernet
  26 from ryu.lib.packet.packet import Packet
  27 from ryu.lib import addrconv
  28 from ryu.lib.packet.slow import slow, lacp
  29 from ryu.lib.packet.slow import SLOW_PROTOCOL_MULTICAST
  30 from ryu.lib.packet.slow import SLOW_SUBTYPE_LACP
  31 from ryu.lib.packet.slow import SLOW_SUBTYPE_MARKER
  32
  33 LOG = logging.getLogger(__name__)
  34
  35
  36 class Test_slow(unittest.TestCase):
  37     """ Test case for Slow Protocol
  38     """
  39
  40     def setUp(self):
  41         self.subtype = SLOW_SUBTYPE_LACP
  42         self.version = lacp.LACP_VERSION_NUMBER
  43         self.actor_tag = lacp.LACP_TLV_TYPE_ACTOR
  44         self.actor_length = 20
  45         self.actor_system_priority = 65534
  46         self.actor_system = '00:07:0d:af:f4:54'
  47         self.actor_key = 1
  48         self.actor_port_priority = 65535
  49         self.actor_port = 1
  50         self.actor_state_activity = lacp.LACP_STATE_ACTIVE
  51         self.actor_state_timeout = lacp.LACP_STATE_LONG_TIMEOUT
  52         self.actor_state_aggregation = lacp.LACP_STATE_AGGREGATEABLE
  53         self.actor_state_synchronization = lacp.LACP_STATE_IN_SYNC
  54         self.actor_state_collecting = lacp.LACP_STATE_COLLECTING_ENABLED
  55         self.actor_state_distributing = lacp.LACP_STATE_DISTRIBUTING_ENABLED
  56         self.actor_state_defaulted = lacp.LACP_STATE_OPERATIONAL_PARTNER
  57         self.actor_state_expired = lacp.LACP_STATE_EXPIRED
  58         self.actor_state = (
  59             (self.actor_state_activity << 0) |
  60             (self.actor_state_timeout << 1) |
  61             (self.actor_state_aggregation << 2) |
  62             (self.actor_state_synchronization << 3) |
  63             (self.actor_state_collecting << 4) |
  64             (self.actor_state_distributing << 5) |
  65             (self.actor_state_defaulted << 6) |
  66             (self.actor_state_expired << 7))
  67         self.partner_tag = lacp.LACP_TLV_TYPE_PARTNER
  68         self.partner_length = 20
  69         self.partner_system_priority = 0
  70         self.partner_system = '00:00:00:00:00:00'
  71         self.partner_key = 0
  72         self.partner_port_priority = 0
  73         self.partner_port = 0
  74         self.partner_state_activity = 0
  75         self.partner_state_timeout = lacp.LACP_STATE_SHORT_TIMEOUT
  76         self.partner_state_aggregation = 0
  77         self.partner_state_synchronization = 0
  78         self.partner_state_collecting = 0
  79         self.partner_state_distributing = 0
  80         self.partner_state_defaulted = 0
  81         self.partner_state_expired = 0
  82         self.partner_state = (
  83             (self.partner_state_activity << 0) |
  84             (self.partner_state_timeout << 1) |
  85             (self.partner_state_aggregation << 2) |
  86             (self.partner_state_synchronization << 3) |
  87             (self.partner_state_collecting << 4) |
  88             (self.partner_state_distributing << 5) |
  89             (self.partner_state_defaulted << 6) |
  90             (self.partner_state_expired << 7))
  91         self.collector_tag = lacp.LACP_TLV_TYPE_COLLECTOR
  92         self.collector_length = 16
  93         self.collector_max_delay = 0
  94         self.terminator_tag = lacp.LACP_TLV_TYPE_TERMINATOR
  95         self.terminator_length = 0
  96
  97         self.head_fmt = lacp._HLEN_PACK_STR
  98         self.head_len = lacp._HLEN_PACK_LEN
  99         self.act_fmt = lacp._ACTPRT_INFO_PACK_STR
 100         self.act_len = lacp._ACTPRT_INFO_PACK_LEN
 101         self.prt_fmt = lacp._ACTPRT_INFO_PACK_STR
 102         self.prt_len = lacp._ACTPRT_INFO_PACK_LEN
 103         self.col_fmt = lacp._COL_INFO_PACK_STR
 104         self.col_len = lacp._COL_INFO_PACK_LEN
 105         self.trm_fmt = lacp._TRM_PACK_STR
 106         self.trm_len = lacp._TRM_PACK_LEN
 107         self.length = lacp._ALL_PACK_LEN
 108
 109         self.head_buf = pack(self.head_fmt,
 110                              self.subtype,
 111                              self.version)
 112         self.act_buf = pack(self.act_fmt,
 113                             self.actor_tag,
 114                             self.actor_length,
 115                             self.actor_system_priority,
 116                             addrconv.mac.text_to_bin(self.actor_system),
 117                             self.actor_key,
 118                             self.actor_port_priority,
 119                             self.actor_port,
 120                             self.actor_state)
 121         self.prt_buf = pack(self.prt_fmt,
 122                             self.partner_tag,
 123                             self.partner_length,
 124                             self.partner_system_priority,
 125                             addrconv.mac.text_to_bin(self.partner_system),
 126                             self.partner_key,
 127                             self.partner_port_priority,
 128                             self.partner_port,
 129                             self.partner_state)
 130         self.col_buf = pack(self.col_fmt,
 131                             self.collector_tag,
 132                             self.collector_length,
 133                             self.collector_max_delay)
 134         self.trm_buf = pack(self.trm_fmt,
 135                             self.terminator_tag,
 136                             self.terminator_length)
 137
 138         self.buf = self.head_buf + self.act_buf + self.prt_buf + \
 139             self.col_buf + self.trm_buf
 140
 141     def tearDown(self):
 142         pass
 143
 144     def test_parser(self):
 145         slow.parser(self.buf)
 146
 147     def test_not_implemented_subtype(self):
 148         not_implemented_buf = pack(
 149             slow._PACK_STR, SLOW_SUBTYPE_MARKER) + self.buf[1:]
 150         (instance, nexttype, last) = slow.parser(not_implemented_buf)
 151         assert instance is None
 152         assert nexttype is None
 153         assert last is not None
 154
 155     def test_invalid_subtype(self):
 156         invalid_buf = b'\xff' + self.buf[1:]
 157         (instance, nexttype, last) = slow.parser(invalid_buf)
 158         assert instance is None
 159         assert nexttype is None
 160         assert last is not None
 161
 162
 163 class Test_lacp(unittest.TestCase):
 164     """ Test case for lacp
 165     """
 166
 167     def setUp(self):
 168         self.subtype = SLOW_SUBTYPE_LACP
 169         self.version = lacp.LACP_VERSION_NUMBER
 170         self.actor_tag = lacp.LACP_TLV_TYPE_ACTOR
 171         self.actor_length = 20
 172         self.actor_system_priority = 65534
 173         self.actor_system = '00:07:0d:af:f4:54'
 174         self.actor_key = 1
 175         self.actor_port_priority = 65535
 176         self.actor_port = 1
 177         self.actor_state_activity = lacp.LACP_STATE_ACTIVE
 178         self.actor_state_timeout = lacp.LACP_STATE_LONG_TIMEOUT
 179         self.actor_state_aggregation = lacp.LACP_STATE_AGGREGATEABLE
 180         self.actor_state_synchronization = lacp.LACP_STATE_IN_SYNC
 181         self.actor_state_collecting = lacp.LACP_STATE_COLLECTING_ENABLED
 182         self.actor_state_distributing = lacp.LACP_STATE_DISTRIBUTING_ENABLED
 183         self.actor_state_defaulted = lacp.LACP_STATE_OPERATIONAL_PARTNER
 184         self.actor_state_expired = lacp.LACP_STATE_EXPIRED
 185         self.actor_state = (
 186             (self.actor_state_activity << 0) |
 187             (self.actor_state_timeout << 1) |
 188             (self.actor_state_aggregation << 2) |
 189             (self.actor_state_synchronization << 3) |
 190             (self.actor_state_collecting << 4) |
 191             (self.actor_state_distributing << 5) |
 192             (self.actor_state_defaulted << 6) |
 193             (self.actor_state_expired << 7))
 194         self.partner_tag = lacp.LACP_TLV_TYPE_PARTNER
 195         self.partner_length = 20
 196         self.partner_system_priority = 0
 197         self.partner_system = '00:00:00:00:00:00'
 198         self.partner_key = 0
 199         self.partner_port_priority = 0
 200         self.partner_port = 0
 201         self.partner_state_activity = 0
 202         self.partner_state_timeout = lacp.LACP_STATE_SHORT_TIMEOUT
 203         self.partner_state_aggregation = 0
 204         self.partner_state_synchronization = 0
 205         self.partner_state_collecting = 0
 206         self.partner_state_distributing = 0
 207         self.partner_state_defaulted = 0
 208         self.partner_state_expired = 0
 209         self.partner_state = (
 210             (self.partner_state_activity << 0) |
 211             (self.partner_state_timeout << 1) |
 212             (self.partner_state_aggregation << 2) |
 213             (self.partner_state_synchronization << 3) |
 214             (self.partner_state_collecting << 4) |
 215             (self.partner_state_distributing << 5) |
 216             (self.partner_state_defaulted << 6) |
 217             (self.partner_state_expired << 7))
 218         self.collector_tag = lacp.LACP_TLV_TYPE_COLLECTOR
 219         self.collector_length = 16
 220         self.collector_max_delay = 0
 221         self.terminator_tag = lacp.LACP_TLV_TYPE_TERMINATOR
 222         self.terminator_length = 0
 223
 224         self.head_fmt = lacp._HLEN_PACK_STR
 225         self.head_len = lacp._HLEN_PACK_LEN
 226         self.act_fmt = lacp._ACTPRT_INFO_PACK_STR
 227         self.act_len = lacp._ACTPRT_INFO_PACK_LEN
 228         self.prt_fmt = lacp._ACTPRT_INFO_PACK_STR
 229         self.prt_len = lacp._ACTPRT_INFO_PACK_LEN
 230         self.col_fmt = lacp._COL_INFO_PACK_STR
 231         self.col_len = lacp._COL_INFO_PACK_LEN
 232         self.trm_fmt = lacp._TRM_PACK_STR
 233         self.trm_len = lacp._TRM_PACK_LEN
 234         self.length = lacp._ALL_PACK_LEN
 235
 236         self.head_buf = pack(self.head_fmt,
 237                              self.subtype,
 238                              self.version)
 239         self.act_buf = pack(self.act_fmt,
 240                             self.actor_tag,
 241                             self.actor_length,
 242                             self.actor_system_priority,
 243                             addrconv.mac.text_to_bin(self.actor_system),
 244                             self.actor_key,
 245                             self.actor_port_priority,
 246                             self.actor_port,
 247                             self.actor_state)
 248         self.prt_buf = pack(self.prt_fmt,
 249                             self.partner_tag,
 250                             self.partner_length,
 251                             self.partner_system_priority,
 252                             addrconv.mac.text_to_bin(self.partner_system),
 253                             self.partner_key,
 254                             self.partner_port_priority,
 255                             self.partner_port,
 256                             self.partner_state)
 257         self.col_buf = pack(self.col_fmt,
 258                             self.collector_tag,
 259                             self.collector_length,
 260                             self.collector_max_delay)
 261         self.trm_buf = pack(self.trm_fmt,
 262                             self.terminator_tag,
 263                             self.terminator_length)
 264
 265         self.buf = self.head_buf + self.act_buf + self.prt_buf + \
 266             self.col_buf + self.trm_buf
 267
 268         self.l = lacp(self.version,
 269                       self.actor_system_priority,
 270                       self.actor_system,
 271                       self.actor_key,
 272                       self.actor_port_priority,
 273                       self.actor_port,
 274                       self.actor_state_activity,
 275                       self.actor_state_timeout,
 276                       self.actor_state_aggregation,
 277                       self.actor_state_synchronization,
 278                       self.actor_state_collecting,
 279                       self.actor_state_distributing,
 280                       self.actor_state_defaulted,
 281                       self.actor_state_expired,
 282                       self.partner_system_priority,
 283                       self.partner_system,
 284                       self.partner_key,
 285                       self.partner_port_priority,
 286                       self.partner_port,
 287                       self.partner_state_activity,
 288                       self.partner_state_timeout,
 289                       self.partner_state_aggregation,
 290                       self.partner_state_synchronization,
 291                       self.partner_state_collecting,
 292                       self.partner_state_distributing,
 293                       self.partner_state_defaulted,
 294                       self.partner_state_expired,
 295                       self.collector_max_delay)
 296
 297     def tearDown(self):
 298         pass
 299
 300     def find_protocol(self, pkt, name):
 301         for p in pkt.protocols:
 302             if p.protocol_name == name:
 303                 return p
 304
 305     def test_init(self):
 306         eq_(self.subtype, self.l._subtype)
 307         eq_(self.version, self.l.version)
 308         eq_(self.actor_tag, self.l._actor_tag)
 309         eq_(self.actor_length, self.l._actor_length)
 310         eq_(self.actor_system_priority, self.l.actor_system_priority)
 311         eq_(self.actor_system, self.l.actor_system)
 312         eq_(self.actor_key, self.l.actor_key)
 313         eq_(self.actor_port_priority, self.l.actor_port_priority)
 314         eq_(self.actor_port, self.l.actor_port)
 315         eq_(self.actor_state_activity, self.l.actor_state_activity)
 316         eq_(self.actor_state_timeout, self.l.actor_state_timeout)
 317         eq_(self.actor_state_aggregation,
 318             self.l.actor_state_aggregation)
 319         eq_(self.actor_state_synchronization,
 320             self.l.actor_state_synchronization)
 321         eq_(self.actor_state_collecting,
 322             self.l.actor_state_collecting)
 323         eq_(self.actor_state_distributing,
 324             self.l.actor_state_distributing)
 325         eq_(self.actor_state_defaulted, self.l.actor_state_defaulted)
 326         eq_(self.actor_state_expired, self.l.actor_state_expired)
 327         eq_(self.actor_state, self.l._actor_state)
 328         eq_(self.partner_tag, self.l._partner_tag)
 329         eq_(self.partner_length, self.l._partner_length)
 330         eq_(self.partner_system_priority,
 331             self.l.partner_system_priority)
 332         eq_(self.partner_system, self.l.partner_system)
 333         eq_(self.partner_key, self.l.partner_key)
 334         eq_(self.partner_port_priority, self.l.partner_port_priority)
 335         eq_(self.partner_port, self.l.partner_port)
 336         eq_(self.partner_state_activity, self.l.partner_state_activity)
 337         eq_(self.partner_state_timeout, self.l.partner_state_timeout)
 338         eq_(self.partner_state_aggregation,
 339             self.l.partner_state_aggregation)
 340         eq_(self.partner_state_synchronization,
 341             self.l.partner_state_synchronization)
 342         eq_(self.partner_state_collecting,
 343             self.l.partner_state_collecting)
 344         eq_(self.partner_state_distributing,
 345             self.l.partner_state_distributing)
 346         eq_(self.partner_state_defaulted,
 347             self.l.partner_state_defaulted)
 348         eq_(self.partner_state_expired, self.l.partner_state_expired)
 349         eq_(self.partner_state, self.l._partner_state)
 350         eq_(self.collector_tag, self.l._collector_tag)
 351         eq_(self.collector_length, self.l._collector_length)
 352         eq_(self.collector_max_delay, self.l.collector_max_delay)
 353         eq_(self.terminator_tag, self.l._terminator_tag)
 354         eq_(self.terminator_length, self.l._terminator_length)
 355
 356     def test_parser(self):
 357         _res = self.l.parser(self.buf)
 358         if type(_res) is tuple:
 359             res = _res[0]
 360         else:
 361             res = _res
 362
 363         eq_(res._subtype, self.subtype)
 364         eq_(res.version, self.version)
 365         eq_(res._actor_tag, self.actor_tag)
 366         eq_(res._actor_length, self.actor_length)
 367         eq_(res.actor_system_priority, self.actor_system_priority)
 368         eq_(res.actor_system, self.actor_system)
 369         eq_(res.actor_key, self.actor_key)
 370         eq_(res.actor_port_priority, self.actor_port_priority)
 371         eq_(res.actor_port, self.actor_port)
 372         eq_(res.actor_state_activity, self.actor_state_activity)
 373         eq_(res.actor_state_timeout, self.actor_state_timeout)
 374         eq_(res.actor_state_aggregation, self.actor_state_aggregation)
 375         eq_(res.actor_state_synchronization,
 376             self.actor_state_synchronization)
 377         eq_(res.actor_state_collecting, self.actor_state_collecting)
 378         eq_(res.actor_state_distributing, self.actor_state_distributing)
 379         eq_(res.actor_state_defaulted, self.actor_state_defaulted)
 380         eq_(res.actor_state_expired, self.actor_state_expired)
 381         eq_(res._actor_state, self.actor_state)
 382         eq_(res._partner_tag, self.partner_tag)
 383         eq_(res._partner_length, self.partner_length)
 384         eq_(res.partner_system_priority, self.partner_system_priority)
 385         eq_(res.partner_system, self.partner_system)
 386         eq_(res.partner_key, self.partner_key)
 387         eq_(res.partner_port_priority, self.partner_port_priority)
 388         eq_(res.partner_port, self.partner_port)
 389         eq_(res.partner_state_activity, self.partner_state_activity)
 390         eq_(res.partner_state_timeout, self.partner_state_timeout)
 391         eq_(res.partner_state_aggregation,
 392             self.partner_state_aggregation)
 393         eq_(res.partner_state_synchronization,
 394             self.partner_state_synchronization)
 395         eq_(res.partner_state_collecting, self.partner_state_collecting)
 396         eq_(res.partner_state_distributing,
 397             self.partner_state_distributing)
 398         eq_(res.partner_state_defaulted, self.partner_state_defaulted)
 399         eq_(res.partner_state_expired, self.partner_state_expired)
 400         eq_(res._partner_state, self.partner_state)
 401         eq_(res._collector_tag, self.collector_tag)
 402         eq_(res._collector_length, self.collector_length)
 403         eq_(res.collector_max_delay, self.collector_max_delay)
 404         eq_(res._terminator_tag, self.terminator_tag)
 405         eq_(res._terminator_length, self.terminator_length)
 406
 407     def test_serialize(self):
 408         data = bytearray()
 409         prev = None
 410         buf = self.l.serialize(data, prev)
 411
 412         offset = 0
 413         head_res = unpack_from(self.head_fmt, buf, offset)
 414         offset += self.head_len
 415         act_res = unpack_from(self.act_fmt, buf, offset)
 416         offset += self.act_len
 417         prt_res = unpack_from(self.prt_fmt, buf, offset)
 418         offset += self.prt_len
 419         col_res = unpack_from(self.col_fmt, buf, offset)
 420         offset += self.col_len
 421         trm_res = unpack_from(self.trm_fmt, buf, offset)
 422
 423         eq_(head_res[0], self.subtype)
 424         eq_(head_res[1], self.version)
 425
 426         eq_(act_res[0], self.actor_tag)
 427         eq_(act_res[1], self.actor_length)
 428         eq_(act_res[2], self.actor_system_priority)
 429         eq_(act_res[3], addrconv.mac.text_to_bin(self.actor_system))
 430         eq_(act_res[4], self.actor_key)
 431         eq_(act_res[5], self.actor_port_priority)
 432         eq_(act_res[6], self.actor_port)
 433         eq_(act_res[7], self.actor_state)
 434
 435         eq_(prt_res[0], self.partner_tag)
 436         eq_(prt_res[1], self.partner_length)
 437         eq_(prt_res[2], self.partner_system_priority)
 438         eq_(prt_res[3], addrconv.mac.text_to_bin(self.partner_system))
 439         eq_(prt_res[4], self.partner_key)
 440         eq_(prt_res[5], self.partner_port_priority)
 441         eq_(prt_res[6], self.partner_port)
 442         eq_(prt_res[7], self.partner_state)
 443
 444         eq_(col_res[0], self.collector_tag)
 445         eq_(col_res[1], self.collector_length)
 446         eq_(col_res[2], self.collector_max_delay)
 447
 448         eq_(trm_res[0], self.terminator_tag)
 449         eq_(trm_res[1], self.terminator_length)
 450
 451     def _build_lacp(self):
 452         ethertype = ether.ETH_TYPE_SLOW
 453         dst = SLOW_PROTOCOL_MULTICAST
 454         e = ethernet(dst, self.actor_system, ethertype)
 455         p = Packet()
 456
 457         p.add_protocol(e)
 458         p.add_protocol(self.l)
 459         p.serialize()
 460         return p
 461
 462     def test_build_lacp(self):
 463         p = self._build_lacp()
 464
 465         e = self.find_protocol(p, "ethernet")
 466         ok_(e)
 467         eq_(e.ethertype, ether.ETH_TYPE_SLOW)
 468
 469         l = self.find_protocol(p, "lacp")
 470         ok_(l)
 471
 472         eq_(l._subtype, self.subtype)
 473         eq_(l.version, self.version)
 474         eq_(l._actor_tag, self.actor_tag)
 475         eq_(l._actor_length, self.actor_length)
 476         eq_(l.actor_system_priority, self.actor_system_priority)
 477         eq_(l.actor_system, self.actor_system)
 478         eq_(l.actor_key, self.actor_key)
 479         eq_(l.actor_port_priority, self.actor_port_priority)
 480         eq_(l.actor_port, self.actor_port)
 481         eq_(l.actor_state_activity, self.actor_state_activity)
 482         eq_(l.actor_state_timeout, self.actor_state_timeout)
 483         eq_(l.actor_state_aggregation, self.actor_state_aggregation)
 484         eq_(l.actor_state_synchronization,
 485             self.actor_state_synchronization)
 486         eq_(l.actor_state_collecting, self.actor_state_collecting)
 487         eq_(l.actor_state_distributing, self.actor_state_distributing)
 488         eq_(l.actor_state_defaulted, self.actor_state_defaulted)
 489         eq_(l.actor_state_expired, self.actor_state_expired)
 490         eq_(l._actor_state, self.actor_state)
 491         eq_(l._partner_tag, self.partner_tag)
 492         eq_(l._partner_length, self.partner_length)
 493         eq_(l.partner_system_priority, self.partner_system_priority)
 494         eq_(l.partner_system, self.partner_system)
 495         eq_(l.partner_key, self.partner_key)
 496         eq_(l.partner_port_priority, self.partner_port_priority)
 497         eq_(l.partner_port, self.partner_port)
 498         eq_(l.partner_state_activity, self.partner_state_activity)
 499         eq_(l.partner_state_timeout, self.partner_state_timeout)
 500         eq_(l.partner_state_aggregation, self.partner_state_aggregation)
 501         eq_(l.partner_state_synchronization,
 502             self.partner_state_synchronization)
 503         eq_(l.partner_state_collecting, self.partner_state_collecting)
 504         eq_(l.partner_state_distributing,
 505             self.partner_state_distributing)
 506         eq_(l.partner_state_defaulted, self.partner_state_defaulted)
 507         eq_(l.partner_state_expired, self.partner_state_expired)
 508         eq_(l._partner_state, self.partner_state)
 509         eq_(l._collector_tag, self.collector_tag)
 510         eq_(l._collector_length, self.collector_length)
 511         eq_(l.collector_max_delay, self.collector_max_delay)
 512         eq_(l._terminator_tag, self.terminator_tag)
 513         eq_(l._terminator_length, self.terminator_length)
 514
 515     @raises(Exception)
 516     def test_malformed_lacp(self):
 517         m_short_buf = self.buf[1:self.length]
 518         slow.parser(m_short_buf)
 519
 520     @raises(Exception)
 521     def test_invalid_subtype(self):
 522         invalid_lacv = copy.deepcopy(self.l)
 523         invalid_lacv.subtype = 0xff
 524         invalid_buf = invalid_lacv.serialize()
 525         slow.parser(invalid_buf)
 526
 527     @raises(Exception)
 528     def test_invalid_version(self):
 529         invalid_lacv = copy.deepcopy(self.l)
 530         invalid_lacv.version = 0xff
 531         invalid_buf = invalid_lacv.serialize()
 532         slow.parser(invalid_buf)
 533
 534     @raises(Exception)
 535     def test_invalid_actor_tag(self):
 536         invalid_lacv = copy.deepcopy(self.l)
 537         invalid_lacv.actor_tag = 0x04
 538         invalid_buf = invalid_lacv.serialize()
 539         slow.parser(invalid_buf)
 540
 541     @raises(Exception)
 542     def test_invalid_actor_length(self):
 543         invalid_lacv = copy.deepcopy(self.l)
 544         invalid_lacv.actor_length = 50
 545         invalid_buf = invalid_lacv.serialize()
 546         slow.parser(invalid_buf)
 547
 548     @raises(Exception)
 549     def test_invalid_partner_tag(self):
 550         invalid_lacv = copy.deepcopy(self.l)
 551         invalid_lacv.partner_tag = 0x01
 552         invalid_buf = invalid_lacv.serialize()
 553         slow.parser(invalid_buf)
 554
 555     @raises(Exception)
 556     def test_invalid_partner_length(self):
 557         invalid_lacv = copy.deepcopy(self.l)
 558         invalid_lacv.partner_length = 0
 559         invalid_buf = invalid_lacv.serialize()
 560         slow.parser(invalid_buf)
 561
 562     @raises(Exception)
 563     def test_invalid_collector_tag(self):
 564         invalid_lacv = copy.deepcopy(self.l)
 565         invalid_lacv.collector_tag = 0x00
 566         invalid_buf = invalid_lacv.serialize()
 567         slow.parser(invalid_buf)
 568
 569     @raises(Exception)
 570     def test_invalid_collector_length(self):
 571         invalid_lacv = copy.deepcopy(self.l)
 572         invalid_lacv.collector_length = 20
 573         invalid_buf = invalid_lacv.serialize()
 574         slow.parser(invalid_buf)
 575
 576     @raises(Exception)
 577     def test_invalid_terminator_tag(self):
 578         invalid_lacv = copy.deepcopy(self.l)
 579         invalid_lacv.terminator_tag = 0x04
 580         invalid_buf = invalid_lacv.serialize()
 581         slow.parser(invalid_buf)
 582
 583     @raises(Exception)
 584     def test_invalid_terminator_length(self):
 585         invalid_lacv = copy.deepcopy(self.l)
 586         invalid_lacv.terminator_length = self.trm_len
 587         invalid_buf = invalid_lacv.serialize()
 588         slow.parser(invalid_buf)
 589
 590     @raises(Exception)
 591     def test_invalid_actor_state_activity(self):
 592         l = lacp(self.version,
 593                  self.actor_system_priority,
 594                  self.actor_system,
 595                  self.actor_key,
 596                  self.actor_port_priority,
 597                  self.actor_port,
 598                  2,
 599                  self.actor_state_timeout,
 600                  self.actor_state_aggregation,
 601                  self.actor_state_synchronization,
 602                  self.actor_state_collecting,
 603                  self.actor_state_distributing,
 604                  self.actor_state_defaulted,
 605                  self.actor_state_expired,
 606                  self.partner_system_priority,
 607                  self.partner_system,
 608                  self.partner_key,
 609                  self.partner_port_priority,
 610                  self.partner_port,
 611                  self.partner_state_activity,
 612                  self.partner_state_timeout,
 613                  self.partner_state_aggregation,
 614                  self.partner_state_synchronization,
 615                  self.partner_state_collecting,
 616                  self.partner_state_distributing,
 617                  self.partner_state_defaulted,
 618                  self.partner_state_expired,
 619                  self.collector_max_delay)
 620         l.serialize()
 621
 622     @raises(Exception)
 623     def test_invalid_actor_state_timeout(self):
 624         l = lacp(self.version,
 625                  self.actor_system_priority,
 626                  self.actor_system,
 627                  self.actor_key,
 628                  self.actor_port_priority,
 629                  self.actor_port,
 630                  self.actor_state_activity,
 631                  2,
 632                  self.actor_state_aggregation,
 633                  self.actor_state_synchronization,
 634                  self.actor_state_collecting,
 635                  self.actor_state_distributing,
 636                  self.actor_state_defaulted,
 637                  self.actor_state_expired,
 638                  self.partner_system_priority,
 639                  self.partner_system,
 640                  self.partner_key,
 641                  self.partner_port_priority,
 642                  self.partner_port,
 643                  self.partner_state_activity,
 644                  self.partner_state_timeout,
 645                  self.partner_state_aggregation,
 646                  self.partner_state_synchronization,
 647                  self.partner_state_collecting,
 648                  self.partner_state_distributing,
 649                  self.partner_state_defaulted,
 650                  self.partner_state_expired,
 651                  self.collector_max_delay)
 652         l.serialize()
 653
 654     @raises(Exception)
 655     def test_invalid_actor_state_aggregation(self):
 656         l = lacp(self.version,
 657                  self.actor_system_priority,
 658                  self.actor_system,
 659                  self.actor_key,
 660                  self.actor_port_priority,
 661                  self.actor_port,
 662                  self.actor_state_activity,
 663                  self.actor_state_timeout,
 664                  2,
 665                  self.actor_state_synchronization,
 666                  self.actor_state_collecting,
 667                  self.actor_state_distributing,
 668                  self.actor_state_defaulted,
 669                  self.actor_state_expired,
 670                  self.partner_system_priority,
 671                  self.partner_system,
 672                  self.partner_key,
 673                  self.partner_port_priority,
 674                  self.partner_port,
 675                  self.partner_state_activity,
 676                  self.partner_state_timeout,
 677                  self.partner_state_aggregation,
 678                  self.partner_state_synchronization,
 679                  self.partner_state_collecting,
 680                  self.partner_state_distributing,
 681                  self.partner_state_defaulted,
 682                  self.partner_state_expired,
 683                  self.collector_max_delay)
 684         l.serialize()
 685
 686     @raises(Exception)
 687     def test_invalid_actor_state_synchronization(self):
 688         l = lacp(self.version,
 689                  self.actor_system_priority,
 690                  self.actor_system,
 691                  self.actor_key,
 692                  self.actor_port_priority,
 693                  self.actor_port,
 694                  self.actor_state_activity,
 695                  self.actor_state_timeout,
 696                  self.actor_state_aggregation,
 697                  2,
 698                  self.actor_state_collecting,
 699                  self.actor_state_distributing,
 700                  self.actor_state_defaulted,
 701                  self.actor_state_expired,
 702                  self.partner_system_priority,
 703                  self.partner_system,
 704                  self.partner_key,
 705                  self.partner_port_priority,
 706                  self.partner_port,
 707                  self.partner_state_activity,
 708                  self.partner_state_timeout,
 709                  self.partner_state_aggregation,
 710                  self.partner_state_synchronization,
 711                  self.partner_state_collecting,
 712                  self.partner_state_distributing,
 713                  self.partner_state_defaulted,
 714                  self.partner_state_expired,
 715                  self.collector_max_delay)
 716         l.serialize()
 717
 718     @raises(Exception)
 719     def test_invalid_actor_state_collecting(self):
 720         l = lacp(self.version,
 721                  self.actor_system_priority,
 722                  self.actor_system,
 723                  self.actor_key,
 724                  self.actor_port_priority,
 725                  self.actor_port,
 726                  self.actor_state_activity,
 727                  self.actor_state_timeout,
 728                  self.actor_state_aggregation,
 729                  self.actor_state_synchronization,
 730                  2,
 731                  self.actor_state_distributing,
 732                  self.actor_state_defaulted,
 733                  self.actor_state_expired,
 734                  self.partner_system_priority,
 735                  self.partner_system,
 736                  self.partner_key,
 737                  self.partner_port_priority,
 738                  self.partner_port,
 739                  self.partner_state_activity,
 740                  self.partner_state_timeout,
 741                  self.partner_state_aggregation,
 742                  self.partner_state_synchronization,
 743                  self.partner_state_collecting,
 744                  self.partner_state_distributing,
 745                  self.partner_state_defaulted,
 746                  self.partner_state_expired,
 747                  self.collector_max_delay)
 748         l.serialize()
 749
 750     @raises(Exception)
 751     def test_invalid_actor_state_distributing(self):
 752         l = lacp(self.version,
 753                  self.actor_system_priority,
 754                  self.actor_system,
 755                  self.actor_key,
 756                  self.actor_port_priority,
 757                  self.actor_port,
 758                  self.actor_state_activity,
 759                  self.actor_state_timeout,
 760                  self.actor_state_aggregation,
 761                  self.actor_state_synchronization,
 762                  self.actor_state_collecting,
 763                  2,
 764                  self.actor_state_defaulted,
 765                  self.actor_state_expired,
 766                  self.partner_system_priority,
 767                  self.partner_system,
 768                  self.partner_key,
 769                  self.partner_port_priority,
 770                  self.partner_port,
 771                  self.partner_state_activity,
 772                  self.partner_state_timeout,
 773                  self.partner_state_aggregation,
 774                  self.partner_state_synchronization,
 775                  self.partner_state_collecting,
 776                  self.partner_state_distributing,
 777                  self.partner_state_defaulted,
 778                  self.partner_state_expired,
 779                  self.collector_max_delay)
 780         l.serialize()
 781
 782     @raises(Exception)
 783     def test_invalid_actor_state_defaulted(self):
 784         l = lacp(self.version,
 785                  self.actor_system_priority,
 786                  self.actor_system,
 787                  self.actor_key,
 788                  self.actor_port_priority,
 789                  self.actor_port,
 790                  self.actor_state_activity,
 791                  self.actor_state_timeout,
 792                  self.actor_state_aggregation,
 793                  self.actor_state_synchronization,
 794                  self.actor_state_collecting,
 795                  self.actor_state_distributing,
 796                  2,
 797                  self.actor_state_expired,
 798                  self.partner_system_priority,
 799                  self.partner_system,
 800                  self.partner_key,
 801                  self.partner_port_priority,
 802                  self.partner_port,
 803                  self.partner_state_activity,
 804                  self.partner_state_timeout,
 805                  self.partner_state_aggregation,
 806                  self.partner_state_synchronization,
 807                  self.partner_state_collecting,
 808                  self.partner_state_distributing,
 809                  self.partner_state_defaulted,
 810                  self.partner_state_expired,
 811                  self.collector_max_delay)
 812         l.serialize()
 813
 814     @raises(Exception)
 815     def test_invalid_actor_state_expired(self):
 816         l = lacp(self.version,
 817                  self.actor_system_priority,
 818                  self.actor_system,
 819                  self.actor_key,
 820                  self.actor_port_priority,
 821                  self.actor_port,
 822                  self.actor_state_activity,
 823                  self.actor_state_timeout,
 824                  self.actor_state_aggregation,
 825                  self.actor_state_synchronization,
 826                  self.actor_state_collecting,
 827                  self.actor_state_distributing,
 828                  self.actor_state_defaulted,
 829                  2,
 830                  self.partner_system_priority,
 831                  self.partner_system,
 832                  self.partner_key,
 833                  self.partner_port_priority,
 834                  self.partner_port,
 835                  self.partner_state_activity,
 836                  self.partner_state_timeout,
 837                  self.partner_state_aggregation,
 838                  self.partner_state_synchronization,
 839                  self.partner_state_collecting,
 840                  self.partner_state_distributing,
 841                  self.partner_state_defaulted,
 842                  self.partner_state_expired,
 843                  self.collector_max_delay)
 844         l.serialize()
 845
 846     @raises(Exception)
 847     def test_invalid_partner_state_activity(self):
 848         l = lacp(self.version,
 849                  self.actor_system_priority,
 850                  self.actor_system,
 851                  self.actor_key,
 852                  self.actor_port_priority,
 853                  self.actor_port,
 854                  self.actor_state_activity,
 855                  self.actor_state_timeout,
 856                  self.actor_state_aggregation,
 857                  self.actor_state_synchronization,
 858                  self.actor_state_collecting,
 859                  self.actor_state_distributing,
 860                  self.actor_state_defaulted,
 861                  self.actor_state_expired,
 862                  self.partner_system_priority,
 863                  self.partner_system,
 864                  self.partner_key,
 865                  self.partner_port_priority,
 866                  self.partner_port,
 867                  -1,
 868                  self.partner_state_timeout,
 869                  self.partner_state_aggregation,
 870                  self.partner_state_synchronization,
 871                  self.partner_state_collecting,
 872                  self.partner_state_distributing,
 873                  self.partner_state_defaulted,
 874                  self.partner_state_expired,
 875                  self.collector_max_delay)
 876         l.serialize()
 877
 878     @raises(Exception)
 879     def test_invalid_partner_state_timeout(self):
 880         l = lacp(self.version,
 881                  self.actor_system_priority,
 882                  self.actor_system,
 883                  self.actor_key,
 884                  self.actor_port_priority,
 885                  self.actor_port,
 886                  self.actor_state_activity,
 887                  self.actor_state_timeout,
 888                  self.actor_state_aggregation,
 889                  self.actor_state_synchronization,
 890                  self.actor_state_collecting,
 891                  self.actor_state_distributing,
 892                  self.actor_state_defaulted,
 893                  self.actor_state_expired,
 894                  self.partner_system_priority,
 895                  self.partner_system,
 896                  self.partner_key,
 897                  self.partner_port_priority,
 898                  self.partner_port,
 899                  self.partner_state_activity,
 900                  -1,
 901                  self.partner_state_aggregation,
 902                  self.partner_state_synchronization,
 903                  self.partner_state_collecting,
 904                  self.partner_state_distributing,
 905                  self.partner_state_defaulted,
 906                  self.partner_state_expired,
 907                  self.collector_max_delay)
 908         l.serialize()
 909
 910     @raises(Exception)
 911     def test_invalid_partner_state_aggregation(self):
 912         l = lacp(self.version,
 913                  self.actor_system_priority,
 914                  self.actor_system,
 915                  self.actor_key,
 916                  self.actor_port_priority,
 917                  self.actor_port,
 918                  self.actor_state_activity,
 919                  self.actor_state_timeout,
 920                  self.actor_state_aggregation,
 921                  self.actor_state_synchronization,
 922                  self.actor_state_collecting,
 923                  self.actor_state_distributing,
 924                  self.actor_state_defaulted,
 925                  self.actor_state_expired,
 926                  self.partner_system_priority,
 927                  self.partner_system,
 928                  self.partner_key,
 929                  self.partner_port_priority,
 930                  self.partner_port,
 931                  self.partner_state_activity,
 932                  self.partner_state_timeout,
 933                  -1,
 934                  self.partner_state_synchronization,
 935                  self.partner_state_collecting,
 936                  self.partner_state_distributing,
 937                  self.partner_state_defaulted,
 938                  self.partner_state_expired,
 939                  self.collector_max_delay)
 940         l.serialize()
 941
 942     @raises(Exception)
 943     def test_invalid_partner_state_synchronization(self):
 944         l = lacp(self.version,
 945                  self.actor_system_priority,
 946                  self.actor_system,
 947                  self.actor_key,
 948                  self.actor_port_priority,
 949                  self.actor_port,
 950                  self.actor_state_activity,
 951                  self.actor_state_timeout,
 952                  self.actor_state_aggregation,
 953                  self.actor_state_synchronization,
 954                  self.actor_state_collecting,
 955                  self.actor_state_distributing,
 956                  self.actor_state_defaulted,
 957                  self.actor_state_expired,
 958                  self.partner_system_priority,
 959                  self.partner_system,
 960                  self.partner_key,
 961                  self.partner_port_priority,
 962                  self.partner_port,
 963                  self.partner_state_activity,
 964                  self.partner_state_timeout,
 965                  self.partner_state_aggregation,
 966                  -1,
 967                  self.partner_state_collecting,
 968                  self.partner_state_distributing,
 969                  self.partner_state_defaulted,
 970                  self.partner_state_expired,
 971                  self.collector_max_delay)
 972         l.serialize()
 973
 974     @raises(Exception)
 975     def test_invalid_partner_state_collecting(self):
 976         l = lacp(self.version,
 977                  self.actor_system_priority,
 978                  self.actor_system,
 979                  self.actor_key,
 980                  self.actor_port_priority,
 981                  self.actor_port,
 982                  self.actor_state_activity,
 983                  self.actor_state_timeout,
 984                  self.actor_state_aggregation,
 985                  self.actor_state_synchronization,
 986                  self.actor_state_collecting,
 987                  self.actor_state_distributing,
 988                  self.actor_state_defaulted,
 989                  self.actor_state_expired,
 990                  self.partner_system_priority,
 991                  self.partner_system,
 992                  self.partner_key,
 993                  self.partner_port_priority,
 994                  self.partner_port,
 995                  self.partner_state_activity,
 996                  self.partner_state_timeout,
 997                  self.partner_state_aggregation,
 998                  self.partner_state_synchronization,
 999                  -1,
1000                  self.partner_state_distributing,
1001                  self.partner_state_defaulted,
1002                  self.partner_state_expired,
1003                  self.collector_max_delay)
1004         l.serialize()
1005
1006     @raises(Exception)
1007     def test_invalid_partner_state_distributing(self):
1008         l = lacp(self.version,
1009                  self.actor_system_priority,
1010                  self.actor_system,
1011                  self.actor_key,
1012                  self.actor_port_priority,
1013                  self.actor_port,
1014                  self.actor_state_activity,
1015                  self.actor_state_timeout,
1016                  self.actor_state_aggregation,
1017                  self.actor_state_synchronization,
1018                  self.actor_state_collecting,
1019                  self.actor_state_distributing,
1020                  self.actor_state_defaulted,
1021                  self.actor_state_expired,
1022                  self.partner_system_priority,
1023                  self.partner_system,
1024                  self.partner_key,
1025                  self.partner_port_priority,
1026                  self.partner_port,
1027                  self.partner_state_activity,
1028                  self.partner_state_timeout,
1029                  self.partner_state_aggregation,
1030                  self.partner_state_synchronization,
1031                  self.partner_state_collecting,
1032                  -1,
1033                  self.partner_state_defaulted,
1034                  self.partner_state_expired,
1035                  self.collector_max_delay)
1036         l.serialize()
1037
1038     @raises(Exception)
1039     def test_invalid_partner_state_defaulted(self):
1040         l = lacp(self.version,
1041                  self.actor_system_priority,
1042                  self.actor_system,
1043                  self.actor_key,
1044                  self.actor_port_priority,
1045                  self.actor_port,
1046                  self.actor_state_activity,
1047                  self.actor_state_timeout,
1048                  self.actor_state_aggregation,
1049                  self.actor_state_synchronization,
1050                  self.actor_state_collecting,
1051                  self.actor_state_distributing,
1052                  self.actor_state_defaulted,
1053                  self.actor_state_expired,
1054                  self.partner_system_priority,
1055                  self.partner_system,
1056                  self.partner_key,
1057                  self.partner_port_priority,
1058                  self.partner_port,
1059                  self.partner_state_activity,
1060                  self.partner_state_timeout,
1061                  self.partner_state_aggregation,
1062                  self.partner_state_synchronization,
1063                  self.partner_state_collecting,
1064                  self.partner_state_distributing,
1065                  -1,
1066                  self.partner_state_expired,
1067                  self.collector_max_delay)
1068         l.serialize()
1069
1070     @raises(Exception)
1071     def test_invalid_partner_state_expired(self):
1072         l = lacp(self.version,
1073                  self.actor_system_priority,
1074                  self.actor_system,
1075                  self.actor_key,
1076                  self.actor_port_priority,
1077                  self.actor_port,
1078                  self.actor_state_activity,
1079                  self.actor_state_timeout,
1080                  self.actor_state_aggregation,
1081                  self.actor_state_synchronization,
1082                  self.actor_state_collecting,
1083                  self.actor_state_distributing,
1084                  self.actor_state_defaulted,
1085                  self.actor_state_expired,
1086                  self.partner_system_priority,
1087                  self.partner_system,
1088                  self.partner_key,
1089                  self.partner_port_priority,
1090                  self.partner_port,
1091                  self.partner_state_activity,
1092                  self.partner_state_timeout,
1093                  self.partner_state_aggregation,
1094                  self.partner_state_synchronization,
1095                  self.partner_state_collecting,
1096                  self.partner_state_distributing,
1097                  self.partner_state_defaulted,
1098                  -1,
1099                  self.collector_max_delay)
1100         l.serialize()
1101
1102     def test_json(self):
1103         jsondict = self.l.to_jsondict()
1104         l = lacp.from_jsondict(jsondict['lacp'])
1105         eq_(str(self.l), str(l))