tests: replace pycodestyle with black

Drop pycodestyle for code style checking in favor of black. Black is
much faster, stable PEP8 compliant code style checker offering also
automatic formatting. It aims to be very stable and produce smallest
diffs. It's used by many small and big projects.

Running checkstyle with black takes a few seconds with a terse output.
Thus, test-checkstyle-diff is no longer necessary.

Expand scope of checkstyle to all python files in the repo, replacing
test-checkstyle with checkstyle-python.

Also, fixstyle-python is now available for automatic style formatting.

Note: python virtualenv has been consolidated in test/Makefile,
test/requirements*.txt which will eventually be moved to a central
location.  This is required to simply the automated generation of
docker executor images in the CI.

Type: improvement
Change-Id: I022a326603485f58585e879ac0f697fceefbc9c8
Signed-off-by: Klement Sekera <klement.sekera@gmail.com>
Signed-off-by: Dave Wallace <dwallacelf@gmail.com>

1 files changed, 205 insertions, 151 deletions

diff --git a/test/test_srv6_ad.py b/test/test_srv6_ad.py
index dad7c186a93..88c0b1d8074 100644
--- a/test/test_srv6_ad.py
+++ b/test/test_srv6_ad.py
@@ -7,8 +7,14 @@ from socket import AF_INET6
 from framework import VppTestCase, VppTestRunner
 from vpp_ip import DpoProto
 from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpTable
-from vpp_srv6 import SRv6LocalSIDBehaviors, VppSRv6LocalSID, VppSRv6Policy, \
-    SRv6PolicyType, VppSRv6Steering, SRv6PolicySteeringTypes
+from vpp_srv6 import (
+    SRv6LocalSIDBehaviors,
+    VppSRv6LocalSID,
+    VppSRv6Policy,
+    SRv6PolicyType,
+    VppSRv6Steering,
+    SRv6PolicySteeringTypes,
+)
 
 import scapy.compat
 from scapy.packet import Raw
@@ -20,7 +26,7 @@ from util import ppp
 
 
 class TestSRv6Ad(VppTestCase):
-    """ SRv6 Dynamic Proxy plugin Test Case """
+    """SRv6 Dynamic Proxy plugin Test Case"""
 
     @classmethod
     def setUpClass(self):
@@ -31,8 +37,7 @@ class TestSRv6Ad(VppTestCase):
         super(TestSRv6Ad, cls).tearDownClass()
 
     def setUp(self):
-        """ Perform test setup before each test case.
-        """
+        """Perform test setup before each test case."""
         super(TestSRv6Ad, self).setUp()
 
         # packet sizes, inclusive L2 overhead
@@ -42,17 +47,15 @@ class TestSRv6Ad(VppTestCase):
         self.reset_packet_infos()
 
     def tearDown(self):
-        """ Clean up test setup after each test case.
-        """
+        """Clean up test setup after each test case."""
         self.teardown_interfaces()
 
         super(TestSRv6Ad, self).tearDown()
 
-    def configure_interface(self,
-                            interface,
-                            ipv6=False, ipv4=False,
-                            ipv6_table_id=0, ipv4_table_id=0):
-        """ Configure interface.
+    def configure_interface(
+        self, interface, ipv6=False, ipv4=False, ipv6_table_id=0, ipv4_table_id=0
+    ):
+        """Configure interface.
         :param ipv6: configure IPv6 on interface
         :param ipv4: configure IPv4 on interface
         :param ipv6_table_id: FIB table_id for IPv6
@@ -71,9 +74,8 @@ class TestSRv6Ad(VppTestCase):
             interface.resolve_arp()
         interface.admin_up()
 
-    def setup_interfaces(self, ipv6=[], ipv4=[],
-                         ipv6_table_id=[], ipv4_table_id=[]):
-        """ Create and configure interfaces.
+    def setup_interfaces(self, ipv6=[], ipv4=[], ipv6_table_id=[], ipv4_table_id=[]):
+        """Create and configure interfaces.
 
         :param ipv6: list of interface IPv6 capabilities
         :param ipv4: list of interface IPv4 capabilities
