#!/usr/bin/env python import random import socket import unittest import time import re from scapy.packet import Raw from scapy.layers.l2 import Ether from scapy.layers.inet import IP, TCP, UDP from scapy.layers.inet6 import IPv6 from framework import VppTestCase, VppTestRunner, running_extended_tests from vpp_object import VppObject from vpp_pg_interface import CaptureTimeoutError from util import ppp from ipfix import IPFIX, Set, Template, Data, IPFIXDecoder from vpp_ip_route import VppIpRoute, VppRoutePath class VppCFLOW(VppObject): """CFLOW object for IPFIX exporter and Flowprobe feature""" def __init__(self, test, intf='pg2', active=0, passive=0, timeout=100, mtu=1024, datapath='l2', layer='l2 l3 l4'): self._test = test self._intf = intf self._active = active if passive == 0 or passive < active: self._passive = active+1 else: self._passive = passive self._datapath = datapath # l2 ip4 ip6 self._collect = layer # l2 l3 l4 self._timeout = timeout self._mtu = mtu self._configured = False def add_vpp_config(self): self.enable_exporter() self._test.vapi.ppcli("flowprobe params record %s active %s " "passive %s" % (self._collect, self._active, self._passive)) self.enable_flowprobe_feature() self._test.vapi.cli("ipfix flush") self._configured = True def remove_vpp_config(self): self.disable_exporter() self.disable_flowprobe_feature() self._test.vapi.cli("ipfix flush") self._configured = False def enable_exporter(self): self._test.vapi.set_ipfix_exporter( collector_address=self._test.pg0.remote_ip4n, src_address=self._test.pg0.local_ip4n, path_mtu=self._mtu, template_interval=self._timeout) def enable_flowprobe_feature(self): self._test.vapi.ppcli("flowprobe feature add-del %s %s" % (self._intf, self._datapath)) def disable_exporter(self): self._test.vapi.cli("set ipfix exporter collector 0.0.0.0") def disable_flowprobe_feature(self): self._test.vapi.cli("flowprobe feature add-del %s %s disable" % (self._intf, self._datapath)) def object_id(self): return "ipfix-collector-%s" % (self._src, self.dst) def query_vpp_config(self): return self._configured def verify_templates(self, decoder=None, timeout=1, count=3): templates = [] p = self._test.wait_for_cflow_packet(self._test.collector, 2, timeout) self._test.assertTrue(p.haslayer(IPFIX)) if decoder is not None and p.haslayer(Template): templates.append(p[Template].templateID) decoder.add_template(p.getlayer(Template)) if count > 1: p = self._test.wait_for_cflow_packet(self._test.collector, 2) self._test.assertTrue(p.haslayer(IPFIX)) if decoder is not None and p.haslayer(Template): templates.append(p[Template].templateID) decoder.add_template(p.getlayer(Template)) if count > 2: p = self._test.wait_for_cflow_packet(self._test.collector, 2) self._test.assertTrue(p.haslayer(IPFIX)) if decoder is not None and p.haslayer(Template): templates.append(p[Template].templateID) decoder.add_template(p.getlayer(Template)) return templates class MethodHolder(VppTestCase): """ Flow-per-packet plugin: test L2, IP4, IP6 reporting """ # Test variables debug_print = False max_number_of_packets = 10 pkts = [] @classmethod 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() try: # Create pg interfaces cls.create_pg_interfaces(range(9)) # Packet sizes cls.pg_if_packet_sizes = [64, 512, 1518, 9018] # Create BD with MAC learning and unknown unicast flooding disabled # and put interfaces to this BD cls.vapi.bridge_domain_add_del(bd_id=1, uu_flood=1, learn=1) cls.vapi.sw_interface_set_l2_bridge(cls.pg1._sw_if_index, bd_id=1) cls.vapi.sw_interface_set_l2_bridge(cls.pg2._sw_if_index, bd_id=1) # Set up all interfaces for i in cls.pg_interfaces: i.admin_up() cls.pg0.config_ip4() cls.pg0.configure_ipv4_neighbors() cls.collector = cls.pg0 cls.pg1.config_ip4() cls.pg1.resolve_arp() cls.pg2.config_ip4() cls.pg2.resolve_arp() cls.pg3.config_ip4() cls.pg3.resolve_arp() cls.pg4.config_ip4() cls.pg4.resolve_arp() cls.pg7.config_ip4() cls.pg8.config_ip4() cls.pg8.configure_ipv4_neighbors() cls.pg5.config_ip6() cls.pg5.resolve_ndp() cls.pg5.disable_ipv6_ra() cls.pg6.config_ip6() cls.p
/*
 * Copyright (c) 2018 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef included_clib_config_h
#define included_clib_config_h

#ifndef CLIB_LOG2_CACHE_LINE_BYTES
#define CLIB_LOG2_CACHE_LINE_BYTES @LOG2_CACHE_LINE_BYTES@
#endif

#define USE_DLMALLOC @DLMALLOC@

#define CLIB_TARGET_TRIPLET "@CMAKE_C_COMPILER_TARGET@"
#endif
# egress interface self.assertEqual(int(record[14].encode('hex'), 16), 9) # packets self.assertEqual(int(record[2].encode('hex'), 16), 1) # src mac self.assertEqual(':'.join(re.findall('..', record[56].encode( 'hex'))), self.pg8.local_mac) # dst mac self.assertEqual(':'.join(re.findall('..', record[80].encode( 'hex'))), self.pg8.remote_mac) flowTimestamp = int(record[156].encode('hex'), 16) >> 32 # flow start timestamp self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1) flowTimestamp = int(record[157].encode('hex'), 16) >> 32 # flow end timestamp self.assertAlmostEqual(flowTimestamp, nowUNIX, delta=1) # ethernet type self.assertEqual(int(record[256].encode('hex'), 16), 8) # src ip self.assertEqual('.'.join(re.findall('..', record[8].encode( 'hex'))), '.'.join('{:02x}'.format(int(n)) for n in self.pg7.remote_ip4.split('.'))) # dst ip self.assertEqual('.'.join(re.findall('..', record[12].encode( 'hex'))), '.'.join('{:02x}'.format(int(n)) for n in "9.0.0.100".split('.'))) # protocol (TCP) self.assertEqual(int(record[4].encode('hex'), 16), 6) # src port self.assertEqual(int(record[7].encode('hex'), 16), 1234) # dst port self.assertEqual(int(record[11].encode('hex'), 16), 4321) # tcp flags self.assertEqual(int(record[6].encode('hex'), 16), 80) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0000") class Datapath(MethodHolder): """collect information on Ethernet, IP4 and IP6 datapath (no timers)""" def test_templatesL2(self): """ verify template on L2 datapath""" self.logger.info("FFP_TEST_START_0000") self.pg_enable_capture(self.pg_interfaces) ipfix = VppCFLOW(test=self, layer='l2') ipfix.add_vpp_config() # template packet should arrive immediately self.vapi.cli("ipfix flush") ipfix.verify_templates(timeout=3, count=1) self.collector.get_capture(1) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0000") def test_L2onL2(self): """ L2 data on L2 datapath""" self.logger.info("FFP_TEST_START_0001") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self, layer='l2') ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder, count=1) self.create_stream(packets=1) capture = self.send_packets() # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") cflow = self.wait_for_cflow_packet(self.collector, templates[0]) self.verify_cflow_data_detail(ipfix_decoder, capture, cflow, {2: 'packets', 256: 8}) self.collector.get_capture(2) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0001") def test_L3onL2(self): """ L3 data on L2 datapath""" self.logger.info("FFP_TEST_START_0002") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self, layer='l3') ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder, count=2) self.create_stream(packets=1) capture = self.send_packets() # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") cflow = self.wait_for_cflow_packet(self.collector, templates[0]) self.verify_cflow_data_detail(ipfix_decoder, capture, cflow, {2: 'packets', 4: 17, 8: 'src_ip', 12: 'dst_ip'}) self.collector.get_capture(3) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0002") def test_L4onL2(self): """ L4 data on L2 datapath""" self.logger.info("FFP_TEST_START_0003") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self, layer='l4') ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder, count=2) self.create_stream(packets=1) capture = self.send_packets() # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") cflow = self.wait_for_cflow_packet(self.collector, templates[0]) self.verify_cflow_data_detail(ipfix_decoder, capture, cflow, {2: 'packets', 7: 'sport', 11: 'dport'}) self.collector.get_capture(3) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0003") def test_templatesIp4(self): """ verify templates on IP4 datapath""" self.logger.info("FFP_TEST_START_0000") self.pg_enable_capture(self.pg_interfaces) ipfix = VppCFLOW(test=self, datapath='ip4') ipfix.add_vpp_config() # template packet should arrive immediately self.vapi.cli("ipfix flush") ipfix.verify_templates(timeout=3, count=1) self.collector.get_capture(1) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0000") def test_L2onIP4(self): """ L2 data on IP4 datapath""" self.logger.info("FFP_TEST_START_0001") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self, intf='pg4', layer='l2', datapath='ip4') ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder, count=1) self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1) capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4) # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") cflow = self.wait_for_cflow_packet(self.collector, templates[0]) self.verify_cflow_data_detail(ipfix_decoder, capture, cflow, {2: 'packets', 256: 8}) # expected two templates and one cflow packet self.collector.get_capture(2) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0001") def test_L3onIP4(self): """ L3 data on IP4 datapath""" self.logger.info("FFP_TEST_START_0002") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self, intf='pg4', layer='l3', datapath='ip4') ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder, count=1) self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1) capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4) # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") cflow = self.wait_for_cflow_packet(self.collector, templates[0]) self.verify_cflow_data_detail(ipfix_decoder, capture, cflow, {1: 'octets', 2: 'packets', 8: 'src_ip', 12: 'dst_ip'}) # expected two templates and one cflow packet self.collector.get_capture(2) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0002") def test_L4onIP4(self): """ L4 data on IP4 datapath""" self.logger.info("FFP_TEST_START_0003") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self, intf='pg4', layer='l4', datapath='ip4') ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder, count=1) self.create_stream(src_if=self.pg3, dst_if=self.pg4, packets=1) capture = self.send_packets(src_if=self.pg3, dst_if=self.pg4) # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") cflow = self.wait_for_cflow_packet(self.collector, templates[0]) self.verify_cflow_data_detail(ipfix_decoder, capture, cflow, {2: 'packets', 7: 'sport', 11: 'dport'}) # expected two templates and one cflow packet self.collector.get_capture(2) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0003") def test_templatesIP6(self): """ verify templates on IP6 datapath""" self.logger.info("FFP_TEST_START_0000") self.pg_enable_capture(self.pg_interfaces) ipfix = VppCFLOW(test=self, datapath='ip6') ipfix.add_vpp_config() # template packet should arrive immediately ipfix.verify_templates(count=1) self.collector.get_capture(1) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0000") def test_L2onIP6(self): """ L2 data on IP6 datapath""" self.logger.info("FFP_TEST_START_0001") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self, intf='pg6', layer='l2', datapath='ip6') ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder, count=1) self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1, ip_ver='IPv6') capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6) # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") cflow = self.wait_for_cflow_packet(self.collector, templates[0]) self.verify_cflow_data_detail(ipfix_decoder, capture, cflow, {2: 'packets', 256: 56710}, ip_ver='v6') # expected two templates and one cflow packet self.collector.get_capture(2) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0001") def test_L3onIP6(self): """ L3 data on IP6 datapath""" self.logger.info("FFP_TEST_START_0002") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self, intf='pg6', layer='l3', datapath='ip6') ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder, count=1) self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1, ip_ver='IPv6') capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6) # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") cflow = self.wait_for_cflow_packet(self.collector, templates[0]) self.verify_cflow_data_detail(ipfix_decoder, capture, cflow, {2: 'packets', 27: 'src_ip', 28: 'dst_ip'}, ip_ver='v6') # expected two templates and one cflow packet self.collector.get_capture(2) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0002") def test_L4onIP6(self): """ L4 data on IP6 datapath""" self.logger.info("FFP_TEST_START_0003") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self, intf='pg6', layer='l4', datapath='ip6') ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder, count=1) self.create_stream(src_if=self.pg5, dst_if=self.pg6, packets=1, ip_ver='IPv6') capture = self.send_packets(src_if=self.pg5, dst_if=self.pg6) # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") cflow = self.wait_for_cflow_packet(self.collector, templates[0]) self.verify_cflow_data_detail(ipfix_decoder, capture, cflow, {2: 'packets', 7: 'sport', 11: 'dport'}, ip_ver='v6') # expected two templates and one cflow packet self.collector.get_capture(2) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0003") def test_0001(self): """ no timers, one CFLOW packet, 9 Flows inside""" self.logger.info("FFP_TEST_START_0001") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self) ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder) self.create_stream(packets=9) capture = self.send_packets() # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") cflow = self.wait_for_cflow_packet(self.collector, templates[1]) self.verify_cflow_data_notimer(ipfix_decoder, capture, [cflow]) self.collector.get_capture(4) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0001") def test_0002(self): """ no timers, two CFLOW packets (mtu=256), 3 Flows in each""" self.logger.info("FFP_TEST_START_0002") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self, mtu=256) ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately self.vapi.cli("ipfix flush") templates = ipfix.verify_templates(ipfix_decoder) self.create_stream(packets=6) capture = self.send_packets() # make sure the one packet we expect actually showed up cflows = [] self.vapi.cli("ipfix flush") cflows.append(self.wait_for_cflow_packet(self.collector, templates[1])) cflows.append(self.wait_for_cflow_packet(self.collector, templates[1])) self.verify_cflow_data_notimer(ipfix_decoder, capture, cflows) self.collector.get_capture(5) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0002") @unittest.skipUnless(running_extended_tests(), "part of extended tests") class DisableIPFIX(MethodHolder): """Disable IPFIX""" def test_0001(self): """ disable IPFIX after first packets""" self.logger.info("FFP_TEST_START_0001") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self) ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder) self.create_stream() self.send_packets() # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") self.wait_for_cflow_packet(self.collector, templates[1]) self.collector.get_capture(4) # disble IPFIX ipfix.disable_exporter() self.pg_enable_capture([self.collector]) self.send_packets() # make sure no one packet arrived in 1 minute self.vapi.cli("ipfix flush") self.wait_for_cflow_packet(self.collector, templates[1], expected=False) self.collector.get_capture(0) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0001") @unittest.skipUnless(running_extended_tests(), "part of extended tests") class ReenableIPFIX(MethodHolder): """Re-enable IPFIX""" def test_0011(self): """ disable IPFIX after first packets and re-enable after few packets """ self.logger.info("FFP_TEST_START_0001") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self) ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder) self.create_stream(packets=5) self.send_packets() # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") self.wait_for_cflow_packet(self.collector, templates[1]) self.collector.get_capture(4) # disble IPFIX ipfix.disable_exporter() self.vapi.cli("ipfix flush") self.pg_enable_capture([self.collector]) self.send_packets() # make sure no one packet arrived in active timer span self.vapi.cli("ipfix flush") self.wait_for_cflow_packet(self.collector, templates[1], expected=False) self.collector.get_capture(0) self.pg2.get_capture(5) # enable IPFIX ipfix.enable_exporter() capture = self.collector.get_capture(4) nr_templates = 0 nr_data = 0 for p in capture: self.assertTrue(p.haslayer(IPFIX)) if p.haslayer(Template): nr_templates += 1 self.assertTrue(nr_templates, 3) for p in capture: self.assertTrue(p.haslayer(IPFIX)) if p.haslayer(Data): nr_data += 1 self.assertTrue(nr_templates, 1) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0001") @unittest.skipUnless(running_extended_tests(), "part of extended tests") class DisableFP(MethodHolder): """Disable Flowprobe feature""" def test_0001(self): """ disable flowprobe feature after first packets""" self.logger.info("FFP_TEST_START_0001") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self) ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately templates = ipfix.verify_templates(ipfix_decoder) self.create_stream() self.send_packets() # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") self.wait_for_cflow_packet(self.collector, templates[1]) self.collector.get_capture(4) # disble IPFIX ipfix.disable_flowprobe_feature() self.pg_enable_capture([self.collector]) self.send_packets() # make sure no one packet arrived in active timer span self.vapi.cli("ipfix flush") self.wait_for_cflow_packet(self.collector, templates[1], expected=False) self.collector.get_capture(0) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0001") @unittest.skipUnless(running_extended_tests(), "part of extended tests") class ReenableFP(MethodHolder): """Re-enable Flowprobe feature""" def test_0001(self): """ disable flowprobe feature after first packets and re-enable after few packets """ self.logger.info("FFP_TEST_START_0001") self.pg_enable_capture(self.pg_interfaces) self.pkts = [] ipfix = VppCFLOW(test=self) ipfix.add_vpp_config() ipfix_decoder = IPFIXDecoder() # template packet should arrive immediately self.vapi.cli("ipfix flush") templates = ipfix.verify_templates(ipfix_decoder, timeout=3) self.create_stream() self.send_packets() # make sure the one packet we expect actually showed up self.vapi.cli("ipfix flush") self.wait_for_cflow_packet(self.collector, templates[1], 5) self.collector.get_capture(4) # disble FPP feature ipfix.disable_flowprobe_feature() self.pg_enable_capture([self.collector]) self.send_packets() # make sure no one packet arrived in active timer span self.vapi.cli("ipfix flush") self.wait_for_cflow_packet(self.collector, templates[1], 5, expected=False) self.collector.get_capture(0) # enable FPP feature ipfix.enable_flowprobe_feature() self.vapi.cli("ipfix flush") templates = ipfix.verify_templates(ipfix_decoder, timeout=3) self.send_packets() # make sure the next packets (templates and data) we expect actually # showed up self.vapi.cli("ipfix flush") self.wait_for_cflow_packet(self.collector, templates[1], 5) self.collector.get_capture(4) ipfix.remove_vpp_config() self.logger.info("FFP_TEST_FINISH_0001") if __name__ == '__main__': unittest.main(testRunner=VppTestRunner)