[dts] [PATCH 0/2] add pipeline new features test scenarios

[dts] [PATCH 0/2] add pipeline new features test scenarios

[Churchill Khangar]

This patch series has the changes to support test suite
for pipeline application new features. Also changes to
improve existing test cases logic to cover different operand
lengths, endianness issues and additional test cases for
existing features.

Following are the details of new features and
existing test cases enhancements
     1. Framework enhancements to improve overall execution time.
     2. RING I/O port type
     3. WCM table match
     4. Register Array
     5. trTCM
     6. Enhancement to existing test cases to verify
          a. Endianness issue
          b. Operands with variable size values
     7. Additional tests to provide more coverage for table match and actions
     8. Additional tests to cover customer common use cases

Patch details
     1. Patch1 - pipeline dependencies archive and compressed
        file pipeline.tar.gz modified for all new features.
     2. Patch2 - add new features test coverage.

Churchill Khangar (2):
  dep: add pipeline test suite new feature dependencies
  tests/pipeline: add new features test coverage

 dep/pipeline.tar.gz         |  Bin 49082 -> 74543 bytes
 tests/TestSuite_pipeline.py | 8416 +++++++++++++++++++------------------------
 2 files changed, 3661 insertions(+), 4755 deletions(-)

-- 
1.8.3.1

[dts] [PATCH 1/2] dep: add pipeline test suite new feature dependencies

[Churchill Khangar]

This patch has the pipeline test suite dependencies
required to run PIPELINE new features
     1. RING I/O port type
     2. WCM table match
     3. Register Array
     4. trTCM
     5. Enhancement to existing test cases to verify
     	     a. Endianness issue
	     b. Operands with variable size values
     6. Additional tests to provide more coverage for table match and actions
     7. Additional tests to cover customer common use cases

Signed-off-by: Churchill Khangar <churchill.khangar@intel.com>
Signed-off-by: Yogesh Jangra <yogesh.jangra@intel.com>
Tested-by: Venkata Suresh Kumar P <venkata.suresh.kumar.p@intel.com>
---
 dep/pipeline.tar.gz | Bin 49082 -> 74543 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/dep/pipeline.tar.gz b/dep/pipeline.tar.gz
index 667e2698b618982af7bd6ef552503bc07e46a236..fb2849ee21e692756ef6b60f9a4f581b390c8c2e 100644
GIT binary patch
literal 74543
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

literal 49082
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

-- 
1.8.3.1

[dts] [PATCH 2/2] tests/pipeline: add new features test coverage

[Churchill Khangar]

This patch has the pipeline test suite changes to cover
the new features and enhancements to existing tests.
Following are the details of new features and
existing test cases enhancements
     1. Framework enhancements to improve overall execution time.
     2. RING I/O port type
     3. WCM table match
     4. Register Array
     5. trTCM
     6. Enhancement to existing test cases to verify
          a. Endianness issue
          b. Operands with variable size values
     7. Additional tests to provide more coverage for table match and actions
     8. Additional tests to cover customer common use cases

Signed-off-by: Churchill Khangar <churchill.khangar@intel.com>
Signed-off-by: Yogesh Jangra <yogesh.jangra@intel.com>
Tested-by: Venkata Suresh Kumar P <venkata.suresh.kumar.p@intel.com>
---
 tests/TestSuite_pipeline.py | 8416 +++++++++++++++++++------------------------
 1 file changed, 3661 insertions(+), 4755 deletions(-)

diff --git a/tests/TestSuite_pipeline.py b/tests/TestSuite_pipeline.py
index 9597896..d1f4d50 100644
--- a/tests/TestSuite_pipeline.py
+++ b/tests/TestSuite_pipeline.py
@@ -65,12 +65,17 @@ from scapy.sendrecv import sendp
 
 import itertools
 
+MODE = 1  # 0: Development, 1: Release
+
 TIMESTAMP = re.compile(r'\d{2}\:\d{2}\:\d{2}\.\d{6}')
 PAYLOAD = re.compile(r'\t0x([0-9a-fA-F]+):  ([0-9a-fA-F ]+)')
 
 FILE_DIR = os.path.dirname(os.path.abspath(__file__)).split(os.path.sep)
 DEP_DIR = os.path.sep.join(FILE_DIR[:-1]) + '/dep/'
 
+BUFFER_SIZE = 1024
+CLI_SERVER_CONNECT_DELAY = 1
+
 
 class TestPipeline(TestCase):
 
@@ -200,9 +205,52 @@ class TestPipeline(TestCase):
         self.convert_tcpdump_to_text2pcap('/tmp/packet_rx.txt', '/tmp/packet_rx_rcv.txt')
         out = self.tester.send_command(
             'diff -sqw /tmp/packet_rx_rcv.txt {}'.format('/tmp/' + out_pcap_file), timeout=0.5)
-        if "differ" in out:
+        if "are identical" not in out:
+            self.dut.send_expect('^C', '# ')
+            self.verify(False, "Output pcap files mismatch error")
+
+    def send_and_sniff_multiple(self, from_port, to_port, in_pcap, out_pcap, filters, rate=0):
+
+        self.tester.send_expect('rm -f /tmp/*.txt /tmp/*.pcap /tmp/*.out', '# ')
+        tx_count = len(from_port)
+        rx_count = len(to_port)
+        tx_port, rx_port, tx_inf, rx_inf = ([] for i in range(4))
+
+        for i in range(tx_count):
+            tx_port.append(self.tester.get_local_port(self.dut_ports[from_port[i]]))
+            tx_inf.append(self.tester.get_interface(tx_port[i]))
+
+        for i in range(rx_count):
+            rx_port.append(self.tester.get_local_port(self.dut_ports[to_port[i]]))
+            rx_inf.append(self.tester.get_interface(rx_port[i]))
+            self.tcpdump_start_sniff(rx_inf[i], filters[i])
+
+        self.tester.scapy_foreground()
+        for i in range(tx_count):
+            self.tester.send_expect(
+                'text2pcap -q {} /tmp/tx_{}.pcap'.format('/tmp/' + in_pcap[i], tx_inf[i]), '# ')
+            self.tester.scapy_append('pkt = rdpcap("/tmp/tx_{}.pcap")'.format(tx_inf[i]))
+            if rate:
+                self.tester.scapy_append(
+                    'sendp(pkt, iface="{}", count=1, inter=1./{})'.format(tx_inf[i], rate))
+            else:
+                self.tester.scapy_append('sendp(pkt, iface="{}", count=1)'.format(tx_inf[i]))
+
+        self.tester.scapy_execute()
+        self.tcpdump_stop_sniff()
+        mismatch_count = 0
+        for i in range(rx_count):
+            self.tester.send_expect(
+                'tcpdump -n -r /tmp/tcpdump_{}.pcap -xx > /tmp/packet_rx.txt'.format(rx_inf[i]), '# ')
+            self.convert_tcpdump_to_text2pcap(
+                '/tmp/packet_rx.txt', '/tmp/packet_rx_rcv_{}.txt'.format(rx_inf[i]))
+            cmd = 'diff -sqw /tmp/packet_rx_rcv_{}.txt {}'.format(rx_inf[i], '/tmp/' + out_pcap[i])
+            out = self.tester.send_command(cmd, timeout=0.5)
+            if "are identical" not in out:
+                mismatch_count += 1
+        if mismatch_count:
             self.dut.send_expect('^C', '# ')
-        self.verify("are identical" in out, "Output pcap files mismatch error")
+            self.verify(False, "Output pcap files mismatch error")
 
     def setup_env(self, port_nums, driver):
         """
@@ -279,7 +327,7 @@ class TestPipeline(TestCase):
         self.vf3_mac = "00:11:22:33:44:58"
 
         ports = [self.dut_p0_pci, self.dut_p1_pci, self.dut_p2_pci, self.dut_p3_pci]
-        self.eal_para = self.dut.create_eal_parameters(cores=list(range(2)), ports=ports)
+        self.eal_para = self.dut.create_eal_parameters(cores=list(range(4)), ports=ports)
         self.sriov_vfs_port = []
         self.session_secondary = self.dut.new_session()
 
@@ -289,10 +337,13 @@ class TestPipeline(TestCase):
         self.app_testpmd_path = self.dut.apps_name['test-pmd']
         self.param_flow_dir = self.get_flow_direction_param_of_tcpdump()
 
-        # update the ./dep/pipeline.tar.gz file for any new changes
-        P4_PIPILINE_TAR_FILE = DEP_DIR + 'pipeline.tar.gz'
+        # update the ./dep/pipeline.tar.gz file
+        PIPELINE_TAR_FILE = DEP_DIR + 'pipeline.tar.gz'
         self.tester.send_expect('rm -rf /tmp/pipeline', '# ')
-        self.tester.send_expect('tar -zxf {} --directory /tmp'.format(P4_PIPILINE_TAR_FILE), "# ", 20)
+        if MODE == 0:  # Development
+            self.tester.send_expect('rm -rf {}'.format(PIPELINE_TAR_FILE), '# ')
+            self.tester.send_expect('tar -czf {} -C {} pipeline/'.format(PIPELINE_TAR_FILE, DEP_DIR), '# ')
+        self.tester.send_expect('tar -zxf {} --directory /tmp'.format(PIPELINE_TAR_FILE), "# ", 20)
 
         # copy the ./dep/pipeline.tar.gz file to DUT
         self.dut.send_expect('rm -rf /tmp/pipeline.tar.gz /tmp/pipeline', "# ", 20)
@@ -305,47 +356,44 @@ class TestPipeline(TestCase):
         """
         pass
 
-    def test_rx_tx_001(self):
-        """
-        rx_tx_001: revert the received packet on the same port without any change
-        """
-        cli_file = '/tmp/pipeline/rx_tx_001/rx_tx_001.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/rx_tx_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/rx_tx_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def connect_cli_server(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        SERVER_IP = '192.168.122.216'
+        SERVER_PORT = 8086
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            try:
+                s.connect((SERVER_IP, SERVER_PORT))
+                sleep(1)
+                msg = s.recv(BUFFER_SIZE)
+                response = msg.decode()
+                # print('Rxd: ' + response)
+                if "pipeline>" not in response:
+                    s.close()
+                    self.verify(0, "CLI Response Error")
+                else:
+                    return s
+            except socket.error as err:
+                print("Socket connection failed with error %s" % (err))
+                self.verify(0, "Failed to connect to server")
+        except socket.error as err:
+            print("Socket creation failed with error %s" % (err))
+            self.verify(0, "Failed to create socket")
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def socket_send_cmd(self, socket, cmd, expected_rsp):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        socket.send(cmd.encode('utf-8'))
+        sleep(0.1)
+        msg = socket.recv(BUFFER_SIZE)
+        response = msg.decode()
+        print('Rxd: ' + response)
+        if expected_rsp not in response:
+            socket.close()
+            self.dut.send_expect("^C", "# ", 20)
+            self.verify(0, "CLI Response Error")
 