@@ -108,9 +110,9 @@ class TestSRv6Ad(VppTestCase):
         # setup all interfaces
         for i in range(count):
             intf = self.pg_interfaces[i]
-            self.configure_interface(intf,
-                                     ipv6[i], ipv4[i],
-                                     ipv6_table_id[i], ipv4_table_id[i])
+            self.configure_interface(
+                intf, ipv6[i], ipv4[i], ipv6_table_id[i], ipv4_table_id[i]
+            )
 
         if any(ipv6):
             self.logger.debug(self.vapi.cli("show ip6 neighbors"))
@@ -122,8 +124,7 @@ class TestSRv6Ad(VppTestCase):
         return self.pg_interfaces
 
     def teardown_interfaces(self):
-        """ Unconfigure and bring down interface.
-        """
+        """Unconfigure and bring down interface."""
         self.logger.debug("Tearing down interfaces")
         # tear down all interfaces
         # AFAIK they cannot be deleted
@@ -135,10 +136,9 @@ class TestSRv6Ad(VppTestCase):
             i.set_table_ip6(0)
 
     def test_SRv6_End_AD_IPv6(self):
-        """ Test SRv6 End.AD behavior with IPv6 traffic.
-        """
-        self.src_addr = 'a0::'
-        self.sid_list = ['a1::', 'a2::a6', 'a3::']
+        """Test SRv6 End.AD behavior with IPv6 traffic."""
+        self.src_addr = "a0::"
+        self.sid_list = ["a1::", "a2::a6", "a3::"]
         self.test_sid_index = 1
 
         # send traffic to one destination interface
@@ -146,19 +146,32 @@ class TestSRv6Ad(VppTestCase):
         self.setup_interfaces(ipv6=[True, True])
 
         # configure route to next segment
-        route = VppIpRoute(self, self.sid_list[self.test_sid_index + 1], 128,
-                           [VppRoutePath(self.pg0.remote_ip6,
-                                         self.pg0.sw_if_index,
-                                         proto=DpoProto.DPO_PROTO_IP6)])
+        route = VppIpRoute(
+            self,
+            self.sid_list[self.test_sid_index + 1],
+            128,
+            [
+                VppRoutePath(
+                    self.pg0.remote_ip6,
+                    self.pg0.sw_if_index,
+                    proto=DpoProto.DPO_PROTO_IP6,
+                )
+            ],
+        )
         route.add_vpp_config()
 
         # configure SRv6 localSID behavior
-        cli_str = "sr localsid address " + \
-                  self.sid_list[self.test_sid_index] + \
-                  " behavior end.ad" + \
-                  " nh " + self.pg1.remote_ip6 + \
-                  " oif " + self.pg1.name + \
-                  " iif " + self.pg1.name
+        cli_str = (
+            "sr localsid address "
+            + self.sid_list[self.test_sid_index]
+            + " behavior end.ad"
+            + " nh "
+            + self.pg1.remote_ip6
+            + " oif "
+            + self.pg1.name
+            + " iif "
+            + self.pg1.name
+        )
         self.vapi.cli(cli_str)
 
         # log the localsids
@@ -171,15 +184,18 @@ class TestSRv6Ad(VppTestCase):
         packet_header1 = self.create_packet_header_IPv6_SRH_IPv6(
             srcaddr=self.src_addr,
             sidlist=self.sid_list[::-1],
-            segleft=len(self.sid_list) - self.test_sid_index - 1)
+            segleft=len(self.sid_list) - self.test_sid_index - 1,
+        )
 
         # generate packets (pg0->pg1)
-        pkts1 = self.create_stream(self.pg0, self.pg1, packet_header1,
-                                   self.pg_packet_sizes, count)
+        pkts1 = self.create_stream(
+            self.pg0, self.pg1, packet_header1, self.pg_packet_sizes, count
+        )
 
         # send packets and verify received packets
-        self.send_and_verify_pkts(self.pg0, pkts1, self.pg1,
-                                  self.compare_rx_tx_packet_End_AD_IPv6_out)
+        self.send_and_verify_pkts(
+            self.pg0, pkts1, self.pg1, self.compare_rx_tx_packet_End_AD_IPv6_out
+        )
 
         # log the localsid counters
         self.logger.info(self.vapi.cli("show sr localsid"))
