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, 442 insertions, 353 deletions

diff --git a/test/test_acl_plugin_macip.py b/test/test_acl_plugin_macip.py
index 5353c16d331..6a1ba589182 100644
--- a/test/test_acl_plugin_macip.py
+++ b/test/test_acl_plugin_macip.py
@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 from __future__ import print_function
+
 """ACL plugin - MACIP tests
 """
 import binascii
@@ -20,10 +21,21 @@ from scapy.layers.inet6 import IPv6
 from framework import VppTestCase, VppTestRunner
 from vpp_lo_interface import VppLoInterface
 from vpp_l2 import L2_PORT_TYPE
-from vpp_sub_interface import L2_VTR_OP, VppSubInterface, VppDot1QSubint, \
-    VppDot1ADSubint
-from vpp_acl import AclRule, VppAcl, VppAclInterface, VppEtypeWhitelist, \
-    VppMacipAclInterface, VppMacipAcl, MacipRule
+from vpp_sub_interface import (
+    L2_VTR_OP,
+    VppSubInterface,
+    VppDot1QSubint,
+    VppDot1ADSubint,
+)
+from vpp_acl import (
+    AclRule,
+    VppAcl,
+    VppAclInterface,
+    VppEtypeWhitelist,
+    VppMacipAclInterface,
+    VppMacipAcl,
+    MacipRule,
+)
 from vpp_papi import MACAddress
 
 
@@ -79,16 +91,13 @@ class MethodHolder(VppTestCase):
                 VppDot1QSubint(cls, cls.pg1, 10),
                 VppDot1ADSubint(cls, cls.pg2, 20, 300, 400),
                 VppDot1QSubint(cls, cls.pg3, 30),
-                VppDot1ADSubint(cls, cls.pg3, 40, 600, 700)]
+                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.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)
@@ -99,16 +108,22 @@ class MethodHolder(VppTestCase):
 
             # Create BD with MAC learning enabled and put interfaces to this BD
             cls.vapi.sw_interface_set_l2_bridge(
-                rx_sw_if_index=cls.loop0.sw_if_index, bd_id=cls.bd_id,
-                port_type=L2_PORT_TYPE.BVI)
+                rx_sw_if_index=cls.loop0.sw_if_index,
+                bd_id=cls.bd_id,
+                port_type=L2_PORT_TYPE.BVI,
+            )
             cls.vapi.sw_interface_set_l2_bridge(
-                rx_sw_if_index=cls.pg0.sw_if_index, bd_id=cls.bd_id)
+                rx_sw_if_index=cls.pg0.sw_if_index, bd_id=cls.bd_id
+            )
             cls.vapi.sw_interface_set_l2_bridge(
-                rx_sw_if_index=cls.pg1.sw_if_index, bd_id=cls.bd_id)
+                rx_sw_if_index=cls.pg1.sw_if_index, bd_id=cls.bd_id
+            )
             cls.vapi.sw_interface_set_l2_bridge(
-                rx_sw_if_index=cls.subifs[0].sw_if_index, bd_id=cls.bd_id)
+                rx_sw_if_index=cls.subifs[0].sw_if_index, bd_id=cls.bd_id
+            )
             cls.vapi.sw_interface_set_l2_bridge(
-                rx_sw_if_index=cls.subifs[1].sw_if_index, bd_id=cls.bd_id)
+                rx_sw_if_index=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()
@@ -122,7 +137,7 @@ class MethodHolder(VppTestCase):
             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 = 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)
 
