nat: remove non-error error counters
[vpp.git] / src / plugins / nat / test / test_nat.py
index e996373..16ffcfd 100644 (file)
@@ -1389,6 +1389,19 @@ class MethodHolder(VppTestCase):
 class TestNAT44(MethodHolder):
     """ NAT44 Test Cases """
 
+    max_translations = 10240
+    max_users = 10240
+
+    @classmethod
+    def setUpConstants(cls):
+        super(TestNAT44, cls).setUpConstants()
+        cls.vpp_cmdline.extend([
+            "nat", "{",
+            "max translations per thread %d" % cls.max_translations,
+            "max users per thread %d" % cls.max_users,
+            "}"
+        ])
+
     @classmethod
     def setUpClass(cls):
         super(TestNAT44, cls).setUpClass()
@@ -1501,14 +1514,10 @@ class TestNAT44(MethodHolder):
             is_add=1)
 
         # in2out
-        tcpn = self.statistics.get_err_counter(
-            '/err/nat44-in2out-slowpath/TCP packets')
-        udpn = self.statistics.get_err_counter(
-            '/err/nat44-in2out-slowpath/UDP packets')
-        icmpn = self.statistics.get_err_counter(
-            '/err/nat44-in2out-slowpath/ICMP packets')
-        totaln = self.statistics.get_err_counter(
-            '/err/nat44-in2out-slowpath/good in2out packets processed')
+        tcpn = self.statistics.get_counter('/nat44/in2out/slowpath/tcp')[0]
+        udpn = self.statistics.get_counter('/nat44/in2out/slowpath/udp')[0]
+        icmpn = self.statistics.get_counter('/nat44/in2out/slowpath/icmp')[0]
+        drops = self.statistics.get_counter('/nat44/in2out/slowpath/drops')[0]
 
         pkts = self.create_stream_in(self.pg0, self.pg1)
         self.pg0.add_stream(pkts)
@@ -1517,26 +1526,21 @@ class TestNAT44(MethodHolder):
         capture = self.pg1.get_capture(len(pkts))
         self.verify_capture_out(capture)
 
