tests: replace pycodestyle with black

[vpp.git] / test / template_bd.py

diff --git a/test/template_bd.py b/test/template_bd.py
index bebe76d..55aaa5a 100644 (file)
--- a/test/template_bd.py
+++ b/test/template_bd.py
@@ -8,51 +8,55 @@ from scapy.layers.inet import IP, UDP
 
 
 class BridgeDomain(metaclass=abc.ABCMeta):
 
 
 class BridgeDomain(metaclass=abc.ABCMeta):

-    """ Bridge domain abstraction """
+    """Bridge domain abstraction"""

 
     @property
     def frame_request(self):
 
     @property
     def frame_request(self):

-        """ Ethernet frame modeling a generic request """
-        return (Ether(src='00:00:00:00:00:01', dst='00:00:00:00:00:02') /
-                IP(src='1.2.3.4', dst='4.3.2.1') /
-                UDP(sport=10000, dport=20000) /
-                Raw('\xa5' * 100))
+        """Ethernet frame modeling a generic request"""
+        return (
+            Ether(src="00:00:00:00:00:01", dst="00:00:00:00:00:02")
+            / IP(src="1.2.3.4", dst="4.3.2.1")
+            / UDP(sport=10000, dport=20000)
+            / Raw("\xa5" * 100)
+        )

 
     @property
     def frame_reply(self):
 
     @property
     def frame_reply(self):

-        """ Ethernet frame modeling a generic reply """
-        return (Ether(src='00:00:00:00:00:02', dst='00:00:00:00:00:01') /
-                IP(src='4.3.2.1', dst='1.2.3.4') /
-                UDP(sport=20000, dport=10000) /
-                Raw('\xa5' * 100))
+        """Ethernet frame modeling a generic reply"""
+        return (
+            Ether(src="00:00:00:00:00:02", dst="00:00:00:00:00:01")
+            / IP(src="4.3.2.1", dst="1.2.3.4")
+            / UDP(sport=20000, dport=10000)
+            / Raw("\xa5" * 100)
+        )

 
     @abc.abstractmethod
     def ip_range(self, start, end):
 
     @abc.abstractmethod
     def ip_range(self, start, end):

-        """ range of remote ip's """
+        """range of remote ip's"""

         pass
 
     @abc.abstractmethod
     def encap_mcast(self, pkt, src_ip, src_mac, vni):
         pass
 
     @abc.abstractmethod
     def encap_mcast(self, pkt, src_ip, src_mac, vni):

-        """ Encapsulate mcast packet """
+        """Encapsulate mcast packet"""

         pass
 
     @abc.abstractmethod
     def encapsulate(self, pkt, vni):
         pass
 
     @abc.abstractmethod
     def encapsulate(self, pkt, vni):

-        """ Encapsulate packet """
+        """Encapsulate packet"""

         pass
 
     @abc.abstractmethod
     def decapsulate(self, pkt):
         pass
 
     @abc.abstractmethod
     def decapsulate(self, pkt):

-        """ Decapsulate packet """
+        """Decapsulate packet"""

         pass
 
     @abc.abstractmethod
     def check_encapsulation(self, pkt, vni, local_only=False):
         pass
 
     @abc.abstractmethod
     def check_encapsulation(self, pkt, vni, local_only=False):

-        """ Verify the encapsulation """
+        """Verify the encapsulation"""

         pass
 
     def assert_eq_pkts(self, pkt1, pkt2):
         pass
 
     def assert_eq_pkts(self, pkt1, pkt2):

-        """ Verify the Ether, IP, UDP, payload are equal in both
+        """Verify the Ether, IP, UDP, payload are equal in both

         packets
         """
         self.assertEqual(pkt1[Ether].src, pkt2[Ether].src)
         packets
         """
         self.assertEqual(pkt1[Ether].src, pkt2[Ether].src)


@@ -64,15 +68,18 @@ class BridgeDomain(metaclass=abc.ABCMeta):
         self.assertEqual(pkt1[Raw], pkt2[Raw])
 
     def test_decap(self):
         self.assertEqual(pkt1[Raw], pkt2[Raw])
 
     def test_decap(self):