@@ -198,18 +213,19 @@ class MethodHolder(VppTestCase):
                     """
         return acls
 
-    def create_rules(self, mac_type=EXACT_MAC, ip_type=EXACT_IP,
-                     acl_count=1, rules_count=None):
+    def create_rules(
+        self, mac_type=EXACT_MAC, ip_type=EXACT_IP, acl_count=1, rules_count=None
+    ):
         acls = []
         if rules_count is None:
             rules_count = [1]
         src_mac = int("220000dead00", 16)
-        for acl in range(2, (acl_count+1) * 2):
+        for acl in range(2, (acl_count + 1) * 2):
             rules = []
             host = random.choice(self.loop0.remote_hosts)
             is_ip6 = acl % 2
-            ip4 = host.ip4.split('.')
-            ip6 = list(unpack('<16B', inet_pton(AF_INET6, host.ip6)))
+            ip4 = host.ip4.split(".")
+            ip6 = list(unpack("<16B", inet_pton(AF_INET6, host.ip6)))
 
             if ip_type == self.EXACT_IP:
                 prefix_len4 = 32
@@ -241,11 +257,12 @@ class MethodHolder(VppTestCase):
                 if mac_type == self.WILD_MAC:
                     mac = "00:00:00:00:00:00"
                 elif mac_type == self.OUI_MAC:
-                    mac = ':'.join(re.findall('..', '{:02x}'.format(
-                        src_mac))[:3])+":00:00:00"
+                    mac = (
+                        ":".join(re.findall("..", "{:02x}".format(src_mac))[:3])
+                        + ":00:00:00"
+                    )
                 else:
-                    mac = ':'.join(re.findall(
-                        '..', '{:02x}'.format(src_mac)))
+                    mac = ":".join(re.findall("..", "{:02x}".format(src_mac)))
 
                 if ip_type == self.EXACT_IP:
                     ip4[3] = random.randint(100, 200)
@@ -255,14 +272,16 @@ class MethodHolder(VppTestCase):
                     ip4[3] = 0
                     ip6[7] = random.randint(100, 200)
                     ip6[15] = 0
-                ip_pack = b''
+                ip_pack = b""
                 for j in range(0, len(ip)):
-                    ip_pack += pack('<B', int(ip[j]))
-
-                rule = MacipRule(is_permit=self.PERMIT,
-                                 src_prefix=ip_network((ip_pack, ip_len)),
-                                 src_mac=MACAddress(mac).packed,
-                                 src_mac_mask=MACAddress(mask).packed)
+                    ip_pack += pack("<B", int(ip[j]))
+
+                rule = MacipRule(
+                    is_permit=self.PERMIT,
+                    src_prefix=ip_network((ip_pack, ip_len)),
+                    src_mac=MACAddress(mac).packed,
+                    src_mac_mask=MACAddress(mask).packed,
+                )
                 rules.append(rule)
                 if ip_type == self.WILD_IP:
                     break
@@ -281,8 +300,8 @@ class MethodHolder(VppTestCase):
 
     def verify_macip_acls(self, acl_count, rules_count, expected_count=2):
         reply = self.macip_acl_dump_debug()
-        for acl in range(2, (acl_count+1) * 2):
-            self.assertEqual(reply[acl - 2].count, rules_count[acl//2-1])
+        for acl in range(2, (acl_count + 1) * 2):
+            self.assertEqual(reply[acl - 2].count, rules_count[acl // 2 - 1])
 
         self.vapi.macip_acl_interface_get()
 
@@ -292,8 +311,17 @@ class MethodHolder(VppTestCase):
         reply = self.vapi.macip_acl_interface_get()
         self.assertEqual(reply.count, expected_count)
 
-    def create_stream(self, mac_type, ip_type, packet_count,
-                      src_if, dst_if, traffic, is_ip6, tags=PERMIT_TAGS):
+    def create_stream(
+        self,
+        mac_type,
+        ip_type,
+        packet_count,
+        src_if,
+        dst_if,
+        traffic,
+        is_ip6,
+        tags=PERMIT_TAGS,
+    ):
         # exact MAC and exact IP
         # exact MAC and subnet of IPs
         # exact MAC and wildcard IP
@@ -329,7 +357,7 @@ class MethodHolder(VppTestCase):
             if traffic == self.BRIDGED:
                 if is_permit:
                     src_mac = remote_dst_host._mac
-                    dst_mac = 'de:ad:00:00:00:00'
+                    dst_mac = "de:ad:00:00:00:00"
                     src_ip4 = remote_dst_host.ip4
                     dst_ip4 = src_if.remote_ip4
                     src_ip6 = remote_dst_host.ip6
@@ -337,8 +365,8 @@ class MethodHolder(VppTestCase):
                     ip_permit = src_ip6 if is_ip6 else src_ip4
                     mac_permit = src_mac
                 if denyMAC:
-                    mac = src_mac.split(':')
-                    mac[0] = format(int(mac[0], 16)+1, "02x")
+                    mac = src_mac.split(":")
+                    mac[0] = format(int(mac[0], 16) + 1, "02x")
                     src_mac = ":".join(mac)
                     if is_ip6:
                         src_ip6 = ip_permit
@@ -362,7 +390,7 @@ class MethodHolder(VppTestCase):
                     ip_permit = src_ip6 if is_ip6 else src_ip4
                     mac_permit = src_mac
                 if denyMAC:
-                    mac = src_mac.split(':')
+                    mac = src_mac.split(":")
                     mac[0] = format(int(mac[0], 16) + 1, "02x")
                     src_mac = ":".join(mac)
                     if is_ip6:
@@ -385,7 +413,7 @@ class MethodHolder(VppTestCase):
                 payload = "to be blocked"
 
             if mac_type == self.WILD_MAC:
-                mac = src_mac.split(':')
+                mac = src_mac.split(":")
                 for i in range(1, 5):
                     mac[i] = format(random.randint(0, 255), "02x")
                 src_mac = ":".join(mac)
@@ -395,7 +423,7 @@ class MethodHolder(VppTestCase):
             ip_rule = src_ip6 if is_ip6 else src_ip4
             if is_ip6:
                 if ip_type != self.EXACT_IP:
-                    sub_ip = list(unpack('<16B', inet_pton(AF_INET6, ip_rule)))
+                    sub_ip = list(unpack("<16B", inet_pton(AF_INET6, ip_rule)))
                     if ip_type == self.WILD_IP:
                         sub_ip[0] = random.randint(240, 254)
                         sub_ip[1] = random.randint(230, 239)
@@ -406,13 +434,12 @@ class MethodHolder(VppTestCase):
                             sub_ip[2] = int(sub_ip[2]) + 1
                         sub_ip[14] = random.randint(100, 199)
                         sub_ip[15] = random.randint(200, 255)
-                    packed_src_ip6 = b''.join(
-                        [scapy.compat.chb(x) for x in sub_ip])
+                    packed_src_ip6 = b"".join([scapy.compat.chb(x) for x in sub_ip])
                     src_ip6 = inet_ntop(AF_INET6, packed_src_ip6)
                 packet /= IPv6(src=src_ip6, dst=dst_ip6)
             else:
                 if ip_type != self.EXACT_IP:
-                    sub_ip = ip_rule.split('.')
+                    sub_ip = ip_rule.split(".")
                     if ip_type == self.WILD_IP:
                         sub_ip[0] = random.randint(1, 49)
                         sub_ip[1] = random.randint(50, 99)
@@ -420,15 +447,15 @@ class MethodHolder(VppTestCase):
                         sub_ip[3] = random.randint(200, 255)
                     elif ip_type == self.SUBNET_IP:
                         if denyIP:
-                            sub_ip[1] = int(sub_ip[1])+1
+                            sub_ip[1] = int(sub_ip[1]) + 1
                         sub_ip[2] = random.randint(100, 199)
                         sub_ip[3] = random.randint(200, 255)
-                    src_ip4 = '.'.join(['{!s}'.format(x) for x in sub_ip])
+                    src_ip4 = ".".join(["{!s}".format(x) for x in sub_ip])
                 packet /= IP(src=src_ip4, dst=dst_ip4, frag=0, flags=0)
 
-            packet /= UDP(sport=src_port, dport=dst_port)/Raw(payload)
+            packet /= UDP(sport=src_port, dport=dst_port) / Raw(payload)
 
-            packet[Raw].load += b" mac:%s" % src_mac.encode('utf-8')
+            packet[Raw].load += b" mac:%s" % src_mac.encode("utf-8")
 
             size = self.pg_if_packet_sizes[p % len(self.pg_if_packet_sizes)]
             if isinstance(src_if, VppSubInterface):
@@ -466,8 +493,8 @@ class MethodHolder(VppTestCase):
                 mac_rule = "00:00:00:00:00:00"
                 mac_mask = "00:00:00:00:00:00"
             elif mac_type == self.OUI_MAC:
-                mac = src_mac.split(':')
-                mac[3] = mac[4] = mac[5] = '00'
+                mac = src_mac.split(":")
+                mac[3] = mac[4] = mac[5] = "00"
                 mac_rule = ":".join(mac)
                 mac_mask = "ff:ff:ff:00:00:00"
 
@@ -477,11 +504,10 @@ class MethodHolder(VppTestCase):
                 else:
                     ip = src_ip6
                     if ip_type == self.SUBNET_IP:
-                        sub_ip = list(unpack('<16B', inet_pton(AF_INET6, ip)))
+                        sub_ip = list(unpack("<16B", inet_pton(AF_INET6, ip)))
                         for i in range(8, 16):
                             sub_ip[i] = 0
-                        packed_ip = b''.join(
-                            [scapy.compat.chb(x) for x in sub_ip])
+                        packed_ip = b"".join([scapy.compat.chb(x) for x in sub_ip])
                         ip = inet_ntop(AF_INET6, packed_ip)
             else:
                 if ip_type == self.WILD_IP:
@@ -489,8 +515,8 @@ class MethodHolder(VppTestCase):
                 else:
                     ip = src_ip4
                     if ip_type == self.SUBNET_IP:
-                        sub_ip = ip.split('.')
-                        sub_ip[2] = sub_ip[3] = '0'
+                        sub_ip = ip.split(".")
+                        sub_ip[2] = sub_ip[3] = "0"
                         ip = ".".join(sub_ip)
 
             prefix_len = 128 if is_ip6 else 32
@@ -508,21 +534,22 @@ class MethodHolder(VppTestCase):
                 rule_prefix_len = 128 if packet.haslayer(IPv6) else 32
                 rule_l3_layer = IPv6 if packet.haslayer(IPv6) else IP
                 if packet.haslayer(IPv6):
-                    rule_l4_proto = packet[UDP].overload_fields[IPv6]['nh']
+                    rule_l4_proto = packet[UDP].overload_fields[IPv6]["nh"]
                 else:
                     rule_l4_proto = packet[IP].proto
 
-                src_network = ip_network(
-                    (packet[rule_l3_layer].src, rule_prefix_len))
-                dst_network = ip_network(
-                    (packet[rule_l3_layer].dst, rule_prefix_len))
-                acl_rule = AclRule(is_permit=is_permit, proto=rule_l4_proto,
-                                   src_prefix=src_network,
-                                   dst_prefix=dst_network,
-                                   sport_from=rule_l4_sport,
-                                   sport_to=rule_l4_sport,
-                                   dport_from=rule_l4_dport,
-                                   dport_to=rule_l4_dport)
+                src_network = ip_network((packet[rule_l3_layer].src, rule_prefix_len))
+                dst_network = ip_network((packet[rule_l3_layer].dst, rule_prefix_len))
+                acl_rule = AclRule(
+                    is_permit=is_permit,
+                    proto=rule_l4_proto,
+                    src_prefix=src_network,
+                    dst_prefix=dst_network,
+                    sport_from=rule_l4_sport,
+                    sport_to=rule_l4_sport,
+                    dport_from=rule_l4_dport,
+                    dport_to=rule_l4_dport,
+                )
                 acl_rules.append(acl_rule)
 
             if mac_type == self.WILD_MAC and ip_type == self.WILD_IP and p > 0:
@@ -531,10 +558,10 @@ class MethodHolder(VppTestCase):
             if is_permit:
                 macip_rule = MacipRule(
                     is_permit=is_permit,
-                    src_prefix=ip_network(
-                        (ip_rule, prefix_len)),
+                    src_prefix=ip_network((ip_rule, prefix_len)),
                     src_mac=MACAddress(mac_rule).packed,
-                    src_mac_mask=MACAddress(mac_mask).packed)
+                    src_mac_mask=MACAddress(mac_mask).packed,
+                )
                 macip_rules.append(macip_rule)
 
         # deny all other packets
@@ -544,16 +571,22 @@ class MethodHolder(VppTestCase):
                 is_permit=0,
                 src_prefix=network,
                 src_mac=MACAddress("00:00:00:00:00:00").packed,
-                src_mac_mask=MACAddress("00:00:00:00:00:00").packed)
+                src_mac_mask=MACAddress("00:00:00:00:00:00").packed,
+            )
             macip_rules.append(macip_rule)
 
         network = IPv6Network((0, 0)) if is_ip6 else IPv4Network((0, 0))
-        acl_rule = AclRule(is_permit=0, src_prefix=network, dst_prefix=network,
-                           sport_from=0, sport_to=0, dport_from=0, dport_to=0)
+        acl_rule = AclRule(
+            is_permit=0,
+            src_prefix=network,
+            dst_prefix=network,
+            sport_from=0,
+            sport_to=0,
+            dport_from=0,
+            dport_to=0,
+        )
         acl_rules.append(acl_rule)
-        return {'stream': packets,
-                'macip_rules': macip_rules,
-                'acl_rules': acl_rules}
+        return {"stream": packets, "macip_rules": macip_rules, "acl_rules": acl_rules}
 
     def verify_capture(self, stream, capture, is_ip6):
         """