-    def test_extract_emit_001(self):
-        """
-        extract_emit_001: revert the received packet on the same port without any change
-        """
-        cli_file = '/tmp/pipeline/extract_emit_001/extract_emit_001.cli'
+    def run_dpdk_app(self, cli_file):
 
         cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
         self.dut.send_expect(cmd, "# ", 20)
@@ -355,5249 +403,4107 @@ class TestPipeline(TestCase):
         self.dut.send_expect(cmd, "# ", 20)
         cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
         self.dut.send_expect(cmd, "# ", 20)
-
         cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/extract_emit_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/extract_emit_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        self.dut.send_expect(cmd, "PIPELINE0 enable", 75)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+    def send_pkts(self, from_port, to_port, in_pcap_file):
+        """
+        Send pkts read from the input pcap file.
+        """
+        tx_port = self.tester.get_local_port(self.dut_ports[from_port])
+        rx_port = self.tester.get_local_port(self.dut_ports[to_port])
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        tx_interface = self.tester.get_interface(tx_port)
+        rx_interface = self.tester.get_interface(rx_port)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        self.tester.send_expect('rm -f /tmp/*.txt /tmp/*.pcap /tmp/*.out', '# ')
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        # Prepare the pkts to be sent
+        self.tester.scapy_foreground()
+        self.tester.send_expect('text2pcap -q {} /tmp/packet_tx.pcap'.format('/tmp/' + in_pcap_file), '# ')
+        self.tester.scapy_append('pkt = rdpcap("/tmp/packet_tx.pcap")')
+        self.tester.scapy_append('sendp(pkt, iface="{}", count=1)'.format(tx_interface))
+        self.tester.scapy_execute()
 
-    def test_extract_emit_002(self):
+    def test_rx_tx_001(self):
 
-        cli_file = '/tmp/pipeline/extract_emit_002/extract_emit_002.cli'
+        cli_file = '/tmp/pipeline/rx_tx_001/rx_tx_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/rx_tx_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/rx_tx_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_extract_emit_001(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/extract_emit_002/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/extract_emit_002/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/extract_emit_001/extract_emit_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/extract_emit_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/extract_emit_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_extract_emit_002(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/extract_emit_002/extract_emit_002.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/extract_emit_002/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/extract_emit_002/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
     def test_extract_emit_003(self):
 
         cli_file = '/tmp/pipeline/extract_emit_003/extract_emit_003.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/extract_emit_003/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/extract_emit_003/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_extract_emit_004(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/extract_emit_003/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/extract_emit_003/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/extract_emit_004/extract_emit_004.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/extract_emit_004/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/extract_emit_004/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_extract_emit_005(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/extract_emit_005/extract_emit_005.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/extract_emit_005/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/extract_emit_005/pcap_files/out_1.txt'] * 4
