def setUp(self):
super(TestIPv4, self).setUp()
# create 3 pg interfaces
self.create_pg_interfaces(range(3))
# create 2 subinterfaces for pg1 and pg2
self.sub_interfaces = [
VppDot1QSubint(self, self.pg1, 100),
VppDot1ADSubint(self, self.pg2, 200, 300, 400)
]
# packet flows mapping pg0 -> pg1.sub, pg2.sub, etc.
self.flows = dict()
self.flows[self.pg0] = [self.pg1.sub_if, self.pg2.sub_if]
self.flows[self.pg1.sub_if] = [self.pg0, self.pg2.sub_if]
self.flows[self.pg2.sub_if] = [self.pg0, self.pg1.sub_if]
# packet sizes
self.pg_if_packet_sizes = [64, 512, 1518, 9018]
self.sub_if_packet_sizes = [64, 512, 1518 + 4, 9018 + 4]
self.interfaces = list(self.pg_interfaces)
self.interfaces.extend(self.sub_interfaces)
# setup all interfaces
for i in self.interfaces:
i.admin_up()
i.config_ip4()
i.resolve_arp()
# config 2M FIB enries
self.config_fib_entries(200)
def setUpClass(cls):
super(TestSpan, cls).setUpClass()
# Test variables
cls.pkts_per_burst = 257 # Number of packets per burst
# create 3 pg interfaces
cls.create_pg_interfaces(range(3))
cls.bd_id = 55
cls.sub_if = VppDot1QSubint(cls, cls.pg0, 100)
cls.vlan_sub_if = VppDot1QSubint(cls, cls.pg2, 300)
cls.vlan_sub_if.set_vtr(L2_VTR_OP.L2_POP_1, tag=300)
cls.qinq_sub_if = VppDot1ADSubint(cls, cls.pg2, 33, 400, 500)
cls.qinq_sub_if.set_vtr(L2_VTR_OP.L2_POP_2, outer=500, inner=400)
# packet flows mapping pg0 -> pg1, pg2 -> pg3, etc.
cls.flows = dict()
cls.flows[cls.pg0] = [cls.pg1]
cls.flows[cls.pg1] = [cls.pg0]
# packet sizes
cls.pg_if_packet_sizes = [64, 512, 1518] # , 9018]
# setup all interfaces
for i in cls.pg_interfaces:
i.admin_up()
i.config_ip4()
i.resolve_arp()
cls.vxlan = cls.vapi.vxlan_add_del_tunnel(
src_address=cls.pg2.local_ip4n,
dst_address=cls.pg2.remote_ip4n,
is_add=1,
vni=1111)
def setUp(self):
"""
Perform test setup before test case.
**Config:**
- create 3 pg interfaces
- untagged pg0 interface
- Dot1Q subinterface on pg1
- Dot1AD subinterface on pg2
- setup interfaces:
- put it into UP state
- set IPv4 addresses
- resolve neighbor address using ARP
- configure 200 fib entries
:ivar list interfaces: pg interfaces and subinterfaces.
:ivar dict flows: IPv4 packet flows in test.
:ivar list pg_if_packet_sizes: packet sizes in test.
"""
super(TestIPv4, self).setUp()
# create 3 pg interfaces
self.create_pg_interfaces(range(3))
# create 2 subinterfaces for pg1 and pg2
self.sub_interfaces = [
VppDot1QSubint(self, self.pg1, 100),
VppDot1ADSubint(self, self.pg2, 200, 300, 400)
]
# packet flows mapping pg0 -> pg1.sub, pg2.sub, etc.
self.flows = dict()
self.flows[self.pg0] = [self.pg1.sub_if, self.pg2.sub_if]
self.flows[self.pg1.sub_if] = [self.pg0, self.pg2.sub_if]
self.flows[self.pg2.sub_if] = [self.pg0, self.pg1.sub_if]
# packet sizes
self.pg_if_packet_sizes = [64, 512, 1518, 9018]
self.sub_if_packet_sizes = [64, 512, 1518 + 4, 9018 + 4]
self.interfaces = list(self.pg_interfaces)
self.interfaces.extend(self.sub_interfaces)
# setup all interfaces
for i in self.interfaces:
i.admin_up()
i.config_ip4()
i.resolve_arp()
# config 2M FIB entries
self.config_fib_entries(200)
def setUpClass(cls):
super(TestVtr, cls).setUpClass()
# Test variables
cls.bd_id = 1
cls.mac_entries_count = 5
cls.Atag = 100
cls.Btag = 200
cls.dot1ad_sub_id = 20
try:
ifs = range(3)
cls.create_pg_interfaces(ifs)
cls.sub_interfaces = [
VppDot1ADSubint(cls, cls.pg1, cls.dot1ad_sub_id, cls.Btag,
cls.Atag),
VppDot1QSubint(cls, cls.pg2, cls.Btag)
]
interfaces = list(cls.pg_interfaces)
interfaces.extend(cls.sub_interfaces)
# Create BD with MAC learning enabled and put interfaces and
# sub-interfaces to this BD
for pg_if in cls.pg_interfaces:
sw_if_index = pg_if.sub_if.sw_if_index \
if hasattr(pg_if, 'sub_if') else pg_if.sw_if_index
cls.vapi.sw_interface_set_l2_bridge(rx_sw_if_index=sw_if_index,
bd_id=cls.bd_id)
# setup all interfaces
for i in interfaces:
i.admin_up()
# mapping between packet-generator index and lists of test hosts
cls.hosts_by_pg_idx = dict()
# create test host entries and inject packets to learn MAC entries
# in the bridge-domain
cls.create_hosts_and_learn(cls.mac_entries_count)
cls.logger.info(cls.vapi.ppcli("show l2fib"))
except Exception:
super(TestVtr, cls).tearDownClass()
raise
def setUpClass(cls):
"""
Perform standard class setup (defined by class method setUpClass in
class VppTestCase) before running the test case, set test case related
variables and configure VPP.
"""
super(MethodHolder, cls).setUpClass()
cls.pg_if_packet_sizes = [64, 512, 1518, 9018] # packet sizes
cls.bd_id = 111
cls.remote_hosts_count = 200
try:
# create 4 pg interfaces, 1 loopback interface
cls.create_pg_interfaces(range(4))
cls.create_loopback_interfaces(range(1))
# create 2 subinterfaces
cls.subifs = [
VppDot1QSubint(cls, cls.pg1, 10),
VppDot1ADSubint(cls, cls.pg2, 20, 300, 400),
VppDot1QSubint(cls, cls.pg3, 30),
VppDot1ADSubint(cls, cls.pg3, 40, 600, 700)
]
cls.subifs[0].set_vtr(L2_VTR_OP.L2_POP_1, inner=10, push1q=1)
cls.subifs[1].set_vtr(L2_VTR_OP.L2_POP_2,
outer=300,
inner=400,
push1q=1)
cls.subifs[2].set_vtr(L2_VTR_OP.L2_POP_1, inner=30, push1q=1)
cls.subifs[3].set_vtr(L2_VTR_OP.L2_POP_2,
outer=600,
inner=700,
push1q=1)
cls.interfaces = list(cls.pg_interfaces)
cls.interfaces.extend(cls.lo_interfaces)
cls.interfaces.extend(cls.subifs)
for i in cls.interfaces:
i.admin_up()
# Create BD with MAC learning enabled and put interfaces to this BD
cls.vapi.sw_interface_set_l2_bridge(cls.loop0.sw_if_index,
bd_id=cls.bd_id,
bvi=1)
cls.vapi.sw_interface_set_l2_bridge(cls.pg0.sw_if_index,
bd_id=cls.bd_id)
cls.vapi.sw_interface_set_l2_bridge(cls.pg1.sw_if_index,
bd_id=cls.bd_id)
cls.vapi.sw_interface_set_l2_bridge(cls.subifs[0].sw_if_index,
bd_id=cls.bd_id)
cls.vapi.sw_interface_set_l2_bridge(cls.subifs[1].sw_if_index,
bd_id=cls.bd_id)
# Configure IPv4/6 addresses on loop interface and routed interface
cls.loop0.config_ip4()
cls.loop0.config_ip6()
cls.pg2.config_ip4()
cls.pg2.config_ip6()
cls.pg3.config_ip4()
cls.pg3.config_ip6()
# Configure MAC address binding to IPv4 neighbors on loop0
cls.loop0.generate_remote_hosts(cls.remote_hosts_count)
# Modify host mac addresses to have different OUI parts
for i in range(2, cls.remote_hosts_count + 2):
mac = cls.loop0.remote_hosts[i - 2]._mac.split(':')
mac[2] = format(int(mac[2], 16) + i, "02x")
cls.loop0.remote_hosts[i - 2]._mac = ":".join(mac)
cls.loop0.configure_ipv4_neighbors()
cls.loop0.configure_ipv6_neighbors()
# configure MAC address on pg3
cls.pg3.resolve_arp()
cls.pg3.resolve_ndp()
# configure MAC address on subifs
for i in cls.subifs:
i.config_ip4()
i.resolve_arp()
i.config_ip6()
# configure MAC address on pg2
cls.pg2.resolve_arp()
cls.pg2.resolve_ndp()
# Loopback BVI interface has remote hosts
# one half of hosts are behind pg0 second behind pg1,pg2,pg3 subifs
cls.pg0.remote_hosts = cls.loop0.remote_hosts[:100]
cls.subifs[0].remote_hosts = cls.loop0.remote_hosts[100:125]
cls.subifs[1].remote_hosts = cls.loop0.remote_hosts[125:150]
cls.subifs[2].remote_hosts = cls.loop0.remote_hosts[150:175]
cls.subifs[3].remote_hosts = cls.loop0.remote_hosts[175:]
except Exception:
super(TestMACIP, cls).tearDownClass()
raise
def setUpClass(cls):
"""
Perform standard class setup (defined by class method setUpClass in
class VppTestCase) before running the test case, set test case related
variables and configure VPP.
:var int bd_id: Bridge domain ID.
:var int mac_entries_count: Number of MAC entries for bridge-domain to
learn.
:var int dot1q_tag: VLAN tag for dot1q sub-interface.
:var int dot1ad_sub_id: SubID of dot1ad sub-interface.
:var int dot1ad_outer_tag: VLAN S-tag for dot1ad sub-interface.
:var int dot1ad_inner_tag: VLAN C-tag for dot1ad sub-interface.
:var int sl_pkts_per_burst: Number of packets in burst for single-loop
test.
:var int dl_pkts_per_burst: Number of packets in burst for dual-loop
test.
"""
super(TestL2bd, cls).setUpClass()
# Test variables
cls.bd_id = 1
cls.mac_entries_count = 100
# cls.dot1q_sub_id = 100
cls.dot1q_tag = 100
cls.dot1ad_sub_id = 20
cls.dot1ad_outer_tag = 200
cls.dot1ad_inner_tag = 300
cls.sl_pkts_per_burst = 2
cls.dl_pkts_per_burst = 257
try:
# create 3 pg interfaces
cls.create_pg_interfaces(range(3))
# create 2 sub-interfaces for pg1 and pg2
cls.sub_interfaces = [
VppDot1QSubint(cls, cls.pg1, cls.dot1q_tag),
VppDot1ADSubint(cls, cls.pg2, cls.dot1ad_sub_id,
cls.dot1ad_outer_tag, cls.dot1ad_inner_tag)
]
# packet flows mapping pg0 -> pg1, pg2, etc.
cls.flows = dict()
cls.flows[cls.pg0] = [cls.pg1, cls.pg2]
cls.flows[cls.pg1] = [cls.pg0, cls.pg2]
cls.flows[cls.pg2] = [cls.pg0, cls.pg1]
# packet sizes
cls.pg_if_packet_sizes = [64, 512, 1518, 9018]
cls.sub_if_packet_sizes = [64, 512, 1518 + 4, 9018 + 4]
cls.interfaces = list(cls.pg_interfaces)
cls.interfaces.extend(cls.sub_interfaces)
# Create BD with MAC learning enabled and put interfaces and
# sub-interfaces to this BD
for pg_if in cls.pg_interfaces:
sw_if_index = pg_if.sub_if.sw_if_index \
if hasattr(pg_if, 'sub_if') else pg_if.sw_if_index
cls.vapi.sw_interface_set_l2_bridge(sw_if_index,
bd_id=cls.bd_id)
# setup all interfaces
for i in cls.interfaces:
i.admin_up()
# mapping between packet-generator index and lists of test hosts
cls.hosts_by_pg_idx = dict()
# create test host entries and inject packets to learn MAC entries
# in the bridge-domain
cls.create_hosts_and_learn(cls.mac_entries_count)
cls.logger.info(cls.vapi.ppcli("show l2fib"))
except Exception:
super(TestL2bd, cls).tearDownClass()
raise