@@ -582,10 +615,20 @@ class MethodHolder(VppTestCase):
         #     data = p[Raw].load.split(':',1)[1])
         #     print(p[p_l3].src, data)
 
-    def run_traffic(self, mac_type, ip_type, traffic, is_ip6, packets,
-                    do_not_expected_capture=False, tags=None,
-                    apply_rules=True, isMACIP=True, permit_tags=PERMIT_TAGS,
-                    try_replace=False):
+    def run_traffic(
+        self,
+        mac_type,
+        ip_type,
+        traffic,
+        is_ip6,
+        packets,
+        do_not_expected_capture=False,
+        tags=None,
+        apply_rules=True,
+        isMACIP=True,
+        permit_tags=PERMIT_TAGS,
+        try_replace=False,
+    ):
         self.reset_packet_infos()
 
         if tags is None:
@@ -619,21 +662,28 @@ class MethodHolder(VppTestCase):
             else:
                 return
 
-        test_dict = self.create_stream(mac_type, ip_type, packets,
-                                       src_if, dst_if,
-                                       traffic, is_ip6,
-                                       tags=permit_tags)
+        test_dict = self.create_stream(
+            mac_type,
+            ip_type,
+            packets,
+            src_if,
+            dst_if,
+            traffic,
+            is_ip6,
+            tags=permit_tags,
+        )
 
         if apply_rules:
             if isMACIP:
-                self.acl = VppMacipAcl(self, rules=test_dict['macip_rules'])
+                self.acl = VppMacipAcl(self, rules=test_dict["macip_rules"])
             else:
-                self.acl = VppAcl(self, rules=test_dict['acl_rules'])
+                self.acl = VppAcl(self, rules=test_dict["acl_rules"])
             self.acl.add_vpp_config()
 
             if isMACIP:
                 self.acl_if = VppMacipAclInterface(
-                    self, sw_if_index=tx_if.sw_if_index, acls=[self.acl])
+                    self, sw_if_index=tx_if.sw_if_index, acls=[self.acl]
+                )
                 self.acl_if.add_vpp_config()
 
                 dump = self.acl_if.dump()
@@ -641,45 +691,51 @@ class MethodHolder(VppTestCase):
                 self.assertEqual(dump[0].acls[0], self.acl.acl_index)
             else:
                 self.acl_if = VppAclInterface(
-                    self, sw_if_index=tx_if.sw_if_index, n_input=1,
-                    acls=[self.acl])
+                    self, sw_if_index=tx_if.sw_if_index, n_input=1, acls=[self.acl]
+                )
                 self.acl_if.add_vpp_config()
         else:
             if hasattr(self, "acl_if"):
                 self.acl_if.remove_vpp_config()
         if try_replace and hasattr(self, "acl"):
             if isMACIP:
-                self.acl.modify_vpp_config(test_dict['macip_rules'])
+                self.acl.modify_vpp_config(test_dict["macip_rules"])
             else:
-                self.acl.modify_vpp_config(test_dict['acl_rules'])
+                self.acl.modify_vpp_config(test_dict["acl_rules"])
 
         if not isinstance(src_if, VppSubInterface):
-            tx_if.add_stream(test_dict['stream'])
+            tx_if.add_stream(test_dict["stream"])
         else:
-            tx_if.parent.add_stream(test_dict['stream'])
+            tx_if.parent.add_stream(test_dict["stream"])
         self.pg_enable_capture(self.pg_interfaces)
         self.pg_start()
 
         if do_not_expected_capture:
             rx_if.get_capture(0)
         else:
-            if traffic == self.BRIDGED and mac_type == self.WILD_MAC and \
-                    ip_type == self.WILD_IP:
+            if (
+                traffic == self.BRIDGED
+                and mac_type == self.WILD_MAC
+                and ip_type == self.WILD_IP
+            ):
                 capture = rx_if.get_capture(packets)
             else:
                 capture = rx_if.get_capture(
-                    self.get_packet_count_for_if_idx(dst_if.sw_if_index))
-            self.verify_capture(test_dict['stream'], capture, is_ip6)
+                    self.get_packet_count_for_if_idx(dst_if.sw_if_index)
+                )
+            self.verify_capture(test_dict["stream"], capture, is_ip6)
         if not isMACIP:
             if hasattr(self, "acl_if"):
                 self.acl_if.remove_vpp_config()
             if hasattr(self, "acl"):
                 self.acl.remove_vpp_config()
 