-        """ Decapsulation test
+        """Decapsulation test

         Send encapsulated frames from pg0
         Verify receipt of decapsulated frames on pg1
         """
 
         Send encapsulated frames from pg0
         Verify receipt of decapsulated frames on pg1
         """
 

-        encapsulated_pkt = self.encapsulate(self.frame_request,
-                                            self.single_tunnel_vni)
+        encapsulated_pkt = self.encapsulate(self.frame_request, self.single_tunnel_vni)

 
 

-        self.pg0.add_stream([encapsulated_pkt, ])
+        self.pg0.add_stream(
+            [
+                encapsulated_pkt,
+            ]
+        )

 
         self.pg1.enable_capture()
 
 
         self.pg1.enable_capture()
 


@@ -85,7 +92,7 @@ class BridgeDomain(metaclass=abc.ABCMeta):
         self.assert_eq_pkts(pkt, self.frame_request)
 
     def test_encap(self):
         self.assert_eq_pkts(pkt, self.frame_request)
 
     def test_encap(self):

-        """ Encapsulation test
+        """Encapsulation test

         Send frames from pg1
         Verify receipt of encapsulated frames on pg0
         """
         Send frames from pg1
         Verify receipt of encapsulated frames on pg0
         """


@@ -104,7 +111,7 @@ class BridgeDomain(metaclass=abc.ABCMeta):
         self.assert_eq_pkts(payload, self.frame_reply)
 
     def test_ucast_flood(self):
         self.assert_eq_pkts(payload, self.frame_reply)
 
     def test_ucast_flood(self):

-        """ Unicast flood test
+        """Unicast flood test

         Send frames from pg3
         Verify receipt of encapsulated frames on pg0
         """
         Send frames from pg3
         Verify receipt of encapsulated frames on pg0
         """


@@ -122,7 +129,7 @@ class BridgeDomain(metaclass=abc.ABCMeta):
             self.assert_eq_pkts(payload, self.frame_reply)
 
     def test_mcast_flood(self):
             self.assert_eq_pkts(payload, self.frame_reply)
 
     def test_mcast_flood(self):

-        """ Multicast flood test
+        """Multicast flood test

         Send frames from pg2
         Verify receipt of encapsulated frames on pg0
         """
         Send frames from pg2
         Verify receipt of encapsulated frames on pg0
         """


@@ -135,14 +142,15 @@ class BridgeDomain(metaclass=abc.ABCMeta):
         # Pick first received frame and check if it's correctly encapsulated.
         out = self.pg0.get_capture(1)
         pkt = out[0]
         # Pick first received frame and check if it's correctly encapsulated.
         out = self.pg0.get_capture(1)
         pkt = out[0]

-        self.check_encapsulation(pkt, self.mcast_flood_bd,
-                                 local_only=False, mcast_pkt=True)
+        self.check_encapsulation(
+            pkt, self.mcast_flood_bd, local_only=False, mcast_pkt=True
+        )

 
         payload = self.decapsulate(pkt)
         self.assert_eq_pkts(payload, self.frame_reply)
 
     def test_mcast_rcv(self):
 
         payload = self.decapsulate(pkt)
         self.assert_eq_pkts(payload, self.frame_reply)
 
     def test_mcast_rcv(self):

-        """ Multicast receive test
+        """Multicast receive test

         Send 20 encapsulated frames from pg0 only 10 match unicast tunnels
         Verify receipt of 10 decap frames on pg2
         """
         Send 20 encapsulated frames from pg0 only 10 match unicast tunnels
         Verify receipt of 10 decap frames on pg2
         """


@@ -151,7 +159,8 @@ class BridgeDomain(metaclass=abc.ABCMeta):
         ip_range_end = 30
         mcast_stream = [
             self.encap_mcast(self.frame_request, ip, mac, self.mcast_flood_bd)
         ip_range_end = 30
         mcast_stream = [
             self.encap_mcast(self.frame_request, ip, mac, self.mcast_flood_bd)

-            for ip in self.ip_range(ip_range_start, ip_range_end)]
+            for ip in self.ip_range(ip_range_start, ip_range_end)
+        ]

         self.pg0.add_stream(mcast_stream)
         self.pg2.enable_capture()
         self.pg_start()
         self.pg0.add_stream(mcast_stream)
         self.pg2.enable_capture()
         self.pg_start()