@@ -188,26 +204,27 @@ class TestSRv6Ad(VppTestCase):
         packet_header2 = self.create_packet_header_IPv6()
 
         # generate returning packets (pg1->pg0)
-        pkts2 = self.create_stream(self.pg1, self.pg0, packet_header2,
-                                   self.pg_packet_sizes, count)
+        pkts2 = self.create_stream(
+            self.pg1, self.pg0, packet_header2, self.pg_packet_sizes, count
+        )
 
         # send packets and verify received packets
-        self.send_and_verify_pkts(self.pg1, pkts2, self.pg0,
-                                  self.compare_rx_tx_packet_End_AD_IPv6_in)
+        self.send_and_verify_pkts(
+            self.pg1, pkts2, self.pg0, self.compare_rx_tx_packet_End_AD_IPv6_in
+        )
 
         # log the localsid counters
         self.logger.info(self.vapi.cli("show sr localsid"))
 
         # remove SRv6 localSIDs
-        cli_str = "sr localsid del address " + \
-                  self.sid_list[self.test_sid_index]
+        cli_str = "sr localsid del address " + self.sid_list[self.test_sid_index]
         self.vapi.cli(cli_str)
 
         # cleanup interfaces
         self.teardown_interfaces()
 
     def compare_rx_tx_packet_End_AD_IPv6_out(self, tx_pkt, rx_pkt):
-        """ Compare input and output packet after passing End.AD with IPv6
+        """Compare input and output packet after passing End.AD with IPv6
 
         :param tx_pkt: transmitted packet
         :param rx_pkt: received packet
@@ -232,7 +249,7 @@ class TestSRv6Ad(VppTestCase):
         self.logger.debug("packet verification: SUCCESS")
 
     def compare_rx_tx_packet_End_AD_IPv6_in(self, tx_pkt, rx_pkt):
-        """ Compare input and output packet after passing End.AD
+        """Compare input and output packet after passing End.AD
 
         :param tx_pkt: transmitted packet
         :param rx_pkt: received packet
@@ -253,8 +270,7 @@ class TestSRv6Ad(VppTestCase):
         # rx'ed seglist should be equal to SID-list in reversed order
         self.assertEqual(rx_srh.addresses, self.sid_list[::-1])
         # segleft should be equal to previous segleft value minus 1
-        self.assertEqual(rx_srh.segleft,
-                         len(self.sid_list) - self.test_sid_index - 2)
+        self.assertEqual(rx_srh.segleft, len(self.sid_list) - self.test_sid_index - 2)
         # lastentry should be equal to the SID-list length minus 1
         self.assertEqual(rx_srh.lastentry, len(self.sid_list) - 1)
 
@@ -269,10 +285,9 @@ class TestSRv6Ad(VppTestCase):
         self.logger.debug("packet verification: SUCCESS")
 
     def test_SRv6_End_AD_IPv4(self):
-        """ Test SRv6 End.AD behavior with IPv4 traffic.
-        """
-        self.src_addr = 'a0::'
-        self.sid_list = ['a1::', 'a2::a4', 'a3::']
+        """Test SRv6 End.AD behavior with IPv4 traffic."""
+        self.src_addr = "a0::"
+        self.sid_list = ["a1::", "a2::a4", "a3::"]
         self.test_sid_index = 1
 
         # send traffic to one destination interface
@@ -280,19 +295,32 @@ class TestSRv6Ad(VppTestCase):
         self.setup_interfaces(ipv6=[True, False], ipv4=[False, True])
 
         # configure route to next segment
-        route = VppIpRoute(self, self.sid_list[self.test_sid_index + 1], 128,
-                           [VppRoutePath(self.pg0.remote_ip6,
-                                         self.pg0.sw_if_index,
-                                         proto=DpoProto.DPO_PROTO_IP6)])
+        route = VppIpRoute(
+            self,
+            self.sid_list[self.test_sid_index + 1],
+            128,
+            [
+                VppRoutePath(
+                    self.pg0.remote_ip6,
+                    self.pg0.sw_if_index,
+                    proto=DpoProto.DPO_PROTO_IP6,
+                )
+            ],
+        )
         route.add_vpp_config()
 
         # configure SRv6 localSID behavior