-    def run_test_acls(self, mac_type, ip_type, acl_count,
-                      rules_count, traffic=None, ip=None):
-        self.apply_macip_rules(self.create_rules(mac_type, ip_type, acl_count,
-                                                 rules_count))
+    def run_test_acls(
+        self, mac_type, ip_type, acl_count, rules_count, traffic=None, ip=None
+    ):
+        self.apply_macip_rules(
+            self.create_rules(mac_type, ip_type, acl_count, rules_count)
+        )
         self.verify_macip_acls(acl_count, rules_count)
 
         if traffic is not None:
@@ -698,134 +754,104 @@ class TestMACIP_IP4(MethodHolder):
         super(TestMACIP_IP4, cls).tearDownClass()
 
     def test_acl_bridged_ip4_exactMAC_exactIP(self):
-        """ IP4 MACIP exactMAC|exactIP ACL bridged traffic
-        """
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP,
-                         self.BRIDGED, self.IS_IP4, 9)
+        """IP4 MACIP exactMAC|exactIP ACL bridged traffic"""
+        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.BRIDGED, self.IS_IP4, 9)
 
     def test_acl_bridged_ip4_exactMAC_subnetIP(self):
-        """ IP4 MACIP exactMAC|subnetIP ACL bridged traffic
-        """
+        """IP4 MACIP exactMAC|subnetIP ACL bridged traffic"""
 
-        self.run_traffic(self.EXACT_MAC, self.SUBNET_IP,
-                         self.BRIDGED, self.IS_IP4, 9)
+        self.run_traffic(self.EXACT_MAC, self.SUBNET_IP, self.BRIDGED, self.IS_IP4, 9)
 
     def test_acl_bridged_ip4_exactMAC_wildIP(self):
-        """ IP4 MACIP exactMAC|wildIP ACL bridged traffic
-        """
+        """IP4 MACIP exactMAC|wildIP ACL bridged traffic"""
 
-        self.run_traffic(self.EXACT_MAC, self.WILD_IP,
-                         self.BRIDGED, self.IS_IP4, 9)
+        self.run_traffic(self.EXACT_MAC, self.WILD_IP, self.BRIDGED, self.IS_IP4, 9)
 
     def test_acl_bridged_ip4_ouiMAC_exactIP(self):
-        """ IP4 MACIP ouiMAC|exactIP ACL bridged traffic
-        """
+        """IP4 MACIP ouiMAC|exactIP ACL bridged traffic"""
 
-        self.run_traffic(self.OUI_MAC, self.EXACT_IP,
-                         self.BRIDGED, self.IS_IP4, 3)
+        self.run_traffic(self.OUI_MAC, self.EXACT_IP, self.BRIDGED, self.IS_IP4, 3)
 
     def test_acl_bridged_ip4_ouiMAC_subnetIP(self):
-        """ IP4 MACIP ouiMAC|subnetIP ACL bridged traffic
-        """
+        """IP4 MACIP ouiMAC|subnetIP ACL bridged traffic"""
 
-        self.run_traffic(self.OUI_MAC, self.SUBNET_IP,
-                         self.BRIDGED, self.IS_IP4, 9)
+        self.run_traffic(self.OUI_MAC, self.SUBNET_IP, self.BRIDGED, self.IS_IP4, 9)
 
     def test_acl_bridged_ip4_ouiMAC_wildIP(self):
-        """ IP4 MACIP ouiMAC|wildIP ACL bridged traffic
-        """
+        """IP4 MACIP ouiMAC|wildIP ACL bridged traffic"""
 
-        self.run_traffic(self.OUI_MAC, self.WILD_IP,
-                         self.BRIDGED, self.IS_IP4, 9)
+        self.run_traffic(self.OUI_MAC, self.WILD_IP, self.BRIDGED, self.IS_IP4, 9)
 
     def test_ac_bridgedl_ip4_wildMAC_exactIP(self):
-        """ IP4 MACIP wildcardMAC|exactIP ACL bridged traffic
-        """
+        """IP4 MACIP wildcardMAC|exactIP ACL bridged traffic"""
 
-        self.run_traffic(self.WILD_MAC, self.EXACT_IP,
-                         self.BRIDGED, self.IS_IP4, 9)
+        self.run_traffic(self.WILD_MAC, self.EXACT_IP, self.BRIDGED, self.IS_IP4, 9)
 
     def test_acl_bridged_ip4_wildMAC_subnetIP(self):
-        """ IP4 MACIP wildcardMAC|subnetIP ACL bridged traffic
-        """
+        """IP4 MACIP wildcardMAC|subnetIP ACL bridged traffic"""
 
-        self.run_traffic(self.WILD_MAC, self.SUBNET_IP,
-                         self.BRIDGED, self.IS_IP4, 9)
+        self.run_traffic(self.WILD_MAC, self.SUBNET_IP, self.BRIDGED, self.IS_IP4, 9)
 
     def test_acl_bridged_ip4_wildMAC_wildIP(self):
-        """ IP4 MACIP wildcardMAC|wildIP ACL bridged traffic
-        """
+        """IP4 MACIP wildcardMAC|wildIP ACL bridged traffic"""
 
-        self.run_traffic(self.WILD_MAC, self.WILD_IP,
-                         self.BRIDGED, self.IS_IP4, 9)
+        self.run_traffic(self.WILD_MAC, self.WILD_IP, self.BRIDGED, self.IS_IP4, 9)
 
     def test_acl_routed_ip4_exactMAC_exactIP(self):
-        """ IP4 MACIP exactMAC|exactIP ACL routed traffic
-        """
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP,
-                         self.ROUTED, self.IS_IP4, 9)
+        """IP4 MACIP exactMAC|exactIP ACL routed traffic"""
+        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.ROUTED, self.IS_IP4, 9)
 
     def test_acl_routed_ip4_exactMAC_subnetIP(self):
-        """ IP4 MACIP exactMAC|subnetIP ACL routed traffic
-        """
-        self.run_traffic(self.EXACT_MAC, self.SUBNET_IP,
-                         self.ROUTED, self.IS_IP4, 9)
+        """IP4 MACIP exactMAC|subnetIP ACL routed traffic"""
+        self.run_traffic(self.EXACT_MAC, self.SUBNET_IP, self.ROUTED, self.IS_IP4, 9)
 
     def test_acl_routed_ip4_exactMAC_wildIP(self):
-        """ IP4 MACIP exactMAC|wildIP ACL routed traffic
-        """
-        self.run_traffic(self.EXACT_MAC, self.WILD_IP,
-                         self.ROUTED, self.IS_IP4, 9)
+        """IP4 MACIP exactMAC|wildIP ACL routed traffic"""
+        self.run_traffic(self.EXACT_MAC, self.WILD_IP, self.ROUTED, self.IS_IP4, 9)
 
     def test_acl_routed_ip4_ouiMAC_exactIP(self):
-        """ IP4 MACIP ouiMAC|exactIP ACL routed traffic
-        """
+        """IP4 MACIP ouiMAC|exactIP ACL routed traffic"""
 
-        self.run_traffic(self.OUI_MAC, self.EXACT_IP,
-                         self.ROUTED, self.IS_IP4, 9)
+        self.run_traffic(self.OUI_MAC, self.EXACT_IP, self.ROUTED, self.IS_IP4, 9)
 
     def test_acl_routed_ip4_ouiMAC_subnetIP(self):
-        """ IP4 MACIP ouiMAC|subnetIP ACL routed traffic
-        """
+        """IP4 MACIP ouiMAC|subnetIP ACL routed traffic"""
 
