+ self.verify_ip(
+ rx1[0],
+ self.pg1.local_mac,
+ self.pg1.remote_hosts[1].mac,
+ self.pg0.remote_ip4,
+ self.pg1.remote_hosts[1].ip4,
+ )
+
+ def test_arp_static(self):
+ """ARP Static"""
+ self.pg2.generate_remote_hosts(3)
+
+ #
+ # Add a static ARP entry
+ #
+ static_arp = VppNeighbor(
+ self,
+ self.pg2.sw_if_index,
+ self.pg2.remote_hosts[1].mac,
+ self.pg2.remote_hosts[1].ip4,
+ is_static=1,
+ )
+ static_arp.add_vpp_config()
+
+ #
+ # Add the connected prefix to the interface
+ #
+ self.pg2.config_ip4()
+
+ #
+ # We should now find the adj-fib
+ #
+ self.assertTrue(
+ find_nbr(
+ self, self.pg2.sw_if_index, self.pg2.remote_hosts[1].ip4, is_static=1
+ )
+ )
+ self.assertTrue(find_route(self, self.pg2.remote_hosts[1].ip4, 32))
+
+ #
+ # remove the connected
+ #
+ self.pg2.unconfig_ip4()
+
+ #
+ # put the interface into table 1
+ #
+ self.pg2.set_table_ip4(1)
+
+ #
+ # configure the same connected and expect to find the
+ # adj fib in the new table
+ #
+ self.pg2.config_ip4()
+ self.assertTrue(find_route(self, self.pg2.remote_hosts[1].ip4, 32, table_id=1))
+
+ #
+ # clean-up
+ #
+ self.pg2.unconfig_ip4()
+ static_arp.remove_vpp_config()
+ self.pg2.set_table_ip4(0)
+
+ def test_arp_static_replace_dynamic_same_mac(self):
+ """ARP Static can replace Dynamic (same mac)"""
+ self.pg2.generate_remote_hosts(1)
+
+ dyn_arp = VppNeighbor(
+ self,
+ self.pg2.sw_if_index,
+ self.pg2.remote_hosts[0].mac,
+ self.pg2.remote_hosts[0].ip4,
+ )
+ static_arp = VppNeighbor(
+ self,
+ self.pg2.sw_if_index,
+ self.pg2.remote_hosts[0].mac,
+ self.pg2.remote_hosts[0].ip4,
+ is_static=1,
+ )
+
+ #
+ # Add a dynamic ARP entry
+ #
+ dyn_arp.add_vpp_config()
+
+ #
+ # We should find the dynamic nbr
+ #
+ self.assertFalse(
+ find_nbr(
+ self, self.pg2.sw_if_index, self.pg2.remote_hosts[0].ip4, is_static=1
+ )
+ )
+ self.assertTrue(
+ find_nbr(
+ self,
+ self.pg2.sw_if_index,
+ self.pg2.remote_hosts[0].ip4,
+ is_static=0,
+ mac=self.pg2.remote_hosts[0].mac,
+ )
+ )
+
+ #
+ # Add a static ARP entry with the same mac
+ #
+ static_arp.add_vpp_config()
+
+ #
+ # We should now find the static nbr with the same mac
+ #
+ self.assertFalse(
+ find_nbr(
+ self, self.pg2.sw_if_index, self.pg2.remote_hosts[0].ip4, is_static=0
+ )
+ )
+ self.assertTrue(
+ find_nbr(
+ self,
+ self.pg2.sw_if_index,
+ self.pg2.remote_hosts[0].ip4,
+ is_static=1,
+ mac=self.pg2.remote_hosts[0].mac,
+ )
+ )
+
+ #
+ # clean-up
+ #
+ static_arp.remove_vpp_config()
+
+ def test_arp_static_replace_dynamic_diff_mac(self):
+ """ARP Static can replace Dynamic (diff mac)"""
+ self.pg2.generate_remote_hosts(2)
+
+ dyn_arp = VppNeighbor(
+ self,
+ self.pg2.sw_if_index,
+ self.pg2.remote_hosts[0].mac,
+ self.pg2.remote_hosts[0].ip4,
+ )
+ static_arp = VppNeighbor(
+ self,
+ self.pg2.sw_if_index,
+ self.pg2.remote_hosts[1].mac,
+ self.pg2.remote_hosts[0].ip4,
+ is_static=1,
+ )
+
+ #
+ # Add a dynamic ARP entry
+ #
+ dyn_arp.add_vpp_config()
+
+ #
+ # We should find the dynamic nbr
+ #
+ self.assertFalse(
+ find_nbr(
+ self, self.pg2.sw_if_index, self.pg2.remote_hosts[0].ip4, is_static=1
+ )
+ )
+ self.assertTrue(
+ find_nbr(
+ self,
+ self.pg2.sw_if_index,
+ self.pg2.remote_hosts[0].ip4,
+ is_static=0,
+ mac=self.pg2.remote_hosts[0].mac,
+ )
+ )
+
+ #
+ # Add a static ARP entry with a changed mac
+ #
+ static_arp.add_vpp_config()
+
+ #
+ # We should now find the static nbr with a changed mac
+ #
+ self.assertFalse(
+ find_nbr(
+ self, self.pg2.sw_if_index, self.pg2.remote_hosts[0].ip4, is_static=0
+ )
+ )
+ self.assertTrue(
+ find_nbr(
+ self,
+ self.pg2.sw_if_index,
+ self.pg2.remote_hosts[0].ip4,
+ is_static=1,
+ mac=self.pg2.remote_hosts[1].mac,
+ )
+ )
+
+ #
+ # clean-up
+ #
+ static_arp.remove_vpp_config()
+
+ def test_arp_incomplete(self):
+ """ARP Incomplete"""
+ self.pg1.generate_remote_hosts(4)
+
+ p0 = (
+ Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
+ / IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_hosts[1].ip4)
+ / UDP(sport=1234, dport=1234)
+ / Raw()
+ )
+ p1 = (
+ Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
+ / IP(src=self.pg0.remote_ip4, dst=self.pg1.remote_hosts[2].ip4)
+ / UDP(sport=1234, dport=1234)
+ / Raw()
+ )
+ p2 = (
+ Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
+ / IP(src=self.pg0.remote_ip4, dst="1.1.1.1")
+ / UDP(sport=1234, dport=1234)
+ / Raw()
+ )
+
+ #
+ # a packet to an unresolved destination generates an ARP request
+ #
+ rx = self.send_and_expect(self.pg0, [p0], self.pg1)
+ self.verify_arp_req(
+ rx[0], self.pg1.local_mac, self.pg1.local_ip4, self.pg1._remote_hosts[1].ip4
+ )
+
+ #
+ # add a neighbour for remote host 1
+ #
+ static_arp = VppNeighbor(
+ self,
+ self.pg1.sw_if_index,
+ self.pg1.remote_hosts[1].mac,
+ self.pg1.remote_hosts[1].ip4,
+ is_static=1,
+ )
+ static_arp.add_vpp_config()
+
+ #
+ # add a route through remote host 3 hence we get an incomplete
+ #
+ VppIpRoute(
+ self,
+ "1.1.1.1",
+ 32,
+ [VppRoutePath(self.pg1.remote_hosts[3].ip4, self.pg1.sw_if_index)],
+ ).add_vpp_config()
+ rx = self.send_and_expect(self.pg0, [p2], self.pg1)
+ self.verify_arp_req(
+ rx[0], self.pg1.local_mac, self.pg1.local_ip4, self.pg1._remote_hosts[3].ip4
+ )
+
+ #
+ # change the interface's MAC
+ #
+ self.vapi.sw_interface_set_mac_address(
+ self.pg1.sw_if_index, "00:00:00:33:33:33"
+ )
+
+ #
+ # now ARP requests come from the new source mac
+ #
+ rx = self.send_and_expect(self.pg0, [p1], self.pg1)
+ self.verify_arp_req(
+ rx[0],
+ "00:00:00:33:33:33",
+ self.pg1.local_ip4,
+ self.pg1._remote_hosts[2].ip4,
+ )
+ rx = self.send_and_expect(self.pg0, [p2], self.pg1)
+ self.verify_arp_req(
+ rx[0],
+ "00:00:00:33:33:33",
+ self.pg1.local_ip4,
+ self.pg1._remote_hosts[3].ip4,
+ )
+
+ #
+ # packets to the resolved host also have the new source mac
+ #
+ rx = self.send_and_expect(self.pg0, [p0], self.pg1)
+ self.verify_ip(
+ rx[0],
+ "00:00:00:33:33:33",
+ self.pg1.remote_hosts[1].mac,
+ self.pg0.remote_ip4,
+ self.pg1.remote_hosts[1].ip4,
+ )
+
+ #
+ # set the mac address on the interface that does not have a
+ # configured subnet and thus no glean
+ #
+ self.vapi.sw_interface_set_mac_address(
+ self.pg2.sw_if_index, "00:00:00:33:33:33"
+ )
+
+ def test_garp(self):
+ """GARP"""
+
+ #
+ # Generate some hosts on the LAN
+ #
+ self.pg1.generate_remote_hosts(4)
+ self.pg2.generate_remote_hosts(4)
+
+ #
+ # And an ARP entry
+ #
+ arp = VppNeighbor(
+ self,
+ self.pg1.sw_if_index,
+ self.pg1.remote_hosts[1].mac,
+ self.pg1.remote_hosts[1].ip4,
+ )
+ arp.add_vpp_config()
+
+ self.assertTrue(
+ find_nbr(
+ self,
+ self.pg1.sw_if_index,
+ self.pg1.remote_hosts[1].ip4,
+ mac=self.pg1.remote_hosts[1].mac,
+ )
+ )
+
+ #
+ # Send a GARP (request) to swap the host 1's address to that of host 2
+ #
+ p1 = Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg1.remote_hosts[2].mac) / ARP(
+ op="who-has",
+ hwdst=self.pg1.local_mac,
+ hwsrc=self.pg1.remote_hosts[2].mac,
+ pdst=self.pg1.remote_hosts[1].ip4,
+ psrc=self.pg1.remote_hosts[1].ip4,
+ )
+
+ self.pg1.add_stream(p1)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+
+ self.assertTrue(
+ find_nbr(
+ self,
+ self.pg1.sw_if_index,
+ self.pg1.remote_hosts[1].ip4,
+ mac=self.pg1.remote_hosts[2].mac,
+ )
+ )
+ self.assert_equal(self.get_arp_rx_garp(self.pg1), 1)
+
+ #
+ # Send a GARP (reply) to swap the host 1's address to that of host 3
+ #
+ p1 = Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg1.remote_hosts[3].mac) / ARP(
+ op="is-at",
+ hwdst=self.pg1.local_mac,
+ hwsrc=self.pg1.remote_hosts[3].mac,
+ pdst=self.pg1.remote_hosts[1].ip4,
+ psrc=self.pg1.remote_hosts[1].ip4,
+ )
+
+ self.pg1.add_stream(p1)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+
+ self.assertTrue(
+ find_nbr(
+ self,
+ self.pg1.sw_if_index,
+ self.pg1.remote_hosts[1].ip4,
+ mac=self.pg1.remote_hosts[3].mac,
+ )
+ )
+ self.assert_equal(self.get_arp_rx_garp(self.pg1), 2)
+
+ #
+ # GARPs (request nor replies) for host we don't know yet
+ # don't result in new neighbour entries
+ #
+ p1 = Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg1.remote_hosts[3].mac) / ARP(
+ op="who-has",
+ hwdst=self.pg1.local_mac,
+ hwsrc=self.pg1.remote_hosts[3].mac,
+ pdst=self.pg1.remote_hosts[2].ip4,
+ psrc=self.pg1.remote_hosts[2].ip4,
+ )
+
+ self.pg1.add_stream(p1)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+
+ self.assertFalse(
+ find_nbr(self, self.pg1.sw_if_index, self.pg1.remote_hosts[2].ip4)
+ )
+
+ p1 = Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg1.remote_hosts[3].mac) / ARP(
+ op="is-at",
+ hwdst=self.pg1.local_mac,
+ hwsrc=self.pg1.remote_hosts[3].mac,
+ pdst=self.pg1.remote_hosts[2].ip4,
+ psrc=self.pg1.remote_hosts[2].ip4,
+ )
+
+ self.pg1.add_stream(p1)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+
+ self.assertFalse(
+ find_nbr(self, self.pg1.sw_if_index, self.pg1.remote_hosts[2].ip4)
+ )
+
+ #
+ # IP address in different subnets are not learnt
+ #
+ self.pg2.configure_ipv4_neighbors()
+
+ cntr = self.statistics.get_err_counter(
+ "/err/arp-reply/l3_dst_address_not_local"
+ )
+
+ for op in ["is-at", "who-has"]:
+ p1 = [
+ (
+ Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg2.remote_hosts[1].mac)
+ / ARP(
+ op=op,
+ hwdst=self.pg2.local_mac,
+ hwsrc=self.pg2.remote_hosts[1].mac,
+ pdst=self.pg2.remote_hosts[1].ip4,
+ psrc=self.pg2.remote_hosts[1].ip4,
+ )
+ ),
+ (
+ Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg2.remote_hosts[1].mac)
+ / ARP(
+ op=op,
+ hwdst="ff:ff:ff:ff:ff:ff",
+ hwsrc=self.pg2.remote_hosts[1].mac,
+ pdst=self.pg2.remote_hosts[1].ip4,
+ psrc=self.pg2.remote_hosts[1].ip4,
+ )
+ ),
+ ]
+
+ self.send_and_assert_no_replies(self.pg1, p1)
+ self.assertFalse(
+ find_nbr(self, self.pg1.sw_if_index, self.pg2.remote_hosts[1].ip4)
+ )
+
+ # they are all dropped because the subnet's don't match
+ self.assertEqual(
+ cntr + 4,
+ self.statistics.get_err_counter("/err/arp-reply/l3_dst_address_not_local"),
+ )
+
+ def test_arp_incomplete2(self):
+ """Incomplete Entries"""
+
+ #
+ # ensure that we throttle the ARP and ND requests
+ #
+ self.pg0.generate_remote_hosts(2)
+
+ #
+ # IPv4/ARP
+ #
+ ip_10_0_0_1 = VppIpRoute(
+ self,
+ "10.0.0.1",
+ 32,
+ [VppRoutePath(self.pg0.remote_hosts[1].ip4, self.pg0.sw_if_index)],
+ )
+ ip_10_0_0_1.add_vpp_config()
+
+ p1 = (
+ Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac)
+ / IP(src=self.pg1.remote_ip4, dst="10.0.0.1")
+ / UDP(sport=1234, dport=1234)
+ / Raw()
+ )
+
+ self.pg1.add_stream(p1 * 257)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+ rx = self.pg0._get_capture(1)
+
+ #
+ # how many we get is going to be dependent on the time for packet
+ # processing but it should be small
+ #
+ self.assertLess(len(rx), 64)
+
+ #
+ # IPv6/ND
+ #
+ ip_10_1 = VppIpRoute(
+ self,
+ "10::1",
+ 128,
+ [
+ VppRoutePath(
+ self.pg0.remote_hosts[1].ip6,
+ self.pg0.sw_if_index,
+ proto=DpoProto.DPO_PROTO_IP6,
+ )
+ ],
+ )
+ ip_10_1.add_vpp_config()
+
+ p1 = (
+ Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac)
+ / IPv6(src=self.pg1.remote_ip6, dst="10::1")
+ / UDP(sport=1234, dport=1234)
+ / Raw()
+ )
+
+ self.pg1.add_stream(p1 * 257)
+ self.pg_enable_capture(self.pg_interfaces)
+ self.pg_start()
+ rx = self.pg0._get_capture(1)
+
+ #
+ # how many we get is going to be dependent on the time for packet
+ # processing but it should be small
+ #
+ self.assertLess(len(rx), 64)
+
+ def test_arp_forus(self):
+ """ARP for for-us"""
+
+ #
+ # Test that VPP responds with ARP requests to addresses that
+ # are connected and local routes.
+ # Use one of the 'remote' addresses in the subnet as a local address
+ # The intention of this route is that it then acts like a secondary
+ # address added to an interface
+ #
+ self.pg0.generate_remote_hosts(2)
+
+ forus = VppIpRoute(
+ self,
+ self.pg0.remote_hosts[1].ip4,
+ 32,
+ [
+ VppRoutePath(
+ "0.0.0.0",
+ self.pg0.sw_if_index,
+ type=FibPathType.FIB_PATH_TYPE_LOCAL,
+ )
+ ],
+ )
+ forus.add_vpp_config()
+
+ p = Ether(dst="ff:ff:ff:ff:ff:ff", src=self.pg0.remote_mac) / ARP(
+ op="who-has",
+ hwdst=self.pg0.local_mac,
+ hwsrc=self.pg0.remote_mac,
+ pdst=self.pg0.remote_hosts[1].ip4,
+ psrc=self.pg0.remote_ip4,
+ )
+
+ rx = self.send_and_expect(self.pg0, [p], self.pg0)
+
+ self.verify_arp_resp(
+ rx[0],
+ self.pg0.local_mac,
+ self.pg0.remote_mac,
+ self.pg0.remote_hosts[1].ip4,
+ self.pg0.remote_ip4,
+ )
+
+ def test_arp_table_swap(self):
+ #
+ # Generate some hosts on the LAN
+ #
+ N_NBRS = 4
+ self.pg1.generate_remote_hosts(N_NBRS)
+
+ for n in range(N_NBRS):
+ # a route thru each neighbour
+ VppIpRoute(
+ self,
+ "10.0.0.%d" % n,
+ 32,
+ [VppRoutePath(self.pg1.remote_hosts[n].ip4, self.pg1.sw_if_index)],
+ ).add_vpp_config()
+
+ # resolve each neighbour
+ p1 = Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) / ARP(
+ op="is-at",
+ hwdst=self.pg1.local_mac,
+ hwsrc="00:00:5e:00:01:09",
+ pdst=self.pg1.local_ip4,
+ psrc=self.pg1.remote_hosts[n].ip4,
+ )
+
+ self.send_and_assert_no_replies(self.pg1, p1, "ARP reply")
+
+ self.logger.info(self.vapi.cli("sh ip neighbors"))
+
+ #
+ # swap the table pg1 is in
+ #
+ table = VppIpTable(self, 100).add_vpp_config()
+
+ self.pg1.unconfig_ip4()
+ self.pg1.set_table_ip4(100)
+ self.pg1.config_ip4()
+
+ #
+ # all neighbours are cleared
+ #
+ for n in range(N_NBRS):
+ self.assertFalse(
+ find_nbr(self, self.pg1.sw_if_index, self.pg1.remote_hosts[n].ip4)
+ )
+
+ #
+ # packets to all neighbours generate ARP requests
+ #
+ for n in range(N_NBRS):
+ # a route thru each neighbour
+ VppIpRoute(
+ self,
+ "10.0.0.%d" % n,
+ 32,
+ [VppRoutePath(self.pg1.remote_hosts[n].ip4, self.pg1.sw_if_index)],
+ table_id=100,
+ ).add_vpp_config()
+
+ p = (
+ Ether(src=self.pg1.remote_hosts[n].mac, dst=self.pg1.local_mac)
+ / IP(src=self.pg1.remote_hosts[n].ip4, dst="10.0.0.%d" % n)
+ / Raw(b"0x5" * 100)
+ )
+ rxs = self.send_and_expect(self.pg1, [p], self.pg1)
+ for rx in rxs:
+ self.verify_arp_req(
+ rx,
+ self.pg1.local_mac,
+ self.pg1.local_ip4,
+ self.pg1.remote_hosts[n].ip4,
+ )
+
+ self.pg1.unconfig_ip4()
+ self.pg1.set_table_ip4(0)
+
+ def test_glean_src_select(self):
+ """Multi Connecteds"""
+
+ #
+ # configure multiple connected subnets on an interface
+ # and ensure that ARP requests for hosts on those subnets
+ # pick up the correct source address
+ #
+ conn1 = VppIpInterfaceAddress(self, self.pg1, "10.0.0.1", 24).add_vpp_config()
+ conn2 = VppIpInterfaceAddress(self, self.pg1, "10.0.1.1", 24).add_vpp_config()
+
+ p1 = (
+ Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
+ / IP(src=self.pg1.remote_ip4, dst="10.0.0.128")
+ / Raw(b"0x5" * 100)
+ )
+
+ rxs = self.send_and_expect(self.pg0, [p1], self.pg1)
+ for rx in rxs:
+ self.verify_arp_req(rx, self.pg1.local_mac, "10.0.0.1", "10.0.0.128")
+
+ p2 = (
+ Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
+ / IP(src=self.pg1.remote_ip4, dst="10.0.1.128")
+ / Raw(b"0x5" * 100)
+ )
+
+ rxs = self.send_and_expect(self.pg0, [p2], self.pg1)
+ for rx in rxs:
+ self.verify_arp_req(rx, self.pg1.local_mac, "10.0.1.1", "10.0.1.128")
+
+ #
+ # add a local address in the same subnet
+ # the source addresses are equivalent. VPP happens to
+ # choose the last one that was added
+ conn3 = VppIpInterfaceAddress(self, self.pg1, "10.0.1.2", 24).add_vpp_config()
+
+ rxs = self.send_and_expect(self.pg0, [p2], self.pg1)
+ for rx in rxs:
+ self.verify_arp_req(rx, self.pg1.local_mac, "10.0.1.2", "10.0.1.128")
+
+ #
+ # remove
+ #
+ conn3.remove_vpp_config()
+ rxs = self.send_and_expect(self.pg0, [p2], self.pg1)
+ for rx in rxs:
+ self.verify_arp_req(rx, self.pg1.local_mac, "10.0.1.1", "10.0.1.128")
+
+ #
+ # add back, this time remove the first one
+ #
+ conn3 = VppIpInterfaceAddress(self, self.pg1, "10.0.1.2", 24).add_vpp_config()
+
+ rxs = self.send_and_expect(self.pg0, [p2], self.pg1)
+ for rx in rxs:
+ self.verify_arp_req(rx, self.pg1.local_mac, "10.0.1.2", "10.0.1.128")
+
+ conn1.remove_vpp_config()
+ rxs = self.send_and_expect(self.pg0, [p2], self.pg1)
+ for rx in rxs:
+ self.verify_arp_req(rx, self.pg1.local_mac, "10.0.1.2", "10.0.1.128")
+
+ # apply a connected prefix to an interface in a different table
+ VppIpRoute(
+ self,
+ "10.0.1.0",
+ 24,
+ [VppRoutePath("0.0.0.0", self.pg1.sw_if_index)],
+ table_id=1,
+ ).add_vpp_config()
+
+ rxs = self.send_and_expect(self.pg3, [p2], self.pg1)
+ for rx in rxs:
+ self.verify_arp_req(rx, self.pg1.local_mac, "10.0.1.2", "10.0.1.128")
+
+ # cleanup
+ conn3.remove_vpp_config()
+ conn2.remove_vpp_config()
+
+
+@tag_fixme_vpp_workers
+class NeighborStatsTestCase(VppTestCase):
+ """ARP/ND Counters"""
+
+ @classmethod
+ def setUpClass(cls):
+ super(NeighborStatsTestCase, cls).setUpClass()
+
+ @classmethod
+ def tearDownClass(cls):
+ super(NeighborStatsTestCase, cls).tearDownClass()
+
+ def setUp(self):
+ super(NeighborStatsTestCase, self).setUp()
+
+ self.create_pg_interfaces(range(2))
+
+ # pg0 configured with ip4 and 6 addresses used for input
+ # pg1 configured with ip4 and 6 addresses used for output
+ # pg2 is unnumbered to pg0
+ for i in self.pg_interfaces:
+ i.admin_up()
+ i.config_ip4()
+ i.config_ip6()
+ i.resolve_arp()
+ i.resolve_ndp()
+
+ def tearDown(self):
+ super(NeighborStatsTestCase, self).tearDown()