-        cli_str = "sr localsid address " + \
-                  self.sid_list[self.test_sid_index] + \
-                  " behavior end.ad" + \
-                  " nh " + self.pg1.remote_ip4 + \
-                  " oif " + self.pg1.name + \
-                  " iif " + self.pg1.name
+        cli_str = (
+            "sr localsid address "
+            + self.sid_list[self.test_sid_index]
+            + " behavior end.ad"
+            + " nh "
+            + self.pg1.remote_ip4
+            + " oif "
+            + self.pg1.name
+            + " iif "
+            + self.pg1.name
+        )
         self.vapi.cli(cli_str)
 
         # log the localsids
@@ -305,15 +333,18 @@ class TestSRv6Ad(VppTestCase):
         packet_header1 = self.create_packet_header_IPv6_SRH_IPv4(
             srcaddr=self.src_addr,
             sidlist=self.sid_list[::-1],
-            segleft=len(self.sid_list) - self.test_sid_index - 1)
+            segleft=len(self.sid_list) - self.test_sid_index - 1,
+        )
 
         # generate packets (pg0->pg1)
-        pkts1 = self.create_stream(self.pg0, self.pg1, packet_header1,
-                                   self.pg_packet_sizes, count)
+        pkts1 = self.create_stream(
+            self.pg0, self.pg1, packet_header1, self.pg_packet_sizes, count
+        )
 
         # send packets and verify received packets
-        self.send_and_verify_pkts(self.pg0, pkts1, self.pg1,
-                                  self.compare_rx_tx_packet_End_AD_IPv4_out)
+        self.send_and_verify_pkts(
+            self.pg0, pkts1, self.pg1, self.compare_rx_tx_packet_End_AD_IPv4_out
+        )
 
         # log the localsid counters
         self.logger.info(self.vapi.cli("show sr localsid"))
@@ -322,26 +353,27 @@ class TestSRv6Ad(VppTestCase):
         packet_header2 = self.create_packet_header_IPv4()
 
         # generate returning packets (pg1->pg0)
-        pkts2 = self.create_stream(self.pg1, self.pg0, packet_header2,
-                                   self.pg_packet_sizes, count)
+        pkts2 = self.create_stream(
+            self.pg1, self.pg0, packet_header2, self.pg_packet_sizes, count
+        )
 
         # send packets and verify received packets
-        self.send_and_verify_pkts(self.pg1, pkts2, self.pg0,
-                                  self.compare_rx_tx_packet_End_AD_IPv4_in)
+        self.send_and_verify_pkts(
+            self.pg1, pkts2, self.pg0, self.compare_rx_tx_packet_End_AD_IPv4_in
+        )
 
         # log the localsid counters
         self.logger.info(self.vapi.cli("show sr localsid"))
 
         # remove SRv6 localSIDs
-        cli_str = "sr localsid del address " + \
-                  self.sid_list[self.test_sid_index]
+        cli_str = "sr localsid del address " + self.sid_list[self.test_sid_index]
         self.vapi.cli(cli_str)
 
         # cleanup interfaces
         self.teardown_interfaces()
 
     def compare_rx_tx_packet_End_AD_IPv4_out(self, tx_pkt, rx_pkt):
-        """ Compare input and output packet after passing End.AD with IPv4
+        """Compare input and output packet after passing End.AD with IPv4
 
         :param tx_pkt: transmitted packet
         :param rx_pkt: received packet
@@ -371,7 +403,7 @@ class TestSRv6Ad(VppTestCase):
         self.logger.debug("packet verification: SUCCESS")
 
     def compare_rx_tx_packet_End_AD_IPv4_in(self, tx_pkt, rx_pkt):
-        """ Compare input and output packet after passing End.AD
+        """Compare input and output packet after passing End.AD
 
         :param tx_pkt: transmitted packet
         :param rx_pkt: received packet