-        self.run_traffic(self.OUI_MAC, self.SUBNET_IP,
-                         self.ROUTED, self.IS_IP4, 9)
+        self.run_traffic(self.OUI_MAC, self.SUBNET_IP, self.ROUTED, self.IS_IP4, 9)
 
     def test_acl_routed_ip4_ouiMAC_wildIP(self):
-        """ IP4 MACIP ouiMAC|wildIP ACL routed traffic
-        """
+        """IP4 MACIP ouiMAC|wildIP ACL routed traffic"""
 
-        self.run_traffic(self.OUI_MAC, self.WILD_IP,
-                         self.ROUTED, self.IS_IP4, 9)
+        self.run_traffic(self.OUI_MAC, self.WILD_IP, self.ROUTED, self.IS_IP4, 9)
 
     def test_acl_routed_ip4_wildMAC_exactIP(self):
-        """ IP4 MACIP wildcardMAC|exactIP ACL routed traffic
-        """
+        """IP4 MACIP wildcardMAC|exactIP ACL routed traffic"""
 
-        self.run_traffic(self.WILD_MAC, self.EXACT_IP,
-                         self.ROUTED, self.IS_IP4, 9)
+        self.run_traffic(self.WILD_MAC, self.EXACT_IP, self.ROUTED, self.IS_IP4, 9)
 
     def test_acl_routed_ip4_wildMAC_subnetIP(self):
-        """ IP4 MACIP wildcardMAC|subnetIP ACL routed traffic
-        """
+        """IP4 MACIP wildcardMAC|subnetIP ACL routed traffic"""
 
-        self.run_traffic(self.WILD_MAC, self.SUBNET_IP,
-                         self.ROUTED, self.IS_IP4, 9)
+        self.run_traffic(self.WILD_MAC, self.SUBNET_IP, self.ROUTED, self.IS_IP4, 9)
 
     def test_acl_routed_ip4_wildMAC_wildIP(self):
-        """ IP4 MACIP wildcardMAC|wildIP ACL
-        """
+        """IP4 MACIP wildcardMAC|wildIP ACL"""
 
-        self.run_traffic(self.WILD_MAC, self.WILD_IP,
-                         self.ROUTED, self.IS_IP4, 9)
+        self.run_traffic(self.WILD_MAC, self.WILD_IP, self.ROUTED, self.IS_IP4, 9)
 
     def test_acl_replace_traffic_ip4(self):
-        """ MACIP replace ACL with IP4 traffic
-        """
-        self.run_traffic(self.OUI_MAC, self.SUBNET_IP,
-                         self.BRIDGED, self.IS_IP4, 9, try_replace=True)
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP,
-                         self.BRIDGED, self.IS_IP4, 9, try_replace=True)
+        """MACIP replace ACL with IP4 traffic"""
+        self.run_traffic(
+            self.OUI_MAC, self.SUBNET_IP, self.BRIDGED, self.IS_IP4, 9, try_replace=True
+        )
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.BRIDGED,
+            self.IS_IP4,
+            9,
+            try_replace=True,
+        )
 
 
 class TestMACIP_IP6(MethodHolder):
@@ -840,138 +866,108 @@ class TestMACIP_IP6(MethodHolder):
         super(TestMACIP_IP6, cls).tearDownClass()
 
     def test_acl_bridged_ip6_exactMAC_exactIP(self):
-        """ IP6 MACIP exactMAC|exactIP ACL bridged traffic
-        """
+        """IP6 MACIP exactMAC|exactIP ACL bridged traffic"""
 
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP,
-                         self.BRIDGED, self.IS_IP6, 9)
+        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.BRIDGED, self.IS_IP6, 9)
 
     def test_acl_bridged_ip6_exactMAC_subnetIP(self):
-        """ IP6 MACIP exactMAC|subnetIP ACL bridged traffic
-        """
+        """IP6 MACIP exactMAC|subnetIP ACL bridged traffic"""
 
-        self.run_traffic(self.EXACT_MAC, self.SUBNET_IP,
-                         self.BRIDGED, self.IS_IP6, 9)
+        self.run_traffic(self.EXACT_MAC, self.SUBNET_IP, self.BRIDGED, self.IS_IP6, 9)
 
     def test_acl_bridged_ip6_exactMAC_wildIP(self):
-        """ IP6 MACIP exactMAC|wildIP ACL bridged traffic
-        """
+        """IP6 MACIP exactMAC|wildIP ACL bridged traffic"""
 
-        self.run_traffic(self.EXACT_MAC, self.WILD_IP,
-                         self.BRIDGED, self.IS_IP6, 9)
+        self.run_traffic(self.EXACT_MAC, self.WILD_IP, self.BRIDGED, self.IS_IP6, 9)
 
     def test_acl_bridged_ip6_ouiMAC_exactIP(self):
-        """ IP6 MACIP oui_MAC|exactIP ACL bridged traffic
-        """
+        """IP6 MACIP oui_MAC|exactIP ACL bridged traffic"""
 
-        self.run_traffic(self.OUI_MAC, self.EXACT_IP,
-                         self.BRIDGED, self.IS_IP6, 9)
+        self.run_traffic(self.OUI_MAC, self.EXACT_IP, self.BRIDGED, self.IS_IP6, 9)
 
     def test_acl_bridged_ip6_ouiMAC_subnetIP(self):
-        """ IP6 MACIP ouiMAC|subnetIP ACL bridged traffic
-        """
+        """IP6 MACIP ouiMAC|subnetIP ACL bridged traffic"""
 
-        self.run_traffic(self.OUI_MAC, self.SUBNET_IP,
-                         self.BRIDGED, self.IS_IP6, 9)
+        self.run_traffic(self.OUI_MAC, self.SUBNET_IP, self.BRIDGED, self.IS_IP6, 9)
 
     def test_acl_bridged_ip6_ouiMAC_wildIP(self):
-        """ IP6 MACIP ouiMAC|wildIP ACL bridged traffic
-        """
+        """IP6 MACIP ouiMAC|wildIP ACL bridged traffic"""
 
-        self.run_traffic(self.OUI_MAC, self.WILD_IP,
-                         self.BRIDGED, self.IS_IP6, 9)
+        self.run_traffic(self.OUI_MAC, self.WILD_IP, self.BRIDGED, self.IS_IP6, 9)
 
     def test_acl_bridged_ip6_wildMAC_exactIP(self):
-        """ IP6 MACIP wildcardMAC|exactIP ACL bridged traffic
-        """
+        """IP6 MACIP wildcardMAC|exactIP ACL bridged traffic"""
 
-        self.run_traffic(self.WILD_MAC, self.EXACT_IP,
-                         self.BRIDGED, self.IS_IP6, 9)
+        self.run_traffic(self.WILD_MAC, self.EXACT_IP, self.BRIDGED, self.IS_IP6, 9)
 
     def test_acl_bridged_ip6_wildMAC_subnetIP(self):
-        """ IP6 MACIP wildcardMAC|subnetIP ACL bridged traffic
-        """
+        """IP6 MACIP wildcardMAC|subnetIP ACL bridged traffic"""
 
-        self.run_traffic(self.WILD_MAC, self.SUBNET_IP,
-                         self.BRIDGED, self.IS_IP6, 9)
+        self.run_traffic(self.WILD_MAC, self.SUBNET_IP, self.BRIDGED, self.IS_IP6, 9)
 
     def test_acl_bridged_ip6_wildMAC_wildIP(self):