-        err = self.statistics.get_err_counter(
-            '/err/nat44-in2out-slowpath/TCP packets')
-        self.assertEqual(err - tcpn, 2)
-        err = self.statistics.get_err_counter(
-            '/err/nat44-in2out-slowpath/UDP packets')
-        self.assertEqual(err - udpn, 1)
-        err = self.statistics.get_err_counter(
-            '/err/nat44-in2out-slowpath/ICMP packets')
-        self.assertEqual(err - icmpn, 1)
-        err = self.statistics.get_err_counter(
-            '/err/nat44-in2out-slowpath/good in2out packets processed')
-        self.assertEqual(err - totaln, 4)
+        if_idx = self.pg0.sw_if_index
+        cnt = self.statistics.get_counter('/nat44/in2out/slowpath/tcp')[0]
+        self.assertEqual(cnt[if_idx] - tcpn[if_idx], 2)
+        cnt = self.statistics.get_counter('/nat44/in2out/slowpath/udp')[0]
+        self.assertEqual(cnt[if_idx] - udpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat44/in2out/slowpath/icmp')[0]
+        self.assertEqual(cnt[if_idx] - icmpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat44/in2out/slowpath/drops')[0]
+        self.assertEqual(cnt[if_idx] - drops[if_idx], 0)
 
         # out2in
-        tcpn = self.statistics.get_err_counter('/err/nat44-out2in/TCP packets')
-        udpn = self.statistics.get_err_counter('/err/nat44-out2in/UDP packets')
-        icmpn = self.statistics.get_err_counter(
-            '/err/nat44-out2in/ICMP packets')
-        totaln = self.statistics.get_err_counter(
-            '/err/nat44-out2in/good out2in packets processed')
+        tcpn = self.statistics.get_counter('/nat44/out2in/slowpath/tcp')[0]
+        udpn = self.statistics.get_counter('/nat44/out2in/slowpath/udp')[0]
+        icmpn = self.statistics.get_counter('/nat44/out2in/slowpath/icmp')[0]
+        drops = self.statistics.get_counter('/nat44/out2in/slowpath/drops')[0]
 
         pkts = self.create_stream_out(self.pg1)
         self.pg1.add_stream(pkts)
@@ -1545,15 +1549,15 @@ class TestNAT44(MethodHolder):
         capture = self.pg0.get_capture(len(pkts))
         self.verify_capture_in(capture, self.pg0)
 
-        err = self.statistics.get_err_counter('/err/nat44-out2in/TCP packets')
-        self.assertEqual(err - tcpn, 2)
-        err = self.statistics.get_err_counter('/err/nat44-out2in/UDP packets')
-        self.assertEqual(err - udpn, 1)
-        err = self.statistics.get_err_counter('/err/nat44-out2in/ICMP packets')
-        self.assertEqual(err - icmpn, 1)
-        err = self.statistics.get_err_counter(
-            '/err/nat44-out2in/good out2in packets processed')
-        self.assertEqual(err - totaln, 4)
+        if_idx = self.pg1.sw_if_index
+        cnt = self.statistics.get_counter('/nat44/out2in/slowpath/tcp')[0]
+        self.assertEqual(cnt[if_idx] - tcpn[if_idx], 2)
+        cnt = self.statistics.get_counter('/nat44/out2in/slowpath/udp')[0]
+        self.assertEqual(cnt[if_idx] - udpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat44/out2in/slowpath/icmp')[0]
+        self.assertEqual(cnt[if_idx] - icmpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat44/out2in/slowpath/drops')[0]
+        self.assertEqual(cnt[if_idx] - drops[if_idx], 0)
 
         users = self.statistics.get_counter('/nat44/total-users')
         self.assertEqual(users[0][0], 1)
@@ -2341,6 +2345,7 @@ class TestNAT44(MethodHolder):
                                       server_in_port, server_out_port,
                                       proto=IP_PROTOS.tcp)
 
+        cnt = self.statistics.get_counter('/nat44/hairpinning')[0]
         # send packet from host to server
         p = (Ether(src=host.mac, dst=self.pg0.local_mac) /
              IP(src=host.ip4, dst=self.nat_addr) /
@@ -2363,6 +2368,10 @@ class TestNAT44(MethodHolder):
             self.logger.error(ppp("Unexpected or invalid packet:", p))
             raise
 
+        after = self.statistics.get_counter('/nat44/hairpinning')[0]
+        if_idx = self.pg0.sw_if_index
+        self.assertEqual(after[if_idx] - cnt[if_idx], 1)
+
         # send reply from server to host
         p = (Ether(src=server.mac, dst=self.pg0.local_mac) /
              IP(src=server.ip4, dst=self.nat_addr) /
@@ -2384,6 +2393,10 @@ class TestNAT44(MethodHolder):
             self.logger.error(ppp("Unexpected or invalid packet:", p))
             raise
 
+        after = self.statistics.get_counter('/nat44/hairpinning')[0]
+        if_idx = self.pg0.sw_if_index
+        self.assertEqual(after[if_idx] - cnt[if_idx], 2)
+
     def test_hairpinning2(self):
         """ NAT44 hairpinning - 1:1 NAT"""
 
@@ -2785,8 +2798,7 @@ class TestNAT44(MethodHolder):
             sw_if_index=self.pg1.sw_if_index,
             is_add=1)
 
-        nat44_config = self.vapi.nat_show_config()
-        max_sessions = 10 * nat44_config.translation_buckets
+        max_sessions = self.max_translations
 
         pkts = []
         for i in range(0, max_sessions):
@@ -4665,14 +4677,12 @@ class TestNAT44EndpointDependent(MethodHolder):
         self.assertEqual(1, nat_config.endpoint_dependent)
 
         # in2out
-        tcpn = self.statistics.get_err_counter(
-            '/err/nat44-ed-in2out-slowpath/TCP packets')
-        udpn = self.statistics.get_err_counter(
-            '/err/nat44-ed-in2out-slowpath/UDP packets')
-        icmpn = self.statistics.get_err_counter(
-            '/err/nat44-ed-in2out-slowpath/ICMP packets')
-        totaln = self.statistics.get_err_counter(
-            '/err/nat44-ed-in2out-slowpath/good in2out packets processed')
+        tcpn = self.statistics.get_counter('/nat44/ed/in2out/slowpath/tcp')[0]
+        udpn = self.statistics.get_counter('/nat44/ed/in2out/slowpath/udp')[0]
+        icmpn = self.statistics.get_counter(
+            '/nat44/ed/in2out/slowpath/icmp')[0]
+        drops = self.statistics.get_counter(
+            '/nat44/ed/in2out/slowpath/drops')[0]
 
         pkts = self.create_stream_in(self.pg0, self.pg1)
         self.pg0.add_stream(pkts)
@@ -4681,28 +4691,23 @@ class TestNAT44EndpointDependent(MethodHolder):
         capture = self.pg1.get_capture(len(pkts))
         self.verify_capture_out(capture, ignore_port=True)
 
-        err = self.statistics.get_err_counter(
-            '/err/nat44-ed-in2out-slowpath/TCP packets')
-        self.assertEqual(err - tcpn, 2)
-        err = self.statistics.get_err_counter(
-            '/err/nat44-ed-in2out-slowpath/UDP packets')
-        self.assertEqual(err - udpn, 1)
-        err = self.statistics.get_err_counter(
-            '/err/nat44-ed-in2out-slowpath/ICMP packets')
-        self.assertEqual(err - icmpn, 1)
-        err = self.statistics.get_err_counter(
-            '/err/nat44-ed-in2out-slowpath/good in2out packets processed')
-        self.assertEqual(err - totaln, 4)
+        if_idx = self.pg0.sw_if_index
+        cnt = self.statistics.get_counter('/nat44/ed/in2out/slowpath/tcp')[0]
+        self.assertEqual(cnt[if_idx] - tcpn[if_idx], 2)
+        cnt = self.statistics.get_counter('/nat44/ed/in2out/slowpath/udp')[0]
+        self.assertEqual(cnt[if_idx] - udpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat44/ed/in2out/slowpath/icmp')[0]
+        self.assertEqual(cnt[if_idx] - icmpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat44/ed/in2out/slowpath/drops')[0]
+        self.assertEqual(cnt[if_idx] - drops[if_idx], 0)
 
         # out2in
-        tcpn = self.statistics.get_err_counter(
-            '/err/nat44-ed-out2in/TCP packets')
-        udpn = self.statistics.get_err_counter(
-            '/err/nat44-ed-out2in/UDP packets')
-        icmpn = self.statistics.get_err_counter(
-            '/err/nat44-ed-out2in-slowpath/ICMP packets')
-        totaln = self.statistics.get_err_counter(
-            '/err/nat44-ed-out2in/good out2in packets processed')
+        tcpn = self.statistics.get_counter('/nat44/ed/out2in/fastpath/tcp')[0]
+        udpn = self.statistics.get_counter('/nat44/ed/out2in/fastpath/udp')[0]
+        icmpn = self.statistics.get_counter(
+            '/nat44/ed/out2in/slowpath/icmp')[0]
+        drops = self.statistics.get_counter(
+            '/nat44/ed/out2in/fastpath/drops')[0]
 
         pkts = self.create_stream_out(self.pg1)
         self.pg1.add_stream(pkts)
@@ -4711,18 +4716,15 @@ class TestNAT44EndpointDependent(MethodHolder):
         capture = self.pg0.get_capture(len(pkts))
         self.verify_capture_in(capture, self.pg0)
 
-        err = self.statistics.get_err_counter(
-            '/err/nat44-ed-out2in/TCP packets')
-        self.assertEqual(err - tcpn, 2)
-        err = self.statistics.get_err_counter(
-            '/err/nat44-ed-out2in/UDP packets')
-        self.assertEqual(err - udpn, 1)
-        err = self.statistics.get_err_counter(
-            '/err/nat44-ed-out2in-slowpath/ICMP packets')
-        self.assertEqual(err - icmpn, 1)
-        err = self.statistics.get_err_counter(
-            '/err/nat44-ed-out2in/good out2in packets processed')
-        self.assertEqual(err - totaln, 3)
+        if_idx = self.pg1.sw_if_index
+        cnt = self.statistics.get_counter('/nat44/ed/out2in/fastpath/tcp')[0]
+        self.assertEqual(cnt[if_idx] - tcpn[if_idx], 2)
+        cnt = self.statistics.get_counter('/nat44/ed/out2in/fastpath/udp')[0]
+        self.assertEqual(cnt[if_idx] - udpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat44/ed/out2in/slowpath/icmp')[0]
+        self.assertEqual(cnt[if_idx] - icmpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat44/ed/out2in/fastpath/drops')[0]
+        self.assertEqual(cnt[if_idx] - drops[if_idx], 0)
 
         sessions = self.statistics.get_counter('/nat44/total-sessions')
         self.assertEqual(sessions[0][0], 3)
@@ -4807,14 +4809,14 @@ class TestNAT44EndpointDependent(MethodHolder):
             self.assertEqual(1, nat_config.endpoint_dependent)
 
             # in2out
-            tcpn = self.statistics.get_err_counter(
-                '/err/nat44-ed-in2out-slowpath/TCP packets')
-            udpn = self.statistics.get_err_counter(
-                '/err/nat44-ed-in2out-slowpath/UDP packets')
-            icmpn = self.statistics.get_err_counter(
-                '/err/nat44-ed-in2out-slowpath/ICMP packets')
-            totaln = self.statistics.get_err_counter(
-                '/err/nat44-ed-in2out-slowpath/good in2out packets processed')
+            tcpn = self.statistics.get_counter(
+                '/nat44/ed/in2out/slowpath/tcp')[0]
+            udpn = self.statistics.get_counter(
+                '/nat44/ed/in2out/slowpath/udp')[0]
+            icmpn = self.statistics.get_counter(
+                '/nat44/ed/in2out/slowpath/icmp')[0]
+            drops = self.statistics.get_counter(
+                '/nat44/ed/in2out/slowpath/drops')[0]
 
             pkts = self.create_stream_in(self.pg7, self.pg8)
             self.pg7.add_stream(pkts)
@@ -4823,28 +4825,29 @@ class TestNAT44EndpointDependent(MethodHolder):
             capture = self.pg8.get_capture(len(pkts))
             self.verify_capture_out(capture, ignore_port=True)
 
-            err = self.statistics.get_err_counter(
-                '/err/nat44-ed-in2out-slowpath/TCP packets')
-            self.assertEqual(err - tcpn, 2)
-            err = self.statistics.get_err_counter(
-                '/err/nat44-ed-in2out-slowpath/UDP packets')
-            self.assertEqual(err - udpn, 1)
-            err = self.statistics.get_err_counter(
-                '/err/nat44-ed-in2out-slowpath/ICMP packets')
-            self.assertEqual(err - icmpn, 1)
-            err = self.statistics.get_err_counter(
-                '/err/nat44-ed-in2out-slowpath/good in2out packets processed')
-            self.assertEqual(err - totaln, 4)
+            if_idx = self.pg7.sw_if_index
+            cnt = self.statistics.get_counter(
+                '/nat44/ed/in2out/slowpath/tcp')[0]
+            self.assertEqual(cnt[if_idx] - tcpn[if_idx], 2)
+            cnt = self.statistics.get_counter(
+                '/nat44/ed/in2out/slowpath/udp')[0]
+            self.assertEqual(cnt[if_idx] - udpn[if_idx], 1)
+            cnt = self.statistics.get_counter(
+                '/nat44/ed/in2out/slowpath/icmp')[0]
+            self.assertEqual(cnt[if_idx] - icmpn[if_idx], 1)
+            cnt = self.statistics.get_counter(
+                '/nat44/ed/in2out/slowpath/drops')[0]
+            self.assertEqual(cnt[if_idx] - drops[if_idx], 0)
 
             # out2in
-            tcpn = self.statistics.get_err_counter(
-                '/err/nat44-ed-out2in/TCP packets')
-            udpn = self.statistics.get_err_counter(
-                '/err/nat44-ed-out2in/UDP packets')
-            icmpn = self.statistics.get_err_counter(
-                '/err/nat44-ed-out2in-slowpath/ICMP packets')
-            totaln = self.statistics.get_err_counter(
-                '/err/nat44-ed-out2in/good out2in packets processed')
+            tcpn = self.statistics.get_counter(
+                '/nat44/ed/out2in/fastpath/tcp')[0]
+            udpn = self.statistics.get_counter(
+                '/nat44/ed/out2in/fastpath/udp')[0]
+            icmpn = self.statistics.get_counter(
+                '/nat44/ed/out2in/slowpath/icmp')[0]
+            drops = self.statistics.get_counter(
+                '/nat44/ed/out2in/fastpath/drops')[0]
 
             pkts = self.create_stream_out(self.pg8)
             self.pg8.add_stream(pkts)
@@ -4853,18 +4856,19 @@ class TestNAT44EndpointDependent(MethodHolder):
             capture = self.pg7.get_capture(len(pkts))
             self.verify_capture_in(capture, self.pg7)
 
-            err = self.statistics.get_err_counter(
-                '/err/nat44-ed-out2in/TCP packets')
-            self.assertEqual(err - tcpn, 2)
-            err = self.statistics.get_err_counter(
-                '/err/nat44-ed-out2in/UDP packets')
-            self.assertEqual(err - udpn, 1)
-            err = self.statistics.get_err_counter(
-                '/err/nat44-ed-out2in-slowpath/ICMP packets')
-            self.assertEqual(err - icmpn, 1)
-            err = self.statistics.get_err_counter(
-                '/err/nat44-ed-out2in/good out2in packets processed')
-            self.assertEqual(err - totaln, 3)
+            if_idx = self.pg8.sw_if_index
+            cnt = self.statistics.get_counter(
+                '/nat44/ed/out2in/fastpath/tcp')[0]
+            self.assertEqual(cnt[if_idx] - tcpn[if_idx], 2)
+            cnt = self.statistics.get_counter(
+                '/nat44/ed/out2in/fastpath/udp')[0]
+            self.assertEqual(cnt[if_idx] - udpn[if_idx], 1)
+            cnt = self.statistics.get_counter(
+                '/nat44/ed/out2in/slowpath/icmp')[0]
+            self.assertEqual(cnt[if_idx] - icmpn[if_idx], 1)
+            cnt = self.statistics.get_counter(
+                '/nat44/ed/out2in/fastpath/drops')[0]
+            self.assertEqual(cnt[if_idx] - drops[if_idx], 0)
 
             sessions = self.statistics.get_counter('/nat44/total-sessions')
             self.assertEqual(sessions[0][0], 3)
@@ -8321,12 +8325,10 @@ class TestNAT64(MethodHolder):
                                           sw_if_index=self.pg1.sw_if_index)
 
         # in2out
-        tcpn = self.statistics.get_err_counter('/err/nat64-in2out/TCP packets')
-        udpn = self.statistics.get_err_counter('/err/nat64-in2out/UDP packets')
-        icmpn = self.statistics.get_err_counter(
-            '/err/nat64-in2out/ICMP packets')
-        totaln = self.statistics.get_err_counter(
-            '/err/nat64-in2out/good in2out packets processed')
+        tcpn = self.statistics.get_counter('/nat64/in2out/tcp')[0]
+        udpn = self.statistics.get_counter('/nat64/in2out/udp')[0]
+        icmpn = self.statistics.get_counter('/nat64/in2out/icmp')[0]
+        drops = self.statistics.get_counter('/nat64/in2out/drops')[0]
 
         pkts = self.create_stream_in_ip6(self.pg0, self.pg1)
         self.pg0.add_stream(pkts)
@@ -8336,23 +8338,21 @@ class TestNAT64(MethodHolder):
         self.verify_capture_out(capture, nat_ip=self.nat_addr,
                                 dst_ip=self.pg1.remote_ip4)
 
-        err = self.statistics.get_err_counter('/err/nat64-in2out/TCP packets')
-        self.assertEqual(err - tcpn, 1)
-        err = self.statistics.get_err_counter('/err/nat64-in2out/UDP packets')
-        self.assertEqual(err - udpn, 1)
-        err = self.statistics.get_err_counter('/err/nat64-in2out/ICMP packets')
-        self.assertEqual(err - icmpn, 1)
-        err = self.statistics.get_err_counter(
-            '/err/nat64-in2out/good in2out packets processed')
-        self.assertEqual(err - totaln, 3)
+        if_idx = self.pg0.sw_if_index
+        cnt = self.statistics.get_counter('/nat64/in2out/tcp')[0]
+        self.assertEqual(cnt[if_idx] - tcpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat64/in2out/udp')[0]
+        self.assertEqual(cnt[if_idx] - udpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat64/in2out/icmp')[0]
+        self.assertEqual(cnt[if_idx] - icmpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat64/in2out/drops')[0]
+        self.assertEqual(cnt[if_idx] - drops[if_idx], 0)
 
         # out2in
-        tcpn = self.statistics.get_err_counter('/err/nat64-out2in/TCP packets')
-        udpn = self.statistics.get_err_counter('/err/nat64-out2in/UDP packets')
-        icmpn = self.statistics.get_err_counter(
-            '/err/nat64-out2in/ICMP packets')
-        totaln = self.statistics.get_err_counter(
-            '/err/nat64-out2in/good out2in packets processed')
+        tcpn = self.statistics.get_counter('/nat64/out2in/tcp')[0]
+        udpn = self.statistics.get_counter('/nat64/out2in/udp')[0]
+        icmpn = self.statistics.get_counter('/nat64/out2in/icmp')[0]
+        drops = self.statistics.get_counter('/nat64/out2in/drops')[0]
 
         pkts = self.create_stream_out(self.pg1, dst_ip=self.nat_addr)
         self.pg1.add_stream(pkts)
@@ -8362,15 +8362,15 @@ class TestNAT64(MethodHolder):
         ip = IPv6(src=''.join(['64:ff9b::', self.pg1.remote_ip4]))
         self.verify_capture_in_ip6(capture, ip[IPv6].src, self.pg0.remote_ip6)
 
-        err = self.statistics.get_err_counter('/err/nat64-out2in/TCP packets')
-        self.assertEqual(err - tcpn, 2)
-        err = self.statistics.get_err_counter('/err/nat64-out2in/UDP packets')
-        self.assertEqual(err - udpn, 1)
-        err = self.statistics.get_err_counter('/err/nat64-out2in/ICMP packets')
-        self.assertEqual(err - icmpn, 1)
-        err = self.statistics.get_err_counter(
-            '/err/nat64-out2in/good out2in packets processed')
-        self.assertEqual(err - totaln, 4)
+        if_idx = self.pg1.sw_if_index
+        cnt = self.statistics.get_counter('/nat64/out2in/tcp')[0]
+        self.assertEqual(cnt[if_idx] - tcpn[if_idx], 2)
+        cnt = self.statistics.get_counter('/nat64/out2in/udp')[0]
+        self.assertEqual(cnt[if_idx] - udpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat64/out2in/icmp')[0]
+        self.assertEqual(cnt[if_idx] - icmpn[if_idx], 1)
+        cnt = self.statistics.get_counter('/nat64/out2in/drops')[0]
+        self.assertEqual(cnt[if_idx] - drops[if_idx], 0)
 
         bibs = self.statistics.get_counter('/nat64/total-bibs')
         self.assertEqual(bibs[0][0], 3)
@@ -9494,158 +9494,5 @@ class TestNAT64(MethodHolder):
         self.logger.info(self.vapi.cli("show nat64 session table all"))
 
 
-class TestNAT66(MethodHolder):
-    """ NAT66 Test Cases """
-
-    @classmethod
-    def setUpClass(cls):
-        super(TestNAT66, cls).setUpClass()
-
-        cls.nat_addr = 'fd01:ff::2'
-
-        cls.create_pg_interfaces(range(2))
-        cls.interfaces = list(cls.pg_interfaces)
-
-        for i in cls.interfaces:
-            i.admin_up()
-            i.config_ip6()
-            i.configure_ipv6_neighbors()
-
-    @classmethod
-    def tearDownClass(cls):
-        super(TestNAT66, cls).tearDownClass()
-
-    def test_static(self):
-        """ 1:1 NAT66 test """
-        flags = self.config_flags.NAT_IS_INSIDE
-        self.vapi.nat66_add_del_interface(is_add=1, flags=flags,
-                                          sw_if_index=self.pg0.sw_if_index)
-        self.vapi.nat66_add_del_interface(is_add=1,
-                                          sw_if_index=self.pg1.sw_if_index)
-        self.vapi.nat66_add_del_static_mapping(
-            local_ip_address=self.pg0.remote_ip6,
-            external_ip_address=self.nat_addr,
-            is_add=1)
-
-        # in2out
-        pkts = []
-        p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
-             IPv6(src=self.pg0.remote_ip6, dst=self.pg1.remote_ip6) /
-             TCP())
-        pkts.append(p)
-        p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
-             IPv6(src=self.pg0.remote_ip6, dst=self.pg1.remote_ip6) /
-             UDP())
-        pkts.append(p)
-        p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
-             IPv6(src=self.pg0.remote_ip6, dst=self.pg1.remote_ip6) /
-             ICMPv6EchoRequest())
-        pkts.append(p)
-        p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
-             IPv6(src=self.pg0.remote_ip6, dst=self.pg1.remote_ip6) /
-             GRE() / IP() / TCP())
-        pkts.append(p)
-        self.pg0.add_stream(pkts)
-        self.pg_enable_capture(self.pg_interfaces)
-        self.pg_start()
-        capture = self.pg1.get_capture(len(pkts))
-
-        for packet in capture:
-            try:
-                self.assertEqual(packet[IPv6].src, self.nat_addr)
-                self.assertEqual(packet[IPv6].dst, self.pg1.remote_ip6)
-                self.assert_packet_checksums_valid(packet)
-            except:
-                self.logger.error(ppp("Unexpected or invalid packet:", packet))
-                raise
-
-        # out2in
-        pkts = []
-        p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
-             IPv6(src=self.pg1.remote_ip6, dst=self.nat_addr) /
-             TCP())
-        pkts.append(p)
-        p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
-             IPv6(src=self.pg1.remote_ip6, dst=self.nat_addr) /
-             UDP())
-        pkts.append(p)
-        p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
-             IPv6(src=self.pg1.remote_ip6, dst=self.nat_addr) /
-             ICMPv6EchoReply())
-        pkts.append(p)
-        p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
-             IPv6(src=self.pg1.remote_ip6, dst=self.nat_addr) /
-             GRE() / IP() / TCP())
-        pkts.append(p)
-        self.pg1.add_stream(pkts)
-        self.pg_enable_capture(self.pg_interfaces)
-        self.pg_start()
-        capture = self.pg0.get_capture(len(pkts))
-        for packet in capture:
-            try:
-                self.assertEqual(packet[IPv6].src, self.pg1.remote_ip6)
-                self.assertEqual(packet[IPv6].dst, self.pg0.remote_ip6)
-                self.assert_packet_checksums_valid(packet)
-            except:
-                self.logger.error(ppp("Unexpected or invalid packet:", packet))
-                raise
-
-        sm = self.vapi.nat66_static_mapping_dump()
-        self.assertEqual(len(sm), 1)
-        self.assertEqual(sm[0].total_pkts, 8)
-
-    def test_check_no_translate(self):
-        """ NAT66 translate only when egress interface is outside interface """
-        flags = self.config_flags.NAT_IS_INSIDE
-        self.vapi.nat66_add_del_interface(is_add=1, flags=flags,
-                                          sw_if_index=self.pg0.sw_if_index)
-        self.vapi.nat66_add_del_interface(is_add=1, flags=flags,
-                                          sw_if_index=self.pg1.sw_if_index)
-        self.vapi.nat66_add_del_static_mapping(
-            local_ip_address=self.pg0.remote_ip6,
-            external_ip_address=self.nat_addr,
-            is_add=1)
-
-        # in2out
-        p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
-             IPv6(src=self.pg0.remote_ip6, dst=self.pg1.remote_ip6) /
-             UDP())
-        self.pg0.add_stream([p])
-        self.pg_enable_capture(self.pg_interfaces)
-        self.pg_start()
-        capture = self.pg1.get_capture(1)
-        packet = capture[0]
-        try:
-            self.assertEqual(packet[IPv6].src, self.pg0.remote_ip6)
-            self.assertEqual(packet[IPv6].dst, self.pg1.remote_ip6)
-        except:
-            self.logger.error(ppp("Unexpected or invalid packet:", packet))
-            raise
-
-    def clear_nat66(self):
-        """
-        Clear NAT66 configuration.
-        """
-        interfaces = self.vapi.nat66_interface_dump()
-        for intf in interfaces:
-            self.vapi.nat66_add_del_interface(is_add=0, flags=intf.flags,
-                                              sw_if_index=intf.sw_if_index)
-
-        static_mappings = self.vapi.nat66_static_mapping_dump()
-        for sm in static_mappings:
-            self.vapi.nat66_add_del_static_mapping(
-                local_ip_address=sm.local_ip_address,
-                external_ip_address=sm.external_ip_address, vrf_id=sm.vrf_id,
-                is_add=0)
-
-    def tearDown(self):
-        super(TestNAT66, self).tearDown()
-        self.clear_nat66()
-
-    def show_commands_at_teardown(self):
-        self.logger.info(self.vapi.cli("show nat66 interfaces"))
-        self.logger.info(self.vapi.cli("show nat66 static mappings"))
-
-
 if __name__ == '__main__':
     unittest.main(testRunner=VppTestRunner)