@@ -392,8 +424,7 @@ class TestSRv6Ad(VppTestCase):
         # rx'ed seglist should be equal to SID-list in reversed order
         self.assertEqual(rx_srh.addresses, self.sid_list[::-1])
         # segleft should be equal to previous segleft value minus 1
-        self.assertEqual(rx_srh.segleft,
-                         len(self.sid_list) - self.test_sid_index - 2)
+        self.assertEqual(rx_srh.segleft, len(self.sid_list) - self.test_sid_index - 2)
         # lastentry should be equal to the SID-list length minus 1
         self.assertEqual(rx_srh.lastentry, len(self.sid_list) - 1)
 
@@ -411,10 +442,9 @@ class TestSRv6Ad(VppTestCase):
         self.logger.debug("packet verification: SUCCESS")
 
     def test_SRv6_End_AD_L2(self):
-        """ Test SRv6 End.AD behavior with L2 traffic.
-        """
-        self.src_addr = 'a0::'
-        self.sid_list = ['a1::', 'a2::a4', 'a3::']
+        """Test SRv6 End.AD behavior with L2 traffic."""
+        self.src_addr = "a0::"
+        self.sid_list = ["a1::", "a2::a4", "a3::"]
         self.test_sid_index = 1
 
         # send traffic to one destination interface
@@ -422,18 +452,30 @@ class TestSRv6Ad(VppTestCase):
         self.setup_interfaces(ipv6=[True, False])
 
         # configure route to next segment
-        route = VppIpRoute(self, self.sid_list[self.test_sid_index + 1], 128,
-                           [VppRoutePath(self.pg0.remote_ip6,
-                                         self.pg0.sw_if_index,
-                                         proto=DpoProto.DPO_PROTO_IP6)])
+        route = VppIpRoute(
+            self,
+            self.sid_list[self.test_sid_index + 1],
+            128,
+            [
+                VppRoutePath(
+                    self.pg0.remote_ip6,
+                    self.pg0.sw_if_index,
+                    proto=DpoProto.DPO_PROTO_IP6,
+                )
+            ],
+        )
         route.add_vpp_config()
 
         # configure SRv6 localSID behavior
-        cli_str = "sr localsid address " + \
-                  self.sid_list[self.test_sid_index] + \
-                  " behavior end.ad" + \
-                  " oif " + self.pg1.name + \
-                  " iif " + self.pg1.name
+        cli_str = (
+            "sr localsid address "
+            + self.sid_list[self.test_sid_index]
+            + " behavior end.ad"
+            + " oif "
+            + self.pg1.name
+            + " iif "
+            + self.pg1.name
+        )
         self.vapi.cli(cli_str)
 
         # log the localsids
@@ -447,15 +489,18 @@ class TestSRv6Ad(VppTestCase):
             srcaddr=self.src_addr,
             sidlist=self.sid_list[::-1],
             segleft=len(self.sid_list) - self.test_sid_index - 1,
-            vlan=0)
+            vlan=0,
+        )
 
         # generate packets (pg0->pg1)
-        pkts1 = self.create_stream(self.pg0, self.pg1, packet_header1,
-                                   self.pg_packet_sizes, count)
+        pkts1 = self.create_stream(
+            self.pg0, self.pg1, packet_header1, self.pg_packet_sizes, count
+        )
 
         # send packets and verify received packets
-        self.send_and_verify_pkts(self.pg0, pkts1, self.pg1,
-                                  self.compare_rx_tx_packet_End_AD_L2_out)
+        self.send_and_verify_pkts(
+            self.pg0, pkts1, self.pg1, self.compare_rx_tx_packet_End_AD_L2_out
+        )
 
         # log the localsid counters
         self.logger.info(self.vapi.cli("show sr localsid"))
@@ -464,26 +509,27 @@ class TestSRv6Ad(VppTestCase):
         packet_header2 = self.create_packet_header_L2()
 
         # generate returning packets (pg1->pg0)