-        """ IP6 MACIP wildcardMAC|wildIP ACL bridged traffic
-        """
+        """IP6 MACIP wildcardMAC|wildIP ACL bridged traffic"""
 
-        self.run_traffic(self.WILD_MAC, self.WILD_IP,
-                         self.BRIDGED, self.IS_IP6, 9)
+        self.run_traffic(self.WILD_MAC, self.WILD_IP, self.BRIDGED, self.IS_IP6, 9)
 
     def test_acl_routed_ip6_exactMAC_exactIP(self):
-        """ IP6 MACIP exactMAC|exactIP ACL routed traffic
-        """
+        """IP6 MACIP exactMAC|exactIP ACL routed traffic"""
 
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP,
-                         self.ROUTED, self.IS_IP6, 9)
+        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.ROUTED, self.IS_IP6, 9)
 
     def test_acl_routed_ip6_exactMAC_subnetIP(self):
-        """ IP6 MACIP exactMAC|subnetIP ACL routed traffic
-        """
+        """IP6 MACIP exactMAC|subnetIP ACL routed traffic"""
 
-        self.run_traffic(self.EXACT_MAC, self.SUBNET_IP,
-                         self.ROUTED, self.IS_IP6, 9)
+        self.run_traffic(self.EXACT_MAC, self.SUBNET_IP, self.ROUTED, self.IS_IP6, 9)
 
     def test_acl_routed_ip6_exactMAC_wildIP(self):
-        """ IP6 MACIP exactMAC|wildIP ACL routed traffic
-        """
+        """IP6 MACIP exactMAC|wildIP ACL routed traffic"""
 
-        self.run_traffic(self.EXACT_MAC, self.WILD_IP,
-                         self.ROUTED, self.IS_IP6, 9)
+        self.run_traffic(self.EXACT_MAC, self.WILD_IP, self.ROUTED, self.IS_IP6, 9)
 
     def test_acl_routed_ip6_ouiMAC_exactIP(self):
-        """ IP6 MACIP ouiMAC|exactIP ACL routed traffic
-        """
+        """IP6 MACIP ouiMAC|exactIP ACL routed traffic"""
 
-        self.run_traffic(self.OUI_MAC, self.EXACT_IP,
-                         self.ROUTED, self.IS_IP6, 9)
+        self.run_traffic(self.OUI_MAC, self.EXACT_IP, self.ROUTED, self.IS_IP6, 9)
 
     def test_acl_routed_ip6_ouiMAC_subnetIP(self):
-        """ IP6 MACIP ouiMAC|subnetIP ACL routed traffic
-        """
+        """IP6 MACIP ouiMAC|subnetIP ACL routed traffic"""
 
-        self.run_traffic(self.OUI_MAC, self.SUBNET_IP,
-                         self.ROUTED, self.IS_IP6, 9)
+        self.run_traffic(self.OUI_MAC, self.SUBNET_IP, self.ROUTED, self.IS_IP6, 9)
 
     def test_acl_routed_ip6_ouiMAC_wildIP(self):
-        """ IP6 MACIP ouiMAC|wildIP ACL routed traffic
-        """
+        """IP6 MACIP ouiMAC|wildIP ACL routed traffic"""
 
-        self.run_traffic(self.OUI_MAC, self.WILD_IP,
-                         self.ROUTED, self.IS_IP6, 9)
+        self.run_traffic(self.OUI_MAC, self.WILD_IP, self.ROUTED, self.IS_IP6, 9)
 
     def test_acl_routed_ip6_wildMAC_exactIP(self):
-        """ IP6 MACIP wildcardMAC|exactIP ACL routed traffic
-        """
+        """IP6 MACIP wildcardMAC|exactIP ACL routed traffic"""
 
-        self.run_traffic(self.WILD_MAC, self.EXACT_IP,
-                         self.ROUTED, self.IS_IP6, 9)
+        self.run_traffic(self.WILD_MAC, self.EXACT_IP, self.ROUTED, self.IS_IP6, 9)
 
     def test_acl_routed_ip6_wildMAC_subnetIP(self):
-        """ IP6 MACIP wildcardMAC|subnetIP ACL routed traffic
-        """
+        """IP6 MACIP wildcardMAC|subnetIP ACL routed traffic"""
 
-        self.run_traffic(self.WILD_MAC, self.SUBNET_IP,
-                         self.ROUTED, self.IS_IP6, 9)
+        self.run_traffic(self.WILD_MAC, self.SUBNET_IP, self.ROUTED, self.IS_IP6, 9)
 
     def test_acl_routed_ip6_wildMAC_wildIP(self):
-        """ IP6 MACIP wildcardMAC|wildIP ACL
-        """
+        """IP6 MACIP wildcardMAC|wildIP ACL"""
 
-        self.run_traffic(self.WILD_MAC, self.WILD_IP,
-                         self.ROUTED, self.IS_IP6, 9)
+        self.run_traffic(self.WILD_MAC, self.WILD_IP, self.ROUTED, self.IS_IP6, 9)
 
     def test_acl_replace_traffic_ip6(self):
-        """ MACIP replace ACL with IP6 traffic
-        """
-        self.run_traffic(self.OUI_MAC, self.SUBNET_IP,
-                         self.BRIDGED, self.IS_IP6, 9, try_replace=True)
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP,
-                         self.BRIDGED, self.IS_IP6, 9, try_replace=True)
+        """MACIP replace ACL with IP6 traffic"""
+        self.run_traffic(
+            self.OUI_MAC, self.SUBNET_IP, self.BRIDGED, self.IS_IP6, 9, try_replace=True
+        )
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.BRIDGED,
+            self.IS_IP6,
+            9,
+            try_replace=True,
+        )
 
 
 class TestMACIP(MethodHolder):
@@ -986,73 +982,76 @@ class TestMACIP(MethodHolder):
         super(TestMACIP, cls).tearDownClass()
 
     def test_acl_1_2(self):
-        """ MACIP ACL with 2 entries
-        """
+        """MACIP ACL with 2 entries"""
 
         self.run_test_acls(self.EXACT_MAC, self.WILD_IP, 1, [2])
 
     def test_acl_1_5(self):
-        """ MACIP ACL with 5 entries
-        """
+        """MACIP ACL with 5 entries"""
 
         self.run_test_acls(self.EXACT_MAC, self.SUBNET_IP, 1, [5])
 
     def test_acl_1_10(self):
-        """ MACIP ACL with 10 entries
-        """
+        """MACIP ACL with 10 entries"""
 
         self.run_test_acls(self.EXACT_MAC, self.EXACT_IP, 1, [10])
 
     def test_acl_1_20(self):
-        """ MACIP ACL with 20 entries
-        """
+        """MACIP ACL with 20 entries"""
 
         self.run_test_acls(self.OUI_MAC, self.WILD_IP, 1, [20])
 
     def test_acl_1_50(self):
-        """ MACIP ACL with 50 entries
-        """
+        """MACIP ACL with 50 entries"""
 
         self.run_test_acls(self.OUI_MAC, self.SUBNET_IP, 1, [50])
 
     def test_acl_1_100(self):
-        """ MACIP ACL with 100 entries
-        """
+        """MACIP ACL with 100 entries"""
 
         self.run_test_acls(self.OUI_MAC, self.EXACT_IP, 1, [100])
 
     def test_acl_2_X(self):