+        filters = ["vlan"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_extract_emit_004(self):
+    def test_extract_emit_006(self):
 
-        cli_file = '/tmp/pipeline/extract_emit_004/extract_emit_004.cli'
+        cli_file = '/tmp/pipeline/extract_emit_006/extract_emit_006.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/extract_emit_006/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/extract_emit_006/pcap_files/out_1.txt'] * 4
+        filters = ["udp port 4789"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_extract_emit_007(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/extract_emit_004/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/extract_emit_004/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/extract_emit_007/extract_emit_007.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/extract_emit_007/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/extract_emit_007/pcap_files/out_1.txt'] * 4
+        filters = ["udp port 4789"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_extract_emit_008(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/extract_emit_008/extract_emit_008.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/extract_emit_008/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/extract_emit_008/pcap_files/out_1.txt'] * 4
+        filters = ["udp port 4789"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_extract_emit_005(self):
+    def test_extract_emit_009(self):
 
-        cli_file = '/tmp/pipeline/extract_emit_005/extract_emit_005.cli'
+        cli_file = '/tmp/pipeline/extract_emit_009/extract_emit_009.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/extract_emit_009/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/extract_emit_009/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_and_001(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/extract_emit_005/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/extract_emit_005/pcap_files/out_1.txt'
-        filters = "vlan"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/and_001/and_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/and_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/and_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_and_002(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/and_002/and_002.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = 'pipeline/and_002/pcap_files/in_1.txt'
+        out_pcap = 'pipeline/and_002/pcap_files/out_1.txt'
+        self.send_and_sniff_pkts(0, 0, in_pcap, out_pcap, "tcp")
+        self.send_and_sniff_pkts(1, 0, in_pcap, out_pcap, "tcp")
+        self.send_and_sniff_pkts(2, 0, in_pcap, out_pcap, "tcp")
+        self.send_and_sniff_pkts(3, 0, in_pcap, out_pcap, "tcp")
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_extract_emit_006(self):
+    def test_and_003(self):
 
-        cli_file = '/tmp/pipeline/extract_emit_006/extract_emit_006.cli'
+        cli_file = '/tmp/pipeline/and_003/and_003.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/and_003/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/and_003/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_and_004(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/extract_emit_006/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/extract_emit_006/pcap_files/out_1.txt'
-        filters = "udp port 4789"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/and_004/and_004.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/and_004/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/and_004/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_and_005(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/and_005/and_005.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/and_005/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/and_005/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_extract_emit_007(self):
+    def test_and_006(self):
 
-        cli_file = '/tmp/pipeline/extract_emit_007/extract_emit_007.cli'
+        cli_file = '/tmp/pipeline/and_006/and_006.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/and_006/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/and_006/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_and_007(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/extract_emit_007/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/extract_emit_007/pcap_files/out_1.txt'
-        filters = "udp port 4789"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/and_007/and_007.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/and_007/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/and_007/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_and_008(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/and_008/and_008.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/and_008/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/and_008/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_extract_emit_008(self):
+    def test_or_001(self):
 
-        cli_file = '/tmp/pipeline/extract_emit_008/extract_emit_008.cli'
+        cli_file = '/tmp/pipeline/or_001/or_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/or_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/or_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_or_002(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/extract_emit_008/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/extract_emit_008/pcap_files/out_1.txt'
-        filters = "udp port 4789"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/or_002/or_002.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/or_002/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/or_002/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_or_003(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/or_003/or_003.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/or_003/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/or_003/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_extract_emit_009(self):
+    def test_or_004(self):
 
-        cli_file = '/tmp/pipeline/extract_emit_009/extract_emit_009.cli'
+        cli_file = '/tmp/pipeline/or_004/or_004.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/or_004/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/or_004/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_or_005(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/extract_emit_009/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/extract_emit_009/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/or_005/or_005.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/or_005/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/or_005/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_or_006(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/or_006/or_006.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/or_006/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/or_006/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_and_001(self):
+    def test_or_007(self):
 
-        cli_file = '/tmp/pipeline/and_001/and_001.cli'
+        cli_file = '/tmp/pipeline/or_007/or_007.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/or_007/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/or_007/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_or_008(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/and_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/and_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/or_008/or_008.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = 'pipeline/or_008/pcap_files/in_1.txt'
+        out_pcap = 'pipeline/or_008/pcap_files/out_1.txt'
+        self.send_and_sniff_pkts(0, 1, in_pcap, out_pcap, "tcp")
+        self.send_and_sniff_pkts(1, 1, in_pcap, out_pcap, "tcp")
+        self.send_and_sniff_pkts(2, 3, in_pcap, out_pcap, "tcp")
+        self.send_and_sniff_pkts(3, 3, in_pcap, out_pcap, "tcp")
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_xor_001(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/xor_001/xor_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/xor_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/xor_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [1, 0, 3, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_and_002(self):
+    def test_xor_002(self):
 
-        cli_file = '/tmp/pipeline/and_002/and_002.cli'
+        cli_file = '/tmp/pipeline/xor_002/xor_002.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/xor_002/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/xor_002/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_xor_003(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/and_002/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/and_002/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/xor_003/xor_003.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 0, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/xor_003/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/xor_003/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 0, in_pcap_file, out_pcap_file, filters)
+    def test_xor_004(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/xor_004/xor_004.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/xor_004/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/xor_004/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_and_003(self):
+    def test_xor_005(self):
 
-        cli_file = '/tmp/pipeline/and_003/and_003.cli'
+        cli_file = '/tmp/pipeline/xor_005/xor_005.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/xor_005/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/xor_005/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_xor_006(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/and_003/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/and_003/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/xor_006/xor_006.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/xor_006/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/xor_006/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [1, 0, 3, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_xor_007(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/xor_007/xor_007.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/xor_007/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/xor_007/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_and_004(self):
+    def test_xor_008(self):
 
-        cli_file = '/tmp/pipeline/and_004/and_004.cli'
+        cli_file = '/tmp/pipeline/xor_008/xor_008.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/xor_008/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/xor_008/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_add_001(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/and_004/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/and_004/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/add_001/add_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/add_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/add_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_add_002(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/add_002/add_002.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/add_002/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/add_002/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_and_005(self):
+    def test_add_003(self):
 
-        cli_file = '/tmp/pipeline/and_005/and_005.cli'
+        cli_file = '/tmp/pipeline/add_003/add_003.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/add_003/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/add_003/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2]
+        rx_port = [1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_add_004(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/and_005/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/and_005/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/add_004/add_004.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/add_004/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/add_004/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_add_005(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/add_005/add_005.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/add_005/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/add_005/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_and_006(self):
+    def test_add_006(self):
 
-        cli_file = '/tmp/pipeline/and_006/and_006.cli'
+        cli_file = '/tmp/pipeline/add_006/add_006.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/add_006/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/add_006/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_add_007(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/and_006/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/and_006/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/add_007/add_007.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/add_007/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/add_007/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_add_008(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/add_008/add_008.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/add_008/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/add_008/pcap_files/out_1.txt'] * 4
+        filters = ["udp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_and_007(self):
+    def test_shl_001(self):
 
-        cli_file = '/tmp/pipeline/and_007/and_007.cli'
+        cli_file = '/tmp/pipeline/shl_001/shl_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/shl_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shl_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_shl_002(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/and_007/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/and_007/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/shl_002/shl_002.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/shl_002/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shl_002/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_shl_003(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/shl_003/shl_003.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/shl_003/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shl_003/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_and_008(self):
+    def test_shl_004(self):
 
-        cli_file = '/tmp/pipeline/and_008/and_008.cli'
+        cli_file = '/tmp/pipeline/shl_004/shl_004.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/shl_004/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shl_004/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_shl_005(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/and_008/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/and_008/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/shl_005/shl_005.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/shl_005/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shl_005/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_shl_006(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/shl_006/shl_006.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/shl_006/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shl_006/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_or_001(self):
+    def test_shl_007(self):
 
-        cli_file = '/tmp/pipeline/or_001/or_001.cli'
+        cli_file = '/tmp/pipeline/shl_007/shl_007.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/shl_007/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shl_007/pcap_files/out_1.txt'] * 4
+        filters = ["udp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_shl_008(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/or_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/or_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/shl_008/shl_008.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/shl_008/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shl_008/pcap_files/out_1.txt'] * 4
+        filters = ["udp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_shr_001(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/shr_001/shr_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/shr_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shr_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_or_002(self):
+    def test_shr_002(self):
 
-        cli_file = '/tmp/pipeline/or_002/or_002.cli'
+        cli_file = '/tmp/pipeline/shr_002/shr_002.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/shr_002/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shr_002/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_shr_003(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/or_002/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/or_002/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/shr_003/shr_003.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/shr_003/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shr_003/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_shr_004(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/shr_004/shr_004.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/shr_004/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shr_004/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_or_003(self):
+    def test_shr_005(self):
 
-        cli_file = '/tmp/pipeline/or_003/or_003.cli'
+        cli_file = '/tmp/pipeline/shr_005/shr_005.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/shr_005/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shr_005/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_shr_006(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/or_003/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/or_003/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/shr_006/shr_006.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/shr_006/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shr_006/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_shr_007(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/shr_007/shr_007.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/shr_007/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shr_007/pcap_files/out_1.txt'] * 4
+        filters = ["udp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_or_004(self):
+    def test_shr_008(self):
 
-        cli_file = '/tmp/pipeline/or_004/or_004.cli'
+        cli_file = '/tmp/pipeline/shr_008/shr_008.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/shr_008/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/shr_008/pcap_files/out_1.txt'] * 4
+        filters = ["udp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_sub_001(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/or_004/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/or_004/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/sub_001/sub_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/sub_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/sub_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_sub_002(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/sub_002/sub_002.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/sub_002/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/sub_002/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_or_005(self):
+    def test_sub_003(self):
 
-        cli_file = '/tmp/pipeline/or_005/or_005.cli'
+        cli_file = '/tmp/pipeline/sub_003/sub_003.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/sub_003/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/sub_003/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_sub_004(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/or_005/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/or_005/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/sub_004/sub_004.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/sub_004/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/sub_004/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_sub_005(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/sub_005/sub_005.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/sub_005/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/sub_005/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_or_006(self):
+    def test_sub_006(self):
 
-        cli_file = '/tmp/pipeline/or_006/or_006.cli'
+        cli_file = '/tmp/pipeline/sub_006/sub_006.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/sub_006/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/sub_006/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_sub_007(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/or_006/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/or_006/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/sub_007/sub_007.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/sub_007/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/sub_007/pcap_files/out_1.txt'] * 4
+        filters = ["udp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_sub_008(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/sub_008/sub_008.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/sub_008/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/sub_008/pcap_files/out_1.txt'] * 4
+        filters = ["udp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_or_007(self):
+    def test_mov_001(self):
 
-        cli_file = '/tmp/pipeline/or_007/or_007.cli'
+        cli_file = '/tmp/pipeline/mov_001/mov_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/mov_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/mov_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_mov_002(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/or_007/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/or_007/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/mov_002/mov_002.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/mov_002/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/mov_002/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_mov_003(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/mov_003/mov_003.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/mov_003/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/mov_003/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_or_008(self):
+    def test_mov_004(self):
 
-        cli_file = '/tmp/pipeline/or_008/or_008.cli'
+        cli_file = '/tmp/pipeline/mov_004/mov_004.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/mov_004/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/mov_004/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_mov_005(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/or_008/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/or_008/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/mov_005/mov_005.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = 'pipeline/mov_005/pcap_files/in_1.txt'
+        out_pcap = 'pipeline/mov_005/pcap_files/out_1.txt'
+        self.send_and_sniff_pkts(0, 0, in_pcap, out_pcap, "tcp")
+        self.send_and_sniff_pkts(1, 0, in_pcap, out_pcap, "tcp")
+        self.send_and_sniff_pkts(2, 0, in_pcap, out_pcap, "tcp")
+        self.send_and_sniff_pkts(3, 0, in_pcap, out_pcap, "tcp")
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 3, in_pcap_file, out_pcap_file, filters)
+    def test_mov_007(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/mov_007/mov_007.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/mov_007/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/mov_007/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_xor_001(self):
+    def test_mov_008(self):
 
-        cli_file = '/tmp/pipeline/xor_001/xor_001.cli'
+        cli_file = '/tmp/pipeline/mov_008/mov_008.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/mov_008/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/mov_008/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_table_001(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/xor_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/xor_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/table_001/table_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 0, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/table_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/table_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 3, in_pcap_file, out_pcap_file, filters)
+    def test_vxlan_001(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 2, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/vxlan_001/vxlan_001.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap_0 = 'pipeline/vxlan_001/pcap_files/in_1.txt'
+        in_pcap_1 = 'pipeline/vxlan_001/pcap_files/in_2.txt'
+        in_pcap_2 = 'pipeline/vxlan_001/pcap_files/in_3.txt'
+        in_pcap_3 = 'pipeline/vxlan_001/pcap_files/in_4.txt'
+        out_pcap_0 = 'pipeline/vxlan_001/pcap_files/out_1.txt'
+        out_pcap_1 = 'pipeline/vxlan_001/pcap_files/out_2.txt'
+        out_pcap_2 = 'pipeline/vxlan_001/pcap_files/out_3.txt'
+        out_pcap_3 = 'pipeline/vxlan_001/pcap_files/out_4.txt'
+
+        in_pcap = [in_pcap_0, in_pcap_1, in_pcap_2, in_pcap_3]
+        out_pcap = [out_pcap_0, out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["udp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+    def test_dma_001(self):
 
-    def test_xor_002(self):
+        cli_file = '/tmp/pipeline/dma_001/dma_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        cli_file = '/tmp/pipeline/xor_002/xor_002.cli'
+        in_pcap = ['pipeline/dma_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/dma_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+    def test_dma_002(self):
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        cli_file = '/tmp/pipeline/dma_002/dma_002.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/xor_002/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/xor_002/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/dma_002/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/dma_002/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+    def test_dma_003(self):
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/dma_003/dma_003.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/dma_003/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/dma_003/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+    def test_dma_004(self):
 
-    def test_xor_003(self):
+        cli_file = '/tmp/pipeline/dma_004/dma_004.cli'
+        self.run_dpdk_app(cli_file)
 
-        cli_file = '/tmp/pipeline/xor_003/xor_003.cli'
+        in_pcap = ['pipeline/dma_004/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/dma_004/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+    def test_dma_005(self):
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        cli_file = '/tmp/pipeline/dma_005/dma_005.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/xor_003/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/xor_003/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/dma_005/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/dma_005/pcap_files/out_1.txt'] * 4
+        filters = ["vlan"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+    def test_dma_006(self):
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/dma_006/dma_006.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/dma_006/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/dma_006/pcap_files/out_1.txt'] * 4
+        filters = ["udp port 4532"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+    def test_dma_007(self):
 
-    def test_xor_004(self):
+        cli_file = '/tmp/pipeline/dma_007/dma_007.cli'
+        self.run_dpdk_app(cli_file)
 
-        cli_file = '/tmp/pipeline/xor_004/xor_004.cli'
+        in_pcap = ['pipeline/dma_007/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/dma_007/pcap_files/out_1.txt'] * 4
+        filters = ["udp port 4532"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+    def test_dma_008(self):
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        cli_file = '/tmp/pipeline/dma_008/dma_008.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/xor_004/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/xor_004/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/dma_008/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/dma_008/pcap_files/out_1.txt'] * 4
+        filters = ["udp port 4532"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+    def test_jump_001(self):
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_001/jump_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+    def test_jump_002(self):
 
-    def test_xor_005(self):
+        cli_file = '/tmp/pipeline/jump_002/jump_002.cli'
+        self.run_dpdk_app(cli_file)
 
-        cli_file = '/tmp/pipeline/xor_005/xor_005.cli'
+        in_pcap = ['pipeline/jump_002/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_002/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+    def test_jump_003(self):
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        cli_file = '/tmp/pipeline/jump_003/jump_003.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/xor_005/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/xor_005/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_003/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_003/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+    def test_jump_004(self):
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_004/jump_004.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_004/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_004/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+    def test_jump_005(self):
 
-    def test_xor_006(self):
-        """
-        find entry in the table based on the des mac address,
-        then update the src mac address to the mac address in the table.
-        """
+        cli_file = '/tmp/pipeline/jump_005/jump_005.cli'
+        self.run_dpdk_app(cli_file)
 
-        cli_file = '/tmp/pipeline/xor_006/xor_006.cli'
+        in_pcap = ['pipeline/jump_005/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_005/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+    def test_jump_006(self):
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        cli_file = '/tmp/pipeline/jump_006/jump_006.cli'
+        self.run_dpdk_app(cli_file)
 
-        in_pcap_file = 'pipeline/xor_006/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/xor_006/pcap_files/out_1.txt'
-        filters = "tcp"
+        in_pcap = ['pipeline/jump_006/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_006/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        sniff_pkts = self.send_and_sniff_pkts(0, 1, in_pcap_file, out_pcap_file, filters)
+    def test_jump_007(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_007/jump_007.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 3, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_007/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_007/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 2, in_pcap_file, out_pcap_file, filters)
+    def test_jump_008(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_008/jump_008.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_xor_007(self):
-        """
-        find entry in the table based on the des mac address,
-        then update the src mac address to the mac address in the table.
-        """
+        in_pcap = ['pipeline/jump_008/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_008/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/xor_007/xor_007.cli'
+    def test_jump_009(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_009/jump_009.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/jump_009/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_009/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        in_pcap_file = 'pipeline/xor_007/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/xor_007/pcap_files/out_1.txt'
-        filters = "tcp"
+    def test_jump_010(self):
 
-        # rule 0 test
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_010/jump_010.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_010/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_010/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_jump_011(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_011/jump_011.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/jump_011/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_011/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_xor_008(self):
+    def test_jump_012(self):
 
-        cli_file = '/tmp/pipeline/xor_008/xor_008.cli'
+        cli_file = '/tmp/pipeline/jump_012/jump_012.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/jump_012/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_012/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_jump_013(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/xor_008/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/xor_008/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_013/jump_013.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_013/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_013/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_jump_014(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_014/jump_014.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/jump_014/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_014/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_add_001(self):
+    def test_jump_015(self):
 
-        cli_file = '/tmp/pipeline/add_001/add_001.cli'
+        cli_file = '/tmp/pipeline/jump_015/jump_015.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/jump_015/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_015/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_jump_016(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/add_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/add_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_016/jump_016.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_016/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_016/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_jump_017(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_017/jump_017.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/jump_017/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_017/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_add_002(self):
+    def test_jump_018(self):
 
-        cli_file = '/tmp/pipeline/add_002/add_002.cli'
+        cli_file = '/tmp/pipeline/jump_018/jump_018.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/jump_018/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_018/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_jump_019(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/add_002/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/add_002/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_019/jump_019.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_019/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_019/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_jump_020(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_020/jump_020.cli'
+        self.run_dpdk_app(cli_file)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/jump_020/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_020/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-    def test_add_003(self):
+    def test_jump_021(self):
 
-        cli_file = '/tmp/pipeline/add_003/add_003.cli'
+        cli_file = '/tmp/pipeline/jump_021/jump_021.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/jump_021/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_021/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_jump_022(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/add_003/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/add_003/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_022/jump_022.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_022/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_022/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 3, in_pcap_file, out_pcap_file, filters)
+    def test_jump_023(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_023/jump_023.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_add_004(self):
+        in_pcap = ['pipeline/jump_023/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_023/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/add_004/add_004.cli'
+    def test_jump_024(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_024/jump_024.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/jump_024/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_024/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/add_004/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/add_004/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_jump_025(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_025/jump_025.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_025/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_025/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_jump_026(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_026/jump_026.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_add_005(self):
+        in_pcap = ['pipeline/jump_026/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_026/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/add_005/add_005.cli'
+    def test_jump_027(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_027/jump_027.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/jump_027/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_027/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/add_005/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/add_005/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_jump_028(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_028/jump_028.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_028/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_028/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_jump_029(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_029/jump_029.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_add_006(self):
+        in_pcap = ['pipeline/jump_029/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_029/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/add_006/add_006.cli'
+    def test_jump_030(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_030/jump_030.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/jump_030/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_030/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/add_006/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/add_006/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_jump_031(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_031/jump_031.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_031/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_031/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_jump_032(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_032/jump_032.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_add_007(self):
+        in_pcap = ['pipeline/jump_032/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_032/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/add_007/add_007.cli'
+    def test_jump_033(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_033/jump_033.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/jump_033/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_033/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/add_007/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/add_007/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_jump_034(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_034/jump_034.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_034/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_034/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_jump_035(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_035/jump_035.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_add_008(self):
+        in_pcap = ['pipeline/jump_035/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_035/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/add_008/add_008.cli'
+    def test_jump_036(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_036/jump_036.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/jump_036/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_036/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/add_008/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/add_008/pcap_files/out_1.txt'
-        filters = "udp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_jump_037(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_037/jump_037.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_037/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_037/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_jump_038(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_038/jump_038.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_shl_001(self):
+        in_pcap = ['pipeline/jump_038/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_038/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/shl_001/shl_001.cli'
+    def test_jump_039(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_039/jump_039.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/jump_039/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_039/pcap_files/out_1.txt'] * 4
+        filters = [""] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shl_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shl_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_jump_040(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_040/jump_040.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_040/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_040/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_jump_041(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_041/jump_041.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_shl_002(self):
+        in_pcap = ['pipeline/jump_041/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_041/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/shl_002/shl_002.cli'
+    def test_jump_042(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_042/jump_042.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/jump_042/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_042/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shl_002/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shl_002/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_jump_043(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_043/jump_043.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_043/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_043/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_jump_044(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_044/jump_044.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_shl_003(self):
+        in_pcap = ['pipeline/jump_044/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_044/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/shl_003/shl_003.cli'
+    def test_jump_045(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_045/jump_045.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/jump_045/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_045/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shl_003/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shl_003/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_jump_046(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_046/jump_046.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_046/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_046/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_jump_047(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_047/jump_047.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_shl_004(self):
+        in_pcap = ['pipeline/jump_047/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_047/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/shl_004/shl_004.cli'
+    def test_jump_048(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_048/jump_048.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/jump_048/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_048/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shl_004/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shl_004/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_jump_049(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_049/jump_049.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_049/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_049/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_jump_050(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_050/jump_050.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_shl_005(self):
+        in_pcap = ['pipeline/jump_050/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_050/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/shl_005/shl_005.cli'
+    def test_jump_051(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_051/jump_051.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/jump_051/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_051/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shl_005/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shl_005/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_jump_052(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_052/jump_052.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_052/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_052/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_jump_053(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_053/jump_053.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_shl_006(self):
+        in_pcap = ['pipeline/jump_053/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_053/pcap_files/out_1.txt'] * 4
+        filters = [""] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/shl_006/shl_006.cli'
+    def test_jump_054(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/jump_054/jump_054.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/jump_054/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_054/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shl_006/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shl_006/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_jump_055(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/jump_055/jump_055.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/jump_055/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/jump_055/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_ckadd_001(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/ckadd_001/ckadd_001.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_shl_007(self):
+        in_pcap = ['pipeline/ckadd_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/ckadd_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/shl_007/shl_007.cli'
+    def test_ckadd_009(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/ckadd_009/ckadd_009.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/ckadd_009/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/ckadd_009/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shl_007/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shl_007/pcap_files/out_1.txt'
-        filters = "udp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_ckadd_010(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/ckadd_010/ckadd_010.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/ckadd_010/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/ckadd_010/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_cksub_001(self):
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/cksub_001/cksub_001.cli'
+        self.run_dpdk_app(cli_file)
 
-    def test_shl_008(self):
+        in_pcap = ['pipeline/cksub_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/cksub_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        cli_file = '/tmp/pipeline/shl_008/shl_008.cli'
+    def test_invalidate_001(self):
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        cli_file = '/tmp/pipeline/invalidate_001/invalidate_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/invalidate_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/invalidate_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shl_008/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shl_008/pcap_files/out_1.txt'
-        filters = "udp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+    def test_validate_001(self):
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/validate_001/validate_001.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/validate_001/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/validate_001/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_table_002(self):
 
+        cli_file = '/tmp/pipeline/table_002/table_002.cli'
+        self.run_dpdk_app(cli_file)
         sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        s = self.connect_cli_server()
 
-    def test_shr_001(self):
+        # empty table scenario
+        in_pcap = ['pipeline/table_002/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/table_002/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        cli_file = '/tmp/pipeline/shr_001/shr_001.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/shr_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shr_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        # single rule scenario
+        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_2.txt'
+        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-    def test_shr_002(self):
+        in_pcap = ['pipeline/table_002/pcap_files/in_2.txt'] * 4
+        out_pcap = ['pipeline/table_002/pcap_files/out_2.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        cli_file = '/tmp/pipeline/shr_002/shr_002.cli'
+        # two rules scenario
+        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_3.txt'
+        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/table_002/pcap_files/in_3.txt'] * 4
+        out_pcap = ['pipeline/table_002/pcap_files/out_3.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        # delete one rule scenario
+        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_4_1.txt'
+        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update none {} none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shr_002/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shr_002/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/table_002/pcap_files/in_4_1.txt'] * 4
+        out_pcap = ['pipeline/table_002/pcap_files/out_4_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        # delete all rules scenario
+        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_4_2.txt'
+        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update none {} none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/table_002/pcap_files/in_4_2.txt'] * 4
+        out_pcap = ['pipeline/table_002/pcap_files/out_4_2.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        # action update scenario (restore one of the previously deleted rules and check the update)
+        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_5_1.txt'
+        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = 'pipeline/table_002/pcap_files/in_5_1.txt'
+        out_pcap = 'pipeline/table_002/pcap_files/out_5_1.txt'
+        self.send_and_sniff_pkts(0, 0, in_pcap, out_pcap, "tcp")
 
-    def test_shr_003(self):
+        # action update scenario (change the action of restored rule and check the update)
+        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_5_2.txt'
+        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        cli_file = '/tmp/pipeline/shr_003/shr_003.cli'
+        in_pcap = ['pipeline/table_002/pcap_files/in_5_1.txt'] * 4
+        out_pcap = ['pipeline/table_002/pcap_files/out_5_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        # deafult action scenario [empty table]
+        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_6_1.txt'  # delete the previously added rule
+        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update none {} none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        in_pcap = ['pipeline/table_002/pcap_files/in_6_1.txt'] * 4
+        out_pcap = ['pipeline/table_002/pcap_files/out_6_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shr_003/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shr_003/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        # deafult action scenario [table with one rule]
+        '''
+        Add key A => Lookup HIT for the right packet with the specific key associated action executed
+                     Lookup MISS for any other packets with default action executed
+        '''
+        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_6_2.txt'  # add a new rule
+        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/table_002/pcap_files/in_6_2.txt'] * 4
+        out_pcap = ['pipeline/table_002/pcap_files/out_6_2.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+    def test_table_003(self):
 
+        cli_file = '/tmp/pipeline/table_003/table_003.cli'
+        self.run_dpdk_app(cli_file)
         sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_shr_004(self):
-
-        cli_file = '/tmp/pipeline/shr_004/shr_004.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/shr_004/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shr_004/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        s = self.connect_cli_server()
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        # Empty table scenario
+        in_pcap = ['pipeline/table_003/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/table_003/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        # Single rule scenario
+        CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_2.txt'
+        CLI_CMD = 'pipeline PIPELINE0 table table_003_table update {} none none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-    def test_shr_005(self):
+        in_pcap = ['pipeline/table_003/pcap_files/in_2.txt'] * 4
+        out_pcap = ['pipeline/table_003/pcap_files/out_2.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        cli_file = '/tmp/pipeline/shr_005/shr_005.cli'
+        # test two rules scenario
+        CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_3.txt'
+        CLI_CMD = 'pipeline PIPELINE0 table table_003_table update {} none none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = ['pipeline/table_003/pcap_files/in_3.txt'] * 4
+        out_pcap = ['pipeline/table_003/pcap_files/out_3.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        # delete one rule scenario
+        CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_4_1.txt'
+        CLI_CMD = 'pipeline PIPELINE0 table table_003_table update none {} none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shr_005/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shr_005/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/table_003/pcap_files/in_4_1.txt'] * 4
+        out_pcap = ['pipeline/table_003/pcap_files/out_4_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        # delete all rules scenario
+        CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_4_2.txt'
+        CLI_CMD = 'pipeline PIPELINE0 table table_003_table update none {} none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/table_003/pcap_files/in_4_2.txt'] * 4
+        out_pcap = ['pipeline/table_003/pcap_files/out_4_2.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        # action update scenario (restore one of the previously deleted rules and check the update)
+        CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_5_1.txt'
+        CLI_CMD = 'pipeline PIPELINE0 table table_003_table update {} none none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        in_pcap = 'pipeline/table_003/pcap_files/in_5_1.txt'
+        out_pcap = 'pipeline/table_003/pcap_files/out_5_1.txt'
+        self.send_and_sniff_pkts(0, 0, in_pcap, out_pcap, "tcp")
 
-    def test_shr_006(self):
+        # action update scenario (change the action of restored rule and check the update)
+        CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_5_2.txt'
+        CLI_CMD = 'pipeline PIPELINE0 table table_003_table update {} none none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        in_pcap = ['pipeline/table_003/pcap_files/in_5_1.txt'] * 4
+        out_pcap = ['pipeline/table_003/pcap_files/out_5_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+
+        # Default action scenario [Empty table]
+        CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_6_1_1.txt'  # delete the previously added rule
+        CMD_FILE_2 = '/tmp/pipeline/table_003/cmd_files/cmd_6_1_2.txt'  # change the default action of table
+        CLI_CMD = 'pipeline PIPELINE0 table table_003_table update none {} {} \n'.format(CMD_FILE, CMD_FILE_2)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        in_pcap = ['pipeline/table_003/pcap_files/in_6_1.txt'] * 4
+        out_pcap = ['pipeline/table_003/pcap_files/out_6_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+
+        # Default action scenario [Table with one rule]
+        '''
+        Add key A => Lookup HIT for the right packet with the specific key associated action executed
+                     Lookup MISS for any other packets with default action executed
+        '''
+        CMD_FILE = '/tmp/pipeline/table_003/cmd_files/cmd_6_2.txt'  # add a new rule
+        CLI_CMD = 'pipeline PIPELINE0 table table_003_table update {} none none\n'.format(CMD_FILE)
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        cli_file = '/tmp/pipeline/shr_006/shr_006.cli'
+        in_pcap = ['pipeline/table_003/pcap_files/in_6_2.txt'] * 4
+        out_pcap = ['pipeline/table_003/pcap_files/out_6_2.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+    def test_table_004(self):
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shr_006/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shr_006/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/table_004/table_004.cli'
+        self.run_dpdk_app(cli_file)
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        in_pcap = ['pipeline/table_004/pcap_files/in_1.txt'] * 4
+        out_pcap = ['pipeline/table_004/pcap_files/out_1.txt'] * 4
+        filters = ["tcp"] * 4
+        tx_port = [0, 1, 2, 3]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+    def test_reg_001(self):
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        cli_file = '/tmp/pipeline/reg_001/reg_001.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        # Read default initial value
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x0\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-    def test_shr_007(self):
+        # Update the register array location
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x0 0xab\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
 
-        cli_file = '/tmp/pipeline/shr_007/shr_007.cli'
+        # Verify updated value
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x0\n'
+        self.socket_send_cmd(s, CLI_CMD, "0xab\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_002(self):
+
+        cli_file = '/tmp/pipeline/reg_002/reg_002.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Update the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0x123456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0x12345678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0x1234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0x12\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        s.close()
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        # Read updated values through packet
+        in_pcap_file = 'pipeline/reg_002/pcap_files/in_1.txt'
+        out_pcap_file = 'pipeline/reg_002/pcap_files/out_1.txt'
+        self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, "tcp")
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_003(self):
+
+        cli_file = '/tmp/pipeline/reg_003/reg_003.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Update the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0x123456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0x12345678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0x1234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0x12\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        s.close()
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shr_007/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shr_007/pcap_files/out_1.txt'
-        filters = "udp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        # Read updated values through packet
+        in_pcap_file = 'pipeline/reg_003/pcap_files/in_1.txt'
+        out_pcap_file = 'pipeline/reg_003/pcap_files/out_1.txt'
+        self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, "tcp")
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_004(self):
+
+        cli_file = '/tmp/pipeline/reg_004/reg_004.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Update the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0x123456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0x12345678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0x1234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0x12\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        s.close()
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        # Read updated values through packet
+        in_pcap_file = 'pipeline/reg_004/pcap_files/in_1.txt'
+        out_pcap_file = 'pipeline/reg_004/pcap_files/out_1.txt'
+        self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, "tcp")
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_005(self):
+
+        cli_file = '/tmp/pipeline/reg_005/reg_005.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Update the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0x123456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0x12345678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0x1234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0x12\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        s.close()
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        # Read updated values through packet
+        in_pcap_file = 'pipeline/reg_005/pcap_files/in_1.txt'
+        out_pcap_file = 'pipeline/reg_005/pcap_files/out_1.txt'
+        self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, "tcp")
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_006(self):
+
+        cli_file = '/tmp/pipeline/reg_006/reg_006.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Update the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0x123456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0x12345678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0x1234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0x12\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send a packet to trigger the execution of apply block
+        in_pcap_file = 'pipeline/reg_006/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify written vs read values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa3a4\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb3b4\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_007(self):
+
+        cli_file = '/tmp/pipeline/reg_007/reg_007.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Update the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0x123456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0x12345678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0x1234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0x12\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send a packet to trigger the execution of apply block
+        in_pcap_file = 'pipeline/reg_007/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify written vs read values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa3a4\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb3b4\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_008(self):
+
+        cli_file = '/tmp/pipeline/reg_008/reg_008.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Update the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0x123456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0x12345678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0x1234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0x12\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send a packet to trigger the execution of apply block
+        in_pcap_file = 'pipeline/reg_008/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify written vs read values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa3a4\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb3b4\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-    def test_shr_008(self):
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_009(self):
+
+        cli_file = '/tmp/pipeline/reg_009/reg_009.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Update the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0x123456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0x12345678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0x1234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0x12\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send a packet to trigger the execution of apply block
+        in_pcap_file = 'pipeline/reg_009/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify written vs read values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa3a4\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb3b4\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-        cli_file = '/tmp/pipeline/shr_008/shr_008.cli'
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_010(self):
+
+        cli_file = '/tmp/pipeline/reg_010/reg_010.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_010/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x6\npipeline> ")
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_011(self):
+
+        cli_file = '/tmp/pipeline/reg_011/reg_011.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_011/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x6\npipeline> ")
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_012(self):
+
+        cli_file = '/tmp/pipeline/reg_012/reg_012.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_012/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/shr_008/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/shr_008/pcap_files/out_1.txt'
-        filters = "udp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_013(self):
+
+        cli_file = '/tmp/pipeline/reg_013/reg_013.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x06\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_013/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x6\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x06\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x9876543210987654\npipeline> ")
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_014(self):
+
+        cli_file = '/tmp/pipeline/reg_014/reg_014.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_014/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x6\npipeline> ")
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_015(self):
+
+        cli_file = '/tmp/pipeline/reg_015/reg_015.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_015/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x6\npipeline> ")
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_016(self):
+
+        cli_file = '/tmp/pipeline/reg_016/reg_016.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_016/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_017(self):
+
+        cli_file = '/tmp/pipeline/reg_017/reg_017.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_017/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-    def test_sub_001(self):
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_018(self):
+
+        cli_file = '/tmp/pipeline/reg_018/reg_018.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_018/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-        cli_file = '/tmp/pipeline/sub_001/sub_001.cli'
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_019(self):
+
+        cli_file = '/tmp/pipeline/reg_019/reg_019.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_019/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_020(self):
+
+        cli_file = '/tmp/pipeline/reg_020/reg_020.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_020/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_021(self):
+
+        cli_file = '/tmp/pipeline/reg_021/reg_021.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_021/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/sub_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/sub_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_022(self):
+
+        cli_file = '/tmp/pipeline/reg_022/reg_022.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_022/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x6\npipeline> ")
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_023(self):
+
+        cli_file = '/tmp/pipeline/reg_023/reg_023.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_023/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_024(self):
+
+        cli_file = '/tmp/pipeline/reg_024/reg_024.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_024/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12\npipeline> ")
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_025(self):
+
+        cli_file = '/tmp/pipeline/reg_025/reg_025.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Verify the default initial values of zero
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x0\npipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_025/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234567890123456\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x123456789012\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345678\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1234\npipeline> ")
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_026(self):
+
+        cli_file = '/tmp/pipeline/reg_026/reg_026.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_026/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
 
-    def test_sub_002(self):
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_027(self):
+
+        cli_file = '/tmp/pipeline/reg_027/reg_027.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_027/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
 
-        cli_file = '/tmp/pipeline/sub_002/sub_002.cli'
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_028(self):
+
+        cli_file = '/tmp/pipeline/reg_028/reg_028.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_028/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_029(self):
+
+        cli_file = '/tmp/pipeline/reg_029/reg_029.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_029/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_030(self):
+
+        cli_file = '/tmp/pipeline/reg_030/reg_030.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_030/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/sub_002/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/sub_002/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_031(self):
+
+        cli_file = '/tmp/pipeline/reg_031/reg_031.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_031/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_032(self):
+
+        cli_file = '/tmp/pipeline/reg_032/reg_032.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_032/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_033(self):
+
+        cli_file = '/tmp/pipeline/reg_033/reg_033.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_033/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_034(self):
+
+        cli_file = '/tmp/pipeline/reg_034/reg_034.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_034/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_035(self):
+
+        cli_file = '/tmp/pipeline/reg_035/reg_035.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_035/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
 
-    def test_sub_003(self):
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_036(self):
+
+        cli_file = '/tmp/pipeline/reg_036/reg_036.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_036/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
 
-        cli_file = '/tmp/pipeline/sub_003/sub_003.cli'
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_037(self):
+
+        cli_file = '/tmp/pipeline/reg_037/reg_037.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_037/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_038(self):
+
+        cli_file = '/tmp/pipeline/reg_038/reg_038.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_038/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
 
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_039(self):
+
+        cli_file = '/tmp/pipeline/reg_039/reg_039.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_039/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
 
-        # rule 0 test
-        in_pcap_file = 'pipeline/sub_003/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/sub_003/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_040(self):
+
+        cli_file = '/tmp/pipeline/reg_040/reg_040.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_040/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
 
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_041(self):
+
+        cli_file = '/tmp/pipeline/reg_041/reg_041.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xf7 0x1f\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_041/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Update the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ace68ac468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x12345777e68a\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x124448ac\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x10f1\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xf7\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x25\npipeline> ")
 
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_042(self):
+
+        cli_file = '/tmp/pipeline/reg_042/reg_042.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_042/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
 
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_043(self):
+
+        cli_file = '/tmp/pipeline/reg_043/reg_043.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_043/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
 
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_044(self):
+
+        cli_file = '/tmp/pipeline/reg_044/reg_044.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x1a1a2a3 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7fc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0x7f 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_044/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x1a1a2a3\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7fc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0x7f\n'
+        self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
 
-    def test_sub_004(self):
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_reg_045(self):
+
+        cli_file = '/tmp/pipeline/reg_045/reg_045.cli'
+        self.run_dpdk_app(cli_file)
+        sleep(CLI_SERVER_CONNECT_DELAY)
+        s = self.connect_cli_server()
+
+        # Initialize the register array locations with required values
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xa1a2 0xff23456789012\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xb1b2 0xff5678\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xc1 0xff234\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regwr REG_ARR_1 0xd1 0xff2\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        # Send packet to DUT to update the register array
+        in_pcap_file = 'pipeline/reg_045/pcap_files/in_1.txt'
+        self.send_pkts(0, 0, in_pcap_file)
+
+        # Verify whether the register array is updated with required values
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xa1a2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468acf12024\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xb1b2\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x1333acf0\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xc1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0x100468\npipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 regrd REG_ARR_1 0xd1\n'
+        self.socket_send_cmd(s, CLI_CMD, "0xff8\npipeline> ")
 
-        cli_file = '/tmp/pipeline/sub_004/sub_004.cli'
+        s.close()
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_001(self):
+
+        cli_file = '/tmp/pipeline/met_001/met_001.cli'
+        self.run_dpdk_app(cli_file)
+
+        # Platinum Profile with High Packet Transmission Rate
+        in_pcap = ['pipeline/met_001/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_001/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_001/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_001/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        # Platinum Profile with Low Packet Transmission Rate
+        out_pcap_1 = 'pipeline/met_001/pcap_files/out_21.txt'
+        out_pcap_2 = 'pipeline/met_001/pcap_files/out_22.txt'
+        out_pcap_3 = 'pipeline/met_001/pcap_files/out_23.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+
+        # Gold Profile with High Packet Transmission Rate
+        s = self.connect_cli_server()
+        CLI_CMD = 'pipeline PIPELINE0 meter profile gold add cir 460 pir 1380 cbs 100 pbs 150\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 meter MET_ARRAY_1 from 0 to 0 set profile gold\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        CLI_CMD = 'pipeline PIPELINE0 meter profile platinum delete\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+
+        out_pcap_1 = 'pipeline/met_001/pcap_files/out_31.txt'
+        out_pcap_2 = 'pipeline/met_001/pcap_files/out_32.txt'
+        out_pcap_3 = 'pipeline/met_001/pcap_files/out_33.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        # Default Profile with High Packet Transmission Rate
+        CLI_CMD = 'pipeline PIPELINE0 meter MET_ARRAY_1 from 0 to 0 reset\n'
+        self.socket_send_cmd(s, CLI_CMD, "pipeline> ")
+        s.close()
 
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/sub_004/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/sub_004/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_sub_005(self):
-
-        cli_file = '/tmp/pipeline/sub_005/sub_005.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/sub_005/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/sub_005/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_sub_006(self):
-
-        cli_file = '/tmp/pipeline/sub_006/sub_006.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/sub_006/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/sub_006/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_sub_007(self):
-
-        cli_file = '/tmp/pipeline/sub_007/sub_007.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/sub_007/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/sub_007/pcap_files/out_1.txt'
-        filters = "udp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_sub_008(self):
-
-        cli_file = '/tmp/pipeline/sub_008/sub_008.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/sub_008/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/sub_008/pcap_files/out_1.txt'
-        filters = "udp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_mov_001(self):
-
-        cli_file = '/tmp/pipeline/mov_001/mov_001.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/mov_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/mov_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_mov_002(self):
-        """
-        mov_002: swap destination and source MAC address of packets received on port
-        """
-        cli_file = '/tmp/pipeline/mov_002/mov_002.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/mov_002/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/mov_002/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_mov_003(self):
-
-        cli_file = '/tmp/pipeline/mov_003/mov_003.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/mov_003/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/mov_003/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_mov_004(self):
-        """
-        find entry in the table based on the des mac address,
-        then update the src mac address to the mac address in the table.
-        """
-
-        cli_file = '/tmp/pipeline/mov_004/mov_004.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        in_pcap_file = 'pipeline/mov_004/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/mov_004/pcap_files/out_1.txt'
-        filters = "tcp"
-
-        # rule 0 test
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_mov_005(self):
-        """
-        find entry in the table based on the des mac address,
-        then update the src mac address to the mac address in the table.
-        """
-
-        cli_file = '/tmp/pipeline/mov_005/mov_005.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        in_pcap_file = 'pipeline/mov_005/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/mov_005/pcap_files/out_1.txt'
-        filters = "tcp"
-
-        # rule 0 test
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 0, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_mov_007(self):
-        """
-        find entry in the table based on the des mac address,
-        then update the src mac address to the mac address in the table.
-        """
-
-        cli_file = '/tmp/pipeline/mov_007/mov_007.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        in_pcap_file = 'pipeline/mov_007/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/mov_007/pcap_files/out_1.txt'
-        filters = "tcp"
-
-        # rule 0 test
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 0, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_mov_008(self):
-        """
-        find entry in the table based on the des mac address,
-        then update the src mac address to the mac address in the table.
-        """
-
-        cli_file = '/tmp/pipeline/mov_008/mov_008.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        in_pcap_file = 'pipeline/mov_008/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/mov_008/pcap_files/out_1.txt'
-        filters = "tcp"
-
-        # rule 0 test
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_table_001(self):
-
-        cli_file = '/tmp/pipeline/table_001/table_001.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/table_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/table_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_vxlan_001(self):
-        """
-        example application: vxlan pipeline
-        """
-        cli_file = '/tmp/pipeline/vxlan_001/vxlan_001.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/vxlan_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/vxlan_001/pcap_files/out_1.txt'
-        filters = "udp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        in_pcap_file = 'pipeline/vxlan_001/pcap_files/in_2.txt'
-        out_pcap_file = 'pipeline/vxlan_001/pcap_files/out_2.txt'
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        in_pcap_file = 'pipeline/vxlan_001/pcap_files/in_3.txt'
-        out_pcap_file = 'pipeline/vxlan_001/pcap_files/out_3.txt'
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        in_pcap_file = 'pipeline/vxlan_001/pcap_files/in_4.txt'
-        out_pcap_file = 'pipeline/vxlan_001/pcap_files/out_4.txt'
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_dma_001(self):
-        """
-        example application: vxlan pipeline
-        """
-        cli_file = '/tmp/pipeline/dma_001/dma_001.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/dma_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/dma_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_dma_002(self):
-
-        cli_file = '/tmp/pipeline/dma_002/dma_002.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/dma_002/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/dma_002/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_dma_003(self):
-
-        cli_file = '/tmp/pipeline/dma_003/dma_003.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/dma_003/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/dma_003/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_dma_004(self):
-
-        cli_file = '/tmp/pipeline/dma_004/dma_004.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/dma_004/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/dma_004/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_dma_005(self):
-
-        cli_file = '/tmp/pipeline/dma_005/dma_005.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/dma_005/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/dma_005/pcap_files/out_1.txt'
-        filters = "vlan"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_dma_006(self):
-
-        cli_file = '/tmp/pipeline/dma_006/dma_006.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/dma_006/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/dma_006/pcap_files/out_1.txt'
-        filters = "udp port 4532"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_dma_007(self):
-
-        cli_file = '/tmp/pipeline/dma_007/dma_007.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/dma_007/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/dma_007/pcap_files/out_1.txt'
-        filters = "udp port 4532"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_dma_008(self):
-
-        cli_file = '/tmp/pipeline/dma_008/dma_008.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/dma_008/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/dma_008/pcap_files/out_1.txt'
-        filters = "udp port 4532"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_001(self):
-
-        cli_file = '/tmp/pipeline/jump_001/jump_001.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_002(self):
-
-        cli_file = '/tmp/pipeline/jump_002/jump_002.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_002/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_002/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_003(self):
-
-        cli_file = '/tmp/pipeline/jump_003/jump_003.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_003/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_003/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_004(self):
-
-        cli_file = '/tmp/pipeline/jump_004/jump_004.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_004/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_004/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_005(self):
-
-        cli_file = '/tmp/pipeline/jump_005/jump_005.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_005/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_005/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_006(self):
-
-        cli_file = '/tmp/pipeline/jump_006/jump_006.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_006/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_006/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_007(self):
-
-        cli_file = '/tmp/pipeline/jump_007/jump_007.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_007/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_007/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_008(self):
-
-        cli_file = '/tmp/pipeline/jump_008/jump_008.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_008/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_008/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_009(self):
-
-        cli_file = '/tmp/pipeline/jump_009/jump_009.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_009/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_009/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_010(self):
-
-        cli_file = '/tmp/pipeline/jump_010/jump_010.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_010/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_010/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_011(self):
-
-        cli_file = '/tmp/pipeline/jump_011/jump_011.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_011/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_011/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_012(self):
-
-        cli_file = '/tmp/pipeline/jump_012/jump_012.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_012/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_012/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_013(self):
-
-        cli_file = '/tmp/pipeline/jump_013/jump_013.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_013/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_013/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_014(self):
-
-        cli_file = '/tmp/pipeline/jump_014/jump_014.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_014/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_014/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_015(self):
-
-        cli_file = '/tmp/pipeline/jump_015/jump_015.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_015/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_015/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_016(self):
-
-        cli_file = '/tmp/pipeline/jump_016/jump_016.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_016/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_016/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_017(self):
-
-        cli_file = '/tmp/pipeline/jump_017/jump_017.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_017/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_017/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_018(self):
-
-        cli_file = '/tmp/pipeline/jump_018/jump_018.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_018/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_018/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_019(self):
-
-        cli_file = '/tmp/pipeline/jump_019/jump_019.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_019/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_019/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_020(self):
-
-        cli_file = '/tmp/pipeline/jump_020/jump_020.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_020/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_020/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_021(self):
-
-        cli_file = '/tmp/pipeline/jump_021/jump_021.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_021/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_021/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_022(self):
-
-        cli_file = '/tmp/pipeline/jump_022/jump_022.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_022/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_022/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_023(self):
-
-        cli_file = '/tmp/pipeline/jump_023/jump_023.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_023/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_023/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_024(self):
-
-        cli_file = '/tmp/pipeline/jump_024/jump_024.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_024/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_024/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_025(self):
-
-        cli_file = '/tmp/pipeline/jump_025/jump_025.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_025/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_025/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_026(self):
-
-        cli_file = '/tmp/pipeline/jump_026/jump_026.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_026/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_026/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_027(self):
-
-        cli_file = '/tmp/pipeline/jump_027/jump_027.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_027/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_027/pcap_files/out_1.txt'
-        filters = ""
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_028(self):
-
-        cli_file = '/tmp/pipeline/jump_028/jump_028.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_028/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_028/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_029(self):
-
-        cli_file = '/tmp/pipeline/jump_029/jump_029.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_029/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_029/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_030(self):
-
-        cli_file = '/tmp/pipeline/jump_030/jump_030.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_030/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_030/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_031(self):
-
-        cli_file = '/tmp/pipeline/jump_031/jump_031.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_031/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_031/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_032(self):
-
-        cli_file = '/tmp/pipeline/jump_032/jump_032.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_032/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_032/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_033(self):
-
-        cli_file = '/tmp/pipeline/jump_033/jump_033.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_033/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_033/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_034(self):
-
-        cli_file = '/tmp/pipeline/jump_034/jump_034.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_034/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_034/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_035(self):
-
-        cli_file = '/tmp/pipeline/jump_035/jump_035.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_035/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_035/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_036(self):
-
-        cli_file = '/tmp/pipeline/jump_036/jump_036.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_036/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_036/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_037(self):
-
-        cli_file = '/tmp/pipeline/jump_037/jump_037.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_037/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_037/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_038(self):
-
-        cli_file = '/tmp/pipeline/jump_038/jump_038.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_038/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_038/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_039(self):
-
-        cli_file = '/tmp/pipeline/jump_039/jump_039.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_039/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_039/pcap_files/out_1.txt'
-        filters = ""
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_040(self):
-
-        cli_file = '/tmp/pipeline/jump_040/jump_040.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_040/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_040/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_041(self):
-
-        cli_file = '/tmp/pipeline/jump_041/jump_041.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_041/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_041/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_042(self):
-
-        cli_file = '/tmp/pipeline/jump_042/jump_042.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_042/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_042/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_043(self):
-
-        cli_file = '/tmp/pipeline/jump_043/jump_043.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_043/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_043/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_044(self):
-
-        cli_file = '/tmp/pipeline/jump_044/jump_044.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_044/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_044/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_045(self):
-
-        cli_file = '/tmp/pipeline/jump_045/jump_045.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_045/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_045/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_046(self):
-
-        cli_file = '/tmp/pipeline/jump_046/jump_046.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_046/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_046/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_047(self):
-
-        cli_file = '/tmp/pipeline/jump_047/jump_047.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_047/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_047/pcap_files/out_1.txt'
-        filters = ""
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_048(self):
-
-        cli_file = '/tmp/pipeline/jump_048/jump_048.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_048/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_048/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_049(self):
-
-        cli_file = '/tmp/pipeline/jump_049/jump_049.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_049/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_049/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_050(self):
-
-        cli_file = '/tmp/pipeline/jump_050/jump_050.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_050/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_050/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_051(self):
-
-        cli_file = '/tmp/pipeline/jump_051/jump_051.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_051/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_051/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_052(self):
-
-        cli_file = '/tmp/pipeline/jump_052/jump_052.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_052/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_052/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_053(self):
-
-        cli_file = '/tmp/pipeline/jump_053/jump_053.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_053/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_053/pcap_files/out_1.txt'
-        filters = ""
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_054(self):
-
-        cli_file = '/tmp/pipeline/jump_054/jump_054.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_054/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_054/pcap_files/out_1.txt'
-        filters = ""
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_jump_055(self):
-
-        cli_file = '/tmp/pipeline/jump_055/jump_055.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/jump_055/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/jump_055/pcap_files/out_1.txt'
-        filters = ""
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_ckadd_001(self):
-
-        cli_file = '/tmp/pipeline/ckadd_001/ckadd_001.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/ckadd_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/ckadd_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_ckadd_009(self):
-
-        cli_file = '/tmp/pipeline/ckadd_009/ckadd_009.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/ckadd_009/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/ckadd_009/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_ckadd_010(self):
-
-        cli_file = '/tmp/pipeline/ckadd_010/ckadd_010.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/ckadd_010/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/ckadd_010/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_cksub_001(self):
-
-        cli_file = '/tmp/pipeline/cksub_001/cksub_001.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/cksub_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/cksub_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_invalidate_001(self):
-
-        cli_file = '/tmp/pipeline/invalidate_001/invalidate_001.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/invalidate_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/invalidate_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_validate_001(self):
-
-        cli_file = '/tmp/pipeline/validate_001/validate_001.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        # rule 0 test
-        in_pcap_file = 'pipeline/validate_001/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/validate_001/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # rule 1 test
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-
-        # rule 2 test
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-
-        # rule 3 test
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
-
-    def test_table_002(self):
-
-        cli_file = '/tmp/pipeline/table_002/table_002.cli'
-
-        cmd = "sed -i -e 's/0000:00:04.0/%s/' {}".format(cli_file) % self.dut_p0_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:05.0/%s/' {}".format(cli_file) % self.dut_p1_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:06.0/%s/' {}".format(cli_file) % self.dut_p2_pci
-        self.dut.send_expect(cmd, "# ", 20)
-        cmd = "sed -i -e 's/0000:00:07.0/%s/' {}".format(cli_file) % self.dut_p3_pci
-        self.dut.send_expect(cmd, "# ", 20)
-
-        cmd = "{0} {1} -- -s {2}".format(self.app_pipeline_path, self.eal_para, cli_file)
-        self.dut.send_expect(cmd, "PIPELINE0 enable", 60)
-
-        sleep(2)
-
-        # create TCP connection to the server
-        SERVER_IP = '192.168.122.216'
-        SERVER_PORT = 8086
-        BUFFER_SIZE = 1024
-
-        try:
-            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        except socket.error as err:
-            print("socket creation failed with error %s" % (err))
-
-        try:
-            s.connect((SERVER_IP, SERVER_PORT))
-        except socket.error as err:
-            print("socket connection failed with error %s" % (err))
-
-        sleep(0.1)
-        msg = s.recv(BUFFER_SIZE)
-        response = msg.decode()
-        # print('Rxd: ' + response)
-        if "pipeline>" not in response:
-            s.close()
-            self.verify(0, "CLI response error")
-
-        # test empty table scenario
-        in_pcap_file = 'pipeline/table_002/pcap_files/in_1.txt'
-        out_pcap_file = 'pipeline/table_002/pcap_files/out_1.txt'
-        filters = "tcp"
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        # test single rule scenario
-        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_2.txt'
-        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
-        s.send(CLI_CMD.encode('utf-8'))
-        sleep(0.1)
-        msg = s.recv(BUFFER_SIZE)
-        response = msg.decode()
-        # print('Rxd: ' + response)
-        if "pipeline>" not in response:
-            s.close()
-            self.verify(0, "CLI response error")
-        filters = "tcp"
-        in_pcap_file = 'pipeline/table_002/pcap_files/in_2.txt'
-        out_pcap_file = 'pipeline/table_002/pcap_files/out_2.txt'
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        # test two rules scenario
-        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_3.txt'
-        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
-        s.send(CLI_CMD.encode('utf-8'))
-        sleep(0.1)
-        msg = s.recv(BUFFER_SIZE)
-        response = msg.decode()
-        # print('Rxd: ' + response)
-        if "pipeline>" not in response:
-            s.close()
-            self.verify(0, "CLI response error")
-        filters = "tcp"
-        in_pcap_file = 'pipeline/table_002/pcap_files/in_3.txt'
-        out_pcap_file = 'pipeline/table_002/pcap_files/out_3.txt'
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        # delete one rule scenario
-        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_4_1.txt'
-        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update none {} none\n'.format(CMD_FILE)
-        s.send(CLI_CMD.encode('utf-8'))
-        sleep(0.1)
-        msg = s.recv(BUFFER_SIZE)
-        response = msg.decode()
-        # print('Rxd: ' + response)
-        if "pipeline>" not in response:
-            s.close()
-            self.verify(0, "CLI response error")
-        filters = "tcp"
-        in_pcap_file = 'pipeline/table_002/pcap_files/in_4_1.txt'
-        out_pcap_file = 'pipeline/table_002/pcap_files/out_4_1.txt'
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        # delete all rules scenario
-        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_4_2.txt'
-        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update none {} none\n'.format(CMD_FILE)
-        s.send(CLI_CMD.encode('utf-8'))
-        sleep(0.1)
-        msg = s.recv(BUFFER_SIZE)
-        response = msg.decode()
-        # print('Rxd: ' + response)
-        if "pipeline>" not in response:
-            s.close()
-            self.verify(0, "CLI response error")
-        filters = "tcp"
-        in_pcap_file = 'pipeline/table_002/pcap_files/in_4_2.txt'
-        out_pcap_file = 'pipeline/table_002/pcap_files/out_4_2.txt'
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        # action update scenario (restore one of the previously deleted rules and check the update)
-        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_5_1.txt'
-        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
-        s.send(CLI_CMD.encode('utf-8'))
-        sleep(0.1)
-        msg = s.recv(BUFFER_SIZE)
-        response = msg.decode()
-        print('Rxd: ' + response)
-        if "pipeline>" not in response:
-            s.close()
-            self.verify(0, "CLI response error")
-        filters = "tcp"
-        in_pcap_file = 'pipeline/table_002/pcap_files/in_5_1.txt'
-        out_pcap_file = 'pipeline/table_002/pcap_files/out_5_1.txt'
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-
-        # action update scenario (change the action of restored rule and check the update)
-        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_5_2.txt'
-        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
-        s.send(CLI_CMD.encode('utf-8'))
-        sleep(0.1)
-        msg = s.recv(BUFFER_SIZE)
-        response = msg.decode()
-        print('Rxd: ' + response)
-        if "pipeline>" not in response:
-            s.close()
-            self.verify(0, "CLI response error")
-        filters = "tcp"
-        in_pcap_file = 'pipeline/table_002/pcap_files/in_5_1.txt'
-        out_pcap_file = 'pipeline/table_002/pcap_files/out_5_1.txt'
-        sniff_pkts = self.send_and_sniff_pkts(0, 1, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(1, 0, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(2, 3, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(3, 2, in_pcap_file, out_pcap_file, filters)
-
-        # deafult action scenario [empty table]
-        '''
-        Empty table => Lookup MISS with default action executed
-        '''
-        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_6_1.txt'  # delete the previously added rule
-        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update none {} none\n'.format(CMD_FILE)
-        s.send(CLI_CMD.encode('utf-8'))
-        sleep(0.1)
-        msg = s.recv(BUFFER_SIZE)
-        response = msg.decode()
-        print('Rxd: ' + response)
-        if "pipeline>" not in response:
-            s.close()
-            self.verify(0, "CLI response error")
-        filters = "tcp"
-        in_pcap_file = 'pipeline/table_002/pcap_files/in_6_1.txt'
-        out_pcap_file = 'pipeline/table_002/pcap_files/out_6_1.txt'
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        # deafult action scenario [table with one rule]
-        '''
-        Add key A => Lookup HIT for the right packet with the specific key associated action executed
-                     Lookup MISS for any other packets with default action executed
-        '''
-        CMD_FILE = '/tmp/pipeline/table_002/cmd_files/cmd_6_2.txt'  # add a new rule
-        CLI_CMD = 'pipeline PIPELINE0 table table_002_table update {} none none\n'.format(CMD_FILE)
-        s.send(CLI_CMD.encode('utf-8'))
-        sleep(0.1)
-        msg = s.recv(BUFFER_SIZE)
-        response = msg.decode()
-        print('Rxd: ' + response)
-        if "pipeline>" not in response:
-            s.close()
-            self.verify(0, "CLI response error")
-        filters = "tcp"
-        in_pcap_file = 'pipeline/table_002/pcap_files/in_6_2.txt'
-        out_pcap_file = 'pipeline/table_002/pcap_files/out_6_2.txt'
-        sniff_pkts = self.send_and_sniff_pkts(0, 0, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(1, 1, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(2, 2, in_pcap_file, out_pcap_file, filters)
-        sniff_pkts = self.send_and_sniff_pkts(3, 3, in_pcap_file, out_pcap_file, filters)
-
-        s.close()
-        sleep(1)
-        cmd = "^C"
-        self.dut.send_expect(cmd, "# ", 20)
+        out_pcap_1 = 'pipeline/met_001/pcap_files/out_41.txt'
+        out_pcap_2 = 'pipeline/met_001/pcap_files/out_42.txt'
+        out_pcap_3 = 'pipeline/met_001/pcap_files/out_43.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_002(self):
+
+        cli_file = '/tmp/pipeline/met_002/met_002.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_002/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_002/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_002/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_002/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        out_pcap_1 = 'pipeline/met_002/pcap_files/out_21.txt'
+        out_pcap_2 = 'pipeline/met_002/pcap_files/out_22.txt'
+        out_pcap_3 = 'pipeline/met_002/pcap_files/out_23.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_003(self):
+
+        cli_file = '/tmp/pipeline/met_003/met_003.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_003/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_003/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_003/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_003/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        out_pcap_1 = 'pipeline/met_003/pcap_files/out_21.txt'
+        out_pcap_2 = 'pipeline/met_003/pcap_files/out_22.txt'
+        out_pcap_3 = 'pipeline/met_003/pcap_files/out_23.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_004(self):
+
+        cli_file = '/tmp/pipeline/met_004/met_004.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_004/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_004/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_004/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_004/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        out_pcap_1 = 'pipeline/met_004/pcap_files/out_21.txt'
+        out_pcap_2 = 'pipeline/met_004/pcap_files/out_22.txt'
+        out_pcap_3 = 'pipeline/met_004/pcap_files/out_23.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_005(self):
+
+        cli_file = '/tmp/pipeline/met_005/met_005.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_005/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_005/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_005/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_005/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        out_pcap_1 = 'pipeline/met_005/pcap_files/out_21.txt'
+        out_pcap_2 = 'pipeline/met_005/pcap_files/out_22.txt'
+        out_pcap_3 = 'pipeline/met_005/pcap_files/out_23.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_006(self):
+
+        cli_file = '/tmp/pipeline/met_006/met_006.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_006/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_006/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_006/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_006/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        out_pcap_1 = 'pipeline/met_006/pcap_files/out_21.txt'
+        out_pcap_2 = 'pipeline/met_006/pcap_files/out_22.txt'
+        out_pcap_3 = 'pipeline/met_006/pcap_files/out_23.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_007(self):
+
+        cli_file = '/tmp/pipeline/met_007/met_007.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_007/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_007/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_007/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_007/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        out_pcap_1 = 'pipeline/met_007/pcap_files/out_21.txt'
+        out_pcap_2 = 'pipeline/met_007/pcap_files/out_22.txt'
+        out_pcap_3 = 'pipeline/met_007/pcap_files/out_23.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_008(self):
+
+        cli_file = '/tmp/pipeline/met_008/met_008.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_008/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_008/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_008/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_008/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        out_pcap_1 = 'pipeline/met_008/pcap_files/out_21.txt'
+        out_pcap_2 = 'pipeline/met_008/pcap_files/out_22.txt'
+        out_pcap_3 = 'pipeline/met_008/pcap_files/out_23.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_009(self):
+
+        cli_file = '/tmp/pipeline/met_009/met_009.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_009/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_009/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_009/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_009/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        out_pcap_1 = 'pipeline/met_009/pcap_files/out_21.txt'
+        out_pcap_2 = 'pipeline/met_009/pcap_files/out_22.txt'
+        out_pcap_3 = 'pipeline/met_009/pcap_files/out_23.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_010(self):
+
+        cli_file = '/tmp/pipeline/met_010/met_010.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_010/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_010/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_010/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_010/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        out_pcap_1 = 'pipeline/met_010/pcap_files/out_21.txt'
+        out_pcap_2 = 'pipeline/met_010/pcap_files/out_22.txt'
+        out_pcap_3 = 'pipeline/met_010/pcap_files/out_23.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_011(self):
+
+        cli_file = '/tmp/pipeline/met_011/met_011.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_011/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_011/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_011/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_011/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        out_pcap_1 = 'pipeline/met_011/pcap_files/out_21.txt'
+        out_pcap_2 = 'pipeline/met_011/pcap_files/out_22.txt'
+        out_pcap_3 = 'pipeline/met_011/pcap_files/out_23.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_012(self):
+
+        cli_file = '/tmp/pipeline/met_012/met_012.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_012/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_012/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_012/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_012/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+
+        out_pcap_1 = 'pipeline/met_012/pcap_files/out_21.txt'
+        out_pcap_2 = 'pipeline/met_012/pcap_files/out_22.txt'
+        out_pcap_3 = 'pipeline/met_012/pcap_files/out_23.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 10)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_013(self):
+
+        cli_file = '/tmp/pipeline/met_013/met_013.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_013/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_013/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_013/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_013/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_014(self):
+
+        cli_file = '/tmp/pipeline/met_014/met_014.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_014/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_014/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_014/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_014/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_met_015(self):
+
+        cli_file = '/tmp/pipeline/met_015/met_015.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = ['pipeline/met_015/pcap_files/in_1.txt']
+        out_pcap_1 = 'pipeline/met_015/pcap_files/out_11.txt'
+        out_pcap_2 = 'pipeline/met_015/pcap_files/out_12.txt'
+        out_pcap_3 = 'pipeline/met_015/pcap_files/out_13.txt'
+        out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3]
+        filters = ["tcp"] * 3
+        tx_port = [0]
+        rx_port = [0, 1, 2]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters, 1000)
+        self.dut.send_expect("^C", "# ", 20)
+
+    '''
+    def test_tap_port_001(self):
+
+        cli_file = '/tmp/pipeline/tap_port_001/tap_port_001.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = 'pipeline/tap_port_001/pcap_files/in_1.txt'
+        out_pcap = 'pipeline/tap_port_001/pcap_files/out_1.txt'
+        self.send_and_sniff_pkts(0, 0, in_pcap, out_pcap, "udp")
+        self.dut.send_expect("^C", "# ", 20)
+    '''
+
+    def test_ring_port_001(self):
+
+        cli_file = '/tmp/pipeline/ring_port_001/ring_port_001.cli'
+        self.run_dpdk_app(cli_file)
+
+        in_pcap = 'pipeline/ring_port_001/pcap_files/in_1.txt'
+        out_pcap = 'pipeline/ring_port_001/pcap_files/out_1.txt'
+        self.send_and_sniff_pkts(0, 1, in_pcap, out_pcap, "udp")
+        self.dut.send_expect("^C", "# ", 20)
+
+    def test_tencent_001(self):
+
+        cli_file = '/tmp/pipeline/tencent_001/tencent_001.cli'
+        self.run_dpdk_app(cli_file)
+        base_dir = 'pipeline/tencent_001/pcap_files/'
+
+        # TCP Packets
+        in_pcap = ['in_1.txt']
+        in_pcap = [base_dir + s for s in in_pcap]
+        out_pcap = ['out_11.txt', 'out_12.txt', 'out_13.txt', 'out_14.txt']
+        out_pcap = [base_dir + s for s in out_pcap]
+        filters = ["tcp"] * 4
+        tx_port = [0]
+        rx_port = [0, 1, 2, 3]
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+
+        # UDP Packets
+        in_pcap = ['in_2.txt']
+        in_pcap = [base_dir + s for s in in_pcap]
+        out_pcap = ['out_21.txt', 'out_22.txt', 'out_23.txt', 'out_24.txt']
+        out_pcap = [base_dir + s for s in out_pcap]
+        filters = ["udp port 200"] * 4
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+
+        # ICMP Packets
+        in_pcap = ['in_3.txt']
+        in_pcap = [base_dir + s for s in in_pcap]
+        out_pcap = ['out_31.txt', 'out_32.txt', 'out_33.txt', 'out_34.txt']
+        out_pcap = [base_dir + s for s in out_pcap]
+        filters = ["icmp"] * 4
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+
+        # IGMP Packets
+        in_pcap = ['in_4.txt']
+        in_pcap = [base_dir + s for s in in_pcap]
+        out_pcap = ['out_41.txt', 'out_42.txt', 'out_43.txt', 'out_44.txt']
+        out_pcap = [base_dir + s for s in out_pcap]
+        filters = ["igmp"] * 4
+        self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters)
+        self.dut.send_expect("^C", "# ", 20)
 
     def tear_down(self):
         """
-- 
1.8.3.1

Re: [dts] [PATCH 0/2] add pipeline new features test scenarios

[Tu, Lijuan]

> -----Original Message-----
> From: dts <dts-bounces@dpdk.org> On Behalf Of Churchill Khangar
> Sent: 2021年4月21日 18:17
> To: dts@dpdk.org
> Cc: Dumitrescu, Cristian <cristian.dumitrescu@intel.com>; P, Venkata Suresh
> Kumar <venkata.suresh.kumar.p@intel.com>; Khangar, Churchill
> <churchill.khangar@intel.com>; Jangra, Yogesh <yogesh.jangra@intel.com>
> Subject: [dts] [PATCH 0/2] add pipeline new features test scenarios
> 
> This patch series has the changes to support test suite for pipeline application
> new features. Also changes to improve existing test cases logic to cover
> different operand lengths, endianness issues and additional test cases for
> existing features.
> 
> Following are the details of new features and existing test cases enhancements
>      1. Framework enhancements to improve overall execution time.
>      2. RING I/O port type
>      3. WCM table match
>      4. Register Array
>      5. trTCM
>      6. Enhancement to existing test cases to verify
>           a. Endianness issue
>           b. Operands with variable size values
>      7. Additional tests to provide more coverage for table match and actions
>      8. Additional tests to cover customer common use cases
> 
> Patch details
>      1. Patch1 - pipeline dependencies archive and compressed
>         file pipeline.tar.gz modified for all new features.
>      2. Patch2 - add new features test coverage.
> 
> Churchill Khangar (2):
>   dep: add pipeline test suite new feature dependencies
>   tests/pipeline: add new features test coverage
> 
>  dep/pipeline.tar.gz         |  Bin 49082 -> 74543 bytes
>  tests/TestSuite_pipeline.py | 8416 +++++++++++++++++++------------------------
>  2 files changed, 3661 insertions(+), 4755 deletions(-)
> 
> --
> 1.8.3.1

Applied the series, thanks