-        pkts2 = self.create_stream(self.pg1, self.pg0, packet_header2,
-                                   self.pg_packet_sizes, count)
+        pkts2 = self.create_stream(
+            self.pg1, self.pg0, packet_header2, self.pg_packet_sizes, count
+        )
 
         # send packets and verify received packets
-        self.send_and_verify_pkts(self.pg1, pkts2, self.pg0,
-                                  self.compare_rx_tx_packet_End_AD_L2_in)
+        self.send_and_verify_pkts(
+            self.pg1, pkts2, self.pg0, self.compare_rx_tx_packet_End_AD_L2_in
+        )
 
         # log the localsid counters
         self.logger.info(self.vapi.cli("show sr localsid"))
 
         # remove SRv6 localSIDs
-        cli_str = "sr localsid del address " + \
-                  self.sid_list[self.test_sid_index]
+        cli_str = "sr localsid del address " + self.sid_list[self.test_sid_index]
         self.vapi.cli(cli_str)
 
         # cleanup interfaces
         self.teardown_interfaces()
 
     def compare_rx_tx_packet_End_AD_L2_out(self, tx_pkt, rx_pkt):
-        """ Compare input and output packet after passing End.AD with L2
+        """Compare input and output packet after passing End.AD with L2
 
         :param tx_pkt: transmitted packet
         :param rx_pkt: received packet
@@ -506,7 +552,7 @@ class TestSRv6Ad(VppTestCase):
         self.logger.debug("packet verification: SUCCESS")
 
     def compare_rx_tx_packet_End_AD_L2_in(self, tx_pkt, rx_pkt):
-        """ Compare input and output packet after passing End.AD
+        """Compare input and output packet after passing End.AD
 
         :param tx_pkt: transmitted packet
         :param rx_pkt: received packet
@@ -528,8 +574,7 @@ class TestSRv6Ad(VppTestCase):
         # rx'ed seglist should be equal to SID-list in reversed order
         self.assertEqual(rx_srh.addresses, self.sid_list[::-1])
         # segleft should be equal to previous segleft value minus 1
-        self.assertEqual(rx_srh.segleft,
-                         len(self.sid_list) - self.test_sid_index - 2)
+        self.assertEqual(rx_srh.segleft, len(self.sid_list) - self.test_sid_index - 2)
         # lastentry should be equal to the SID-list length minus 1
         self.assertEqual(rx_srh.lastentry, len(self.sid_list) - 1)
 
@@ -539,8 +584,7 @@ class TestSRv6Ad(VppTestCase):
 
         self.logger.debug("packet verification: SUCCESS")
 
-    def create_stream(self, src_if, dst_if, packet_header, packet_sizes,
-                      count):
+    def create_stream(self, src_if, dst_if, packet_header, packet_sizes, count):
         """Create SRv6 input packet stream for defined interface.
 
         :param VppInterface src_if: Interface to create packet stream for
@@ -557,15 +601,17 @@ class TestSRv6Ad(VppTestCase):
         pkts = []
         for i in range(0, count - 1):
             payload_info = self.create_packet_info(src_if, dst_if)
-            self.logger.debug(
-                "Creating packet with index %d" % (payload_info.index))
+            self.logger.debug("Creating packet with index %d" % (payload_info.index))
             payload = self.info_to_payload(payload_info)
             # add L2 header if not yet provided in packet_header
-            if packet_header.getlayer(0).name == 'Ethernet':
+            if packet_header.getlayer(0).name == "Ethernet":
                 p = packet_header / Raw(payload)
             else:
-                p = Ether(dst=src_if.local_mac, src=src_if.remote_mac) / \
-                    packet_header / Raw(payload)
+                p = (
+                    Ether(dst=src_if.local_mac, src=src_if.remote_mac)
+                    / packet_header
+                    / Raw(payload)
+                )
             size = packet_sizes[i % len(packet_sizes)]
             self.logger.debug("Packet size %d" % (size))
             self.extend_packet(p, size)
@@ -618,7 +664,7 @@ class TestSRv6Ad(VppTestCase):
         UDP source port and destination port are 1234
         """
 