-        """ MACIP 2 ACLs each with 100+ entries
-        """
+        """MACIP 2 ACLs each with 100+ entries"""
 
         self.run_test_acls(self.OUI_MAC, self.SUBNET_IP, 2, [100, 200])
 
     def test_acl_10_X(self):
-        """ MACIP 10 ACLs each with 100+ entries
-        """
+        """MACIP 10 ACLs each with 100+ entries"""
 
-        self.run_test_acls(self.EXACT_MAC, self.EXACT_IP, 10,
-                           [100, 120, 140, 160, 180, 200, 210, 220, 230, 240])
+        self.run_test_acls(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            10,
+            [100, 120, 140, 160, 180, 200, 210, 220, 230, 240],
+        )
 
     def test_acl_10_X_traffic_ip4(self):
-        """ MACIP 10 ACLs each with 100+ entries with IP4 traffic
-        """
+        """MACIP 10 ACLs each with 100+ entries with IP4 traffic"""
 
-        self.run_test_acls(self.EXACT_MAC, self.EXACT_IP, 10,
-                           [100, 120, 140, 160, 180, 200, 210, 220, 230, 240],
-                           self.BRIDGED, self.IS_IP4)
+        self.run_test_acls(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            10,
+            [100, 120, 140, 160, 180, 200, 210, 220, 230, 240],
+            self.BRIDGED,
+            self.IS_IP4,
+        )
 
     def test_acl_10_X_traffic_ip6(self):
-        """ MACIP 10 ACLs each with 100+ entries with IP6 traffic
-        """
+        """MACIP 10 ACLs each with 100+ entries with IP6 traffic"""
 
-        self.run_test_acls(self.EXACT_MAC, self.EXACT_IP, 10,
-                           [100, 120, 140, 160, 180, 200, 210, 220, 230, 240],
-                           self.BRIDGED, self.IS_IP6)
+        self.run_test_acls(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            10,
+            [100, 120, 140, 160, 180, 200, 210, 220, 230, 240],
+            self.BRIDGED,
+            self.IS_IP6,
+        )
 
     def test_acl_replace(self):
-        """ MACIP replace ACL
-        """
+        """MACIP replace ACL"""
 
         r1 = self.create_rules(acl_count=3, rules_count=[2, 2, 2])
         r2 = self.create_rules(mac_type=self.OUI_MAC, ip_type=self.SUBNET_IP)
@@ -1069,17 +1068,15 @@ class TestMACIP(MethodHolder):
         # verify changes
         self.assertEqual(len(acls_before), len(acls_after))
         for acl1, acl2 in zip(
-                acls_before[:2]+acls_before[4:],
-                acls_after[:2]+acls_after[4:]):
+            acls_before[:2] + acls_before[4:], acls_after[:2] + acls_after[4:]
+        ):
             self.assertEqual(len(acl1), len(acl2))
 
             self.assertEqual(len(acl1.r), len(acl2.r))
             for r1, r2 in zip(acl1.r, acl2.r):
                 self.assertEqual(len(acl1.r), len(acl2.r))
                 self.assertEqual(acl1.r, acl2.r)
-        for acl1, acl2 in zip(
-                acls_before[2:4],
-                acls_after[2:4]):
+        for acl1, acl2 in zip(acls_before[2:4], acls_after[2:4]):
             self.assertEqual(len(acl1), len(acl2))
 
             self.assertNotEqual(len(acl1.r), len(acl2.r))
@@ -1088,38 +1085,40 @@ class TestMACIP(MethodHolder):
                 self.assertNotEqual(acl1.r, acl2.r)
 
     def test_delete_intf(self):
-        """ MACIP ACL delete intf with acl
-        """
+        """MACIP ACL delete intf with acl"""
 
-        intf_count = len(self.interfaces)+1
+        intf_count = len(self.interfaces) + 1
         intf = []
         macip_alcs = self.apply_macip_rules(
-            self.create_rules(acl_count=3, rules_count=[3, 5, 4]))
+            self.create_rules(acl_count=3, rules_count=[3, 5, 4])
+        )
 
         intf.append(VppLoInterface(self))
         intf.append(VppLoInterface(self))
 
         sw_if_index0 = intf[0].sw_if_index
         macip_acl_if0 = VppMacipAclInterface(
-            self, sw_if_index=sw_if_index0, acls=[macip_alcs[1]])
+            self, sw_if_index=sw_if_index0, acls=[macip_alcs[1]]
+        )
         macip_acl_if0.add_vpp_config()
 
         reply = self.vapi.macip_acl_interface_get()
-        self.assertEqual(reply.count, intf_count+1)
+        self.assertEqual(reply.count, intf_count + 1)
         self.assertEqual(reply.acls[sw_if_index0], 1)
 
         sw_if_index1 = intf[1].sw_if_index
         macip_acl_if1 = VppMacipAclInterface(
-            self, sw_if_index=sw_if_index1, acls=[macip_alcs[0]])
+            self, sw_if_index=sw_if_index1, acls=[macip_alcs[0]]
+        )
         macip_acl_if1.add_vpp_config()
 
         reply = self.vapi.macip_acl_interface_get()
-        self.assertEqual(reply.count, intf_count+2)
+        self.assertEqual(reply.count, intf_count + 2)
         self.assertEqual(reply.acls[sw_if_index1], 0)
 
         intf[0].remove_vpp_config()
         reply = self.vapi.macip_acl_interface_get()
-        self.assertEqual(reply.count, intf_count+2)
+        self.assertEqual(reply.count, intf_count + 2)
         self.assertEqual(reply.acls[sw_if_index0], 4294967295)
         self.assertEqual(reply.acls[sw_if_index1], 0)
 
@@ -1128,14 +1127,16 @@ class TestMACIP(MethodHolder):
         sw_if_index2 = intf[2].sw_if_index
         sw_if_index3 = intf[3].sw_if_index
         macip_acl_if2 = VppMacipAclInterface(
-            self, sw_if_index=sw_if_index2, acls=[macip_alcs[1]])
+            self, sw_if_index=sw_if_index2, acls=[macip_alcs[1]]
+        )
         macip_acl_if2.add_vpp_config()
         macip_acl_if3 = VppMacipAclInterface(
-            self, sw_if_index=sw_if_index3, acls=[macip_alcs[1]])
+            self, sw_if_index=sw_if_index3, acls=[macip_alcs[1]]
+        )
         macip_acl_if3.add_vpp_config()
 
         reply = self.vapi.macip_acl_interface_get()
-        self.assertEqual(reply.count, intf_count+3)
+        self.assertEqual(reply.count, intf_count + 3)
         self.assertEqual(reply.acls[sw_if_index1], 0)
         self.assertEqual(reply.acls[sw_if_index2], 1)
         self.assertEqual(reply.acls[sw_if_index3], 1)
@@ -1150,7 +1151,7 @@ class TestMACIP(MethodHolder):
         intf[1].remove_vpp_config()
 
         reply = self.vapi.macip_acl_interface_get()
-        self.assertEqual(reply.count, intf_count+3)
+        self.assertEqual(reply.count, intf_count + 3)
         self.assertEqual(reply.acls[sw_if_index0], 4294967295)
         self.assertEqual(reply.acls[sw_if_index1], 4294967295)
         self.assertEqual(reply.acls[sw_if_index2], 4294967295)