-        p = IPv6(src='1234::1', dst='4321::1') / UDP(sport=1234, dport=1234)
+        p = IPv6(src="1234::1", dst="4321::1") / UDP(sport=1234, dport=1234)
         return p
 
     def create_packet_header_IPv6_SRH_IPv6(self, srcaddr, sidlist, segleft):
@@ -636,11 +682,12 @@ class TestSRv6Ad(VppTestCase):
         UDP source port and destination port are 1234
         """
 
-        p = IPv6(src=srcaddr, dst=sidlist[segleft]) / \
-            IPv6ExtHdrSegmentRouting(addresses=sidlist,
-                                     segleft=segleft, nh=41) / \
-            IPv6(src='1234::1', dst='4321::1') / \
-            UDP(sport=1234, dport=1234)
+        p = (
+            IPv6(src=srcaddr, dst=sidlist[segleft])
+            / IPv6ExtHdrSegmentRouting(addresses=sidlist, segleft=segleft, nh=41)
+            / IPv6(src="1234::1", dst="4321::1")
+            / UDP(sport=1234, dport=1234)
+        )
         return p
 
     def create_packet_header_IPv4(self):
@@ -653,7 +700,7 @@ class TestSRv6Ad(VppTestCase):
         UDP source port and destination port are 1234
         """
 
-        p = IP(src='123.1.1.1', dst='124.1.1.1') / UDP(sport=1234, dport=1234)
+        p = IP(src="123.1.1.1", dst="124.1.1.1") / UDP(sport=1234, dport=1234)
         return p
 
     def create_packet_header_IPv6_SRH_IPv4(self, srcaddr, sidlist, segleft):
@@ -671,11 +718,12 @@ class TestSRv6Ad(VppTestCase):
         UDP source port and destination port are 1234
         """
 
-        p = IPv6(src=srcaddr, dst=sidlist[segleft]) / \
-            IPv6ExtHdrSegmentRouting(addresses=sidlist,
-                                     segleft=segleft, nh=4) / \
-            IP(src='123.1.1.1', dst='124.1.1.1') / \
-            UDP(sport=1234, dport=1234)
+        p = (
+            IPv6(src=srcaddr, dst=sidlist[segleft])
+            / IPv6ExtHdrSegmentRouting(addresses=sidlist, segleft=segleft, nh=4)
+            / IP(src="123.1.1.1", dst="124.1.1.1")
+            / UDP(sport=1234, dport=1234)
+        )
         return p
 
     def create_packet_header_L2(self, vlan=0):
@@ -686,7 +734,7 @@ class TestSRv6Ad(VppTestCase):
         # Note: the dst addr ('00:55:44:33:22:11') is used in
         # the compare function compare_rx_tx_packet_T_Encaps_L2
         # to detect presence of L2 in SRH payload
-        p = Ether(src='00:11:22:33:44:55', dst='00:55:44:33:22:11')
+        p = Ether(src="00:11:22:33:44:55", dst="00:55:44:33:22:11")
         etype = 0x8137  # IPX
         if vlan:
             # add 802.1q layer
@@ -695,8 +743,7 @@ class TestSRv6Ad(VppTestCase):
             p.type = etype
         return p
 
-    def create_packet_header_IPv6_SRH_L2(self, srcaddr, sidlist, segleft,
-                                         vlan=0):
+    def create_packet_header_IPv6_SRH_L2(self, srcaddr, sidlist, segleft, vlan=0):
         """Create packet header: L2 encapsulated in SRv6:
         IPv6 header with SRH, L2
 
@@ -708,7 +755,7 @@ class TestSRv6Ad(VppTestCase):
         IPv6 source address is set to srcaddr
         IPv6 destination address is set to sidlist[segleft]
         """
-        eth = Ether(src='00:11:22:33:44:55', dst='00:55:44:33:22:11')
+        eth = Ether(src="00:11:22:33:44:55", dst="00:55:44:33:22:11")
         etype = 0x8137  # IPX
         if vlan:
             # add 802.1q layer
@@ -716,15 +763,15 @@ class TestSRv6Ad(VppTestCase):
         else:
             eth.type = etype
 
-        p = IPv6(src=srcaddr, dst=sidlist[segleft]) / \
-            IPv6ExtHdrSegmentRouting(addresses=sidlist,
-                                     segleft=segleft, nh=143) / \
-            eth
+        p = (
+            IPv6(src=srcaddr, dst=sidlist[segleft])
+            / IPv6ExtHdrSegmentRouting(addresses=sidlist, segleft=segleft, nh=143)
+            / eth
+        )
         return p
 
     def get_payload_info(self, packet):
-        """ Extract the payload_info from the packet
-        """
+        """Extract the payload_info from the packet"""
         # in most cases, payload_info is in packet[Raw]
         # but packet[Raw] gives the complete payload
         # (incl L2 header) for the T.Encaps L2 case
@@ -736,7 +783,8 @@ class TestSRv6Ad(VppTestCase):
             # take packet[Raw], convert it to an Ether layer
             # and then extract Raw from it
             payload_info = self.payload_to_info(
-                Ether(scapy.compat.raw(packet[Raw]))[Raw])
+                Ether(scapy.compat.raw(packet[Raw]))[Raw]
+            )
 
         return payload_info
 
@@ -749,8 +797,10 @@ class TestSRv6Ad(VppTestCase):
         :param capture: captured packets
         :param compare_func: function to compare in and out packet
         """
-        self.logger.info("Verifying capture on interface %s using function %s"
-                         % (dst_if.name, compare_func.__name__))
+        self.logger.info(
+            "Verifying capture on interface %s using function %s"
+            % (dst_if.name, compare_func.__name__)
+        )
 
         last_info = dict()
         for i in self.pg_interfaces:
@@ -763,19 +813,19 @@ class TestSRv6Ad(VppTestCase):
                 payload_info = self.get_payload_info(packet)
                 packet_index = payload_info.index
 
-                self.logger.debug("Verifying packet with index %d"
-                                  % (packet_index))
+                self.logger.debug("Verifying packet with index %d" % (packet_index))
                 # packet should have arrived on the expected interface
                 self.assertEqual(payload_info.dst, dst_sw_if_index)
                 self.logger.debug(
-                    "Got packet on interface %s: src=%u (idx=%u)" %
-                    (dst_if.name, payload_info.src, packet_index))
+                    "Got packet on interface %s: src=%u (idx=%u)"
+                    % (dst_if.name, payload_info.src, packet_index)
+                )
 
                 # search for payload_info with same src and dst if_index
                 # this will give us the transmitted packet
                 next_info = self.get_next_packet_info_for_interface2(
-                    payload_info.src, dst_sw_if_index,
-                    last_info[payload_info.src])
+                    payload_info.src, dst_sw_if_index, last_info[payload_info.src]
+                )
                 last_info[payload_info.src] = next_info
                 # next_info should not be None
                 self.assertTrue(next_info is not None)
@@ -784,8 +834,9 @@ class TestSRv6Ad(VppTestCase):
                 # data field of next_info contains the tx packet
                 txed_packet = next_info.data
 
-                self.logger.debug(ppp("Transmitted packet:",
-                                      txed_packet))  # ppp=Pretty Print Packet
+                self.logger.debug(
+                    ppp("Transmitted packet:", txed_packet)
+                )  # ppp=Pretty Print Packet
 
                 self.logger.debug(ppp("Received packet:", packet))
 
@@ -799,11 +850,14 @@ class TestSRv6Ad(VppTestCase):
         # have all expected packets arrived?
         for i in self.pg_interfaces:
             remaining_packet = self.get_next_packet_info_for_interface2(
-                i.sw_if_index, dst_sw_if_index, last_info[i.sw_if_index])
-            self.assertTrue(remaining_packet is None,
-                            "Interface %s: Packet expected from interface %s "
-                            "didn't arrive" % (dst_if.name, i.name))
+                i.sw_if_index, dst_sw_if_index, last_info[i.sw_if_index]
+            )
+            self.assertTrue(
+                remaining_packet is None,
+                "Interface %s: Packet expected from interface %s "
+                "didn't arrive" % (dst_if.name, i.name),
+            )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main(testRunner=VppTestRunner)