@@ -1174,14 +1175,28 @@ class TestACL_dot1q_bridged(MethodHolder):
         super(TestACL_dot1q_bridged, cls).tearDownClass()
 
     def test_acl_bridged_ip4_subif_dot1q(self):
-        """ IP4 ACL SubIf Dot1Q bridged traffic"""
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.BRIDGED,
-                         self.IS_IP4, 9, tags=self.DOT1Q, isMACIP=False)
+        """IP4 ACL SubIf Dot1Q bridged traffic"""
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.BRIDGED,
+            self.IS_IP4,
+            9,
+            tags=self.DOT1Q,
+            isMACIP=False,
+        )
 
     def test_acl_bridged_ip6_subif_dot1q(self):
-        """ IP6 ACL SubIf Dot1Q bridged traffic"""
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.BRIDGED,
-                         self.IS_IP6, 9, tags=self.DOT1Q, isMACIP=False)
+        """IP6 ACL SubIf Dot1Q bridged traffic"""
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.BRIDGED,
+            self.IS_IP6,
+            9,
+            tags=self.DOT1Q,
+            isMACIP=False,
+        )
 
 
 class TestACL_dot1ad_bridged(MethodHolder):
@@ -1196,14 +1211,28 @@ class TestACL_dot1ad_bridged(MethodHolder):
         super(TestACL_dot1ad_bridged, cls).tearDownClass()
 
     def test_acl_bridged_ip4_subif_dot1ad(self):
-        """ IP4 ACL SubIf Dot1AD bridged traffic"""
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.BRIDGED,
-                         self.IS_IP4, 9, tags=self.DOT1AD, isMACIP=False)
+        """IP4 ACL SubIf Dot1AD bridged traffic"""
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.BRIDGED,
+            self.IS_IP4,
+            9,
+            tags=self.DOT1AD,
+            isMACIP=False,
+        )
 
     def test_acl_bridged_ip6_subif_dot1ad(self):
-        """ IP6 ACL SubIf Dot1AD bridged traffic"""
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.BRIDGED,
-                         self.IS_IP6, 9, tags=self.DOT1AD, isMACIP=False)
+        """IP6 ACL SubIf Dot1AD bridged traffic"""
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.BRIDGED,
+            self.IS_IP6,
+            9,
+            tags=self.DOT1AD,
+            isMACIP=False,
+        )
 
 
 class TestACL_dot1q_routed(MethodHolder):
@@ -1218,26 +1247,56 @@ class TestACL_dot1q_routed(MethodHolder):
         super(TestACL_dot1q_routed, cls).tearDownClass()
 
     def test_acl_routed_ip4_subif_dot1q(self):
-        """ IP4 ACL SubIf Dot1Q routed traffic"""
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.ROUTED,
-                         self.IS_IP4, 9, tags=self.DOT1Q, isMACIP=False)
+        """IP4 ACL SubIf Dot1Q routed traffic"""
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.ROUTED,
+            self.IS_IP4,
+            9,
+            tags=self.DOT1Q,
+            isMACIP=False,
+        )
 
     def test_acl_routed_ip6_subif_dot1q(self):
-        """ IP6 ACL SubIf Dot1Q routed traffic"""
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.ROUTED,
-                         self.IS_IP6, 9, tags=self.DOT1Q, isMACIP=False)
+        """IP6 ACL SubIf Dot1Q routed traffic"""
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.ROUTED,
+            self.IS_IP6,
+            9,
+            tags=self.DOT1Q,
+            isMACIP=False,
+        )
 
     def test_acl_routed_ip4_subif_dot1q_deny_by_tags(self):
-        """ IP4 ACL SubIf wrong tags Dot1Q routed traffic"""
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.ROUTED,
-                         self.IS_IP4, 9, True, tags=self.DOT1Q, isMACIP=False,
-                         permit_tags=self.DENY_TAGS)
+        """IP4 ACL SubIf wrong tags Dot1Q routed traffic"""
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.ROUTED,
+            self.IS_IP4,
+            9,
+            True,
+            tags=self.DOT1Q,
+            isMACIP=False,
+            permit_tags=self.DENY_TAGS,
+        )
 
     def test_acl_routed_ip6_subif_dot1q_deny_by_tags(self):
-        """ IP6 ACL SubIf wrong tags Dot1Q routed traffic"""
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.ROUTED,
-                         self.IS_IP6, 9, True, tags=self.DOT1Q, isMACIP=False,
-                         permit_tags=self.DENY_TAGS)
+        """IP6 ACL SubIf wrong tags Dot1Q routed traffic"""
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.ROUTED,
+            self.IS_IP6,
+            9,
+            True,
+            tags=self.DOT1Q,
+            isMACIP=False,
+            permit_tags=self.DENY_TAGS,
+        )
 
 
 class TestACL_dot1ad_routed(MethodHolder):
@@ -1252,27 +1311,57 @@ class TestACL_dot1ad_routed(MethodHolder):
         super(TestACL_dot1ad_routed, cls).tearDownClass()
 
     def test_acl_routed_ip6_subif_dot1ad(self):
-        """ IP6 ACL SubIf Dot1AD routed traffic"""
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.ROUTED,
-                         self.IS_IP6, 9, tags=self.DOT1AD, isMACIP=False)
+        """IP6 ACL SubIf Dot1AD routed traffic"""
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.ROUTED,
+            self.IS_IP6,
+            9,
+            tags=self.DOT1AD,
+            isMACIP=False,
+        )
 
     def test_acl_routed_ip4_subif_dot1ad(self):
-        """ IP4 ACL SubIf Dot1AD routed traffic"""
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.ROUTED,
-                         self.IS_IP4, 9, tags=self.DOT1AD, isMACIP=False)
+        """IP4 ACL SubIf Dot1AD routed traffic"""
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.ROUTED,
+            self.IS_IP4,
+            9,
+            tags=self.DOT1AD,
+            isMACIP=False,
+        )
 
     def test_acl_routed_ip6_subif_dot1ad_deny_by_tags(self):
-        """ IP6 ACL SubIf wrong tags Dot1AD routed traffic"""
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.ROUTED,
-                         self.IS_IP6, 9, True, tags=self.DOT1AD, isMACIP=False,
-                         permit_tags=self.DENY_TAGS)
+        """IP6 ACL SubIf wrong tags Dot1AD routed traffic"""
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.ROUTED,
+            self.IS_IP6,
+            9,
+            True,
+            tags=self.DOT1AD,
+            isMACIP=False,
+            permit_tags=self.DENY_TAGS,
+        )
 
     def test_acl_routed_ip4_subif_dot1ad_deny_by_tags(self):
-        """ IP4 ACL SubIf wrong tags Dot1AD routed traffic"""
-        self.run_traffic(self.EXACT_MAC, self.EXACT_IP, self.ROUTED,
-                         self.IS_IP4, 9, True, tags=self.DOT1AD, isMACIP=False,
-                         permit_tags=self.DENY_TAGS)
-
-
-if __name__ == '__main__':
+        """IP4 ACL SubIf wrong tags Dot1AD routed traffic"""
+        self.run_traffic(
+            self.EXACT_MAC,
+            self.EXACT_IP,
+            self.ROUTED,
+            self.IS_IP4,
+            9,
+            True,
+            tags=self.DOT1AD,
+            isMACIP=False,
+            permit_tags=self.DENY_TAGS,
+        )
+
+
+if __name__ == "__main__":
     unittest.main(testRunner=VppTestRunner)