diff --git a/tests/TestSuite_ice_flow_priority.py b/tests/TestSuite_ice_flow_priority.py
index 4f63f06d..ddc6a2af 100644
--- a/tests/TestSuite_ice_flow_priority.py
+++ b/tests/TestSuite_ice_flow_priority.py
@@ -440,11 +440,22 @@ class ICEPFFlowPriorityTest(TestCase):
                 cores="1S/4C/1T",
                 ports=[self.pf_pci],
                 eal_param="--log-level=ice,8",
-                param="--rxq=16 --txq=16",
+                param="--rxq={0} --txq={0}".format(self.rxq),
+            )
+        # start testpmd in pipeline mode
+        elif "pipeline" in self._suite_result.test_case:
+            self.pmdout.start_testpmd(
+                cores="1S/4C/1T",
+                ports=[self.pf_pci],
+                port_options={self.pf_pci: "pipeline-mode-support=1"},
+                eal_param="--log-level=ice,7",
+                param="--rxq={0} --txq={0}".format(self.rxq),
             )
         else:
             self.pmdout.start_testpmd(
-                cores="1S/4C/1T", ports=[self.pf_pci], param="--rxq=16 --txq=16"
+                cores="1S/4C/1T",
+                ports=[self.pf_pci],
+                param="--rxq={0} --txq={0}".format(self.rxq),
             )
         self.pmdout.execute_cmd("set fwd rxonly")
         self.pmdout.execute_cmd("set verbose 1")
@@ -652,11 +663,166 @@ class ICEPFFlowPriorityTest(TestCase):
         queue = re.findall(p, out)
         self.verify(len(queue) == 1 and int(queue[0]) == 5, "drop pkt failed")
 
+    def test_create_fdir_rule_with_priority_0_pipeline(self):
+        """
+        Create Flow Rules Only Supported by Fdir Filter with Priority 0
+        """
+        # create rules only supported by fdir with priority 0, check the rules can not be created.
+        out = self.dut.send_expect(
+            "flow create 0 priority 0 ingress pattern eth / ipv6 src is 1111:2222:3333:4444:5555:6666:7777:8888 dst is 1111:2222:3333:4444:5555:6666:7777:9999 / sctp src is 25 dst is 23 / end actions queue index 1 / end",
+            "testpmd> ",
+        )
+        self.verify("Failed" in out, "failed: priority is not work")
+        out = self.dut.send_expect(
+            "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 ttl is 20 / sctp src is 25 dst is 23 / end actions queue index 1 / end",
+            "testpmd> ",
+        )
+        self.verify("Failed" in out, "failed: priority is not work")
+        self.dut.send_expect("quit", "# ")
+
+    def test_create_switch_rule_with_priority_1_pipeline(self):
+        """
+        Create flow rules only supported by switch filter with priority 1
+        """
+        # create rules only supported by switch with priority 1, check the rules can not be created.
+        out = self.dut.send_expect(
+            "flow create 0 priority 1 ingress pattern eth / ipv4 / nvgre / eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / end actions queue index 3 / end",
+            "testpmd> ",
+        )
+        self.verify("Failed" in out, "failed: priority is not work")
+        out = self.dut.send_expect(
+            "flow create 0 priority 1 ingress pattern eth / ipv4 / nvgre / eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / udp src is 25 dst is 23 / end actions queue index 3 / end",
+            "testpmd> ",
+        )
+        self.verify("Failed" in out, "failed: priority is not work")
+        self.dut.send_expect("quit", "# ")
+
+    def test_priority_in_pipeline_mode(self):
+        """
+        Create Flow Rules with Priority in Pipeline Mode
+        """
+        rules = [
+            "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 1 / end",
+            "flow create 0 priority 0 ingress pattern eth / ipv4 / udp / vxlan / eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / udp src is 25 dst is 23 / end actions queue index 2 / end",
+            "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.4 dst is 192.168.0.7 tos is 4 ttl is 20 / tcp src is 25 dst is 23 / end actions queue index 3 / end",
+            "flow create 0 priority 1 ingress pattern eth / ipv4 / udp / vxlan / eth / ipv4 src is 192.168.0.4 dst is 192.168.0.7 / udp src is 25 dst is 23 / end actions queue index 4 / end",
+            "flow create 0 ingress pattern eth / ipv4 src is 192.168.1.2 dst is 192.168.0.3 tos is 5 / tcp src is 25 dst is 23 / end actions queue index 1 / end",
+            "flow create 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 ttl is 20 / sctp src is 25 dst is 23 / end actions queue index 1 / end",
+        ]
+        pkts = [
+            'Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)',
+            'Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP()/UDP()/VXLAN()/Ether()/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/UDP(sport=25,dport=23)/Raw("x"*80)',
+            'Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP(src="192.168.0.4",dst="192.168.0.7",tos=4,ttl=20)/TCP(sport=25,dport=23)/Raw("x"*80)',
+            'Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP()/UDP()/VXLAN()/Ether()/IP(src="192.168.0.4",dst="192.168.0.7")/UDP(sport=25,dport=23)/Raw("x"*80)',
+        ]
+        # create fdir and switch rules with different priority
+        rule_list1 = self.process.create_rule(
+            rules[0:2], check_stats=True, msg="Succeeded to create (2) flow"
+        )
+        rule_list2 = self.process.create_rule(
+            rules[2:4], check_stats=True, msg="Succeeded to create (1) flow"
+        )
+        rule_list = rule_list1 + rule_list2
+        self.process.check_rule(port_id=0, stats=True, rule_list=rule_list)
+        # send pkts and check the rules are written to different filter tables and the rules can work
+        self.pmdout.wait_link_status_up(self.dut_ports[0])
+        out = self.process.send_pkt_get_out(pkts[0], port_id=0)
+        self.process.check_rx_packets(
+            out, check_param={"queue": 1}, expect_pkt=1, stats=True
+        )
+        self.logger.info("pass: queue id is 1")
+        out = self.process.send_pkt_get_out(pkts[1], port_id=0)
+        self.process.check_rx_packets(
+            out, check_param={"queue": 2}, expect_pkt=1, stats=True
+        )
+        self.logger.info("pass: queue id is 2")
+        out = self.process.send_pkt_get_out(pkts[2], port_id=0)
+        self.process.check_rx_packets(
+            out, check_param={"queue": 3}, expect_pkt=1, stats=True
+        )
+        self.logger.info("pass: queue id is 3")
+        out = self.process.send_pkt_get_out(pkts[3], port_id=0)
+        self.process.check_rx_packets(
+            out, check_param={"queue": 4}, expect_pkt=1, stats=True
+        )
+        self.logger.info("pass: queue id is 4")
+        # create rules without priority, only the pattern supported by switch can be created.
+        self.process.create_rule(
+            rules[4], check_stats=True, msg="Succeeded to create (2) flow"
+        )
+        self.process.create_rule(rules[5], check_stats=False)
+        self.pmdout.execute_cmd("flow flush 0")
+
+    def test_rules_with_same_parameters_different_action_pipeline(self):
+        """
+        Create flow rules with same parameter but different actions
+        """
+        rules = [
+            "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 1 / end",
+            "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 3 / end",
+        ]
+        pkts = [
+            'Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)',
+        ]
+
+        # create rules with same parameters but different action
+        rule_list1 = self.process.create_rule(
+            rules[0], check_stats=True, msg="Succeeded to create (2) flow"
+        )
+        rule_list2 = self.process.create_rule(
+            rules[1], check_stats=True, msg="Succeeded to create (1) flow"
+        )
+        rule_list = rule_list1 + rule_list2
+        self.process.check_rule(port_id=0, stats=True, rule_list=rule_list)
+        # send a pkt to check the switch rule is work for its high priority
+        self.pmdout.wait_link_status_up(self.dut_ports[0])
+        out = self.process.send_pkt_get_out(pkts[0], port_id=0)
+        self.process.check_rx_packets(
+            out, check_param={"queue": 1}, expect_pkt=1, stats=True
+        )
+        self.logger.info("pass: queue id is 1")
+        # remove the switch rule and check the fdir rule is work
+        self.process.destroy_rule(port_id=0, rule_id=rule_list1)
+        out = self.process.send_pkt_get_out(pkts[0], port_id=0)
+        self.process.check_rx_packets(
+            out, check_param={"queue": 3}, expect_pkt=1, stats=True
+        )
+        self.logger.info("pass: queue id is 3")
+        self.pmdout.execute_cmd("flow flush 0")
+        self.pmdout.quit()
+        # restart testpmd in pipeline mode
+        self.launch_testpmd()
+        # create rules with same parameters but different action
+        rule_list1 = self.process.create_rule(
+            rules[1], check_stats=True, msg="Succeeded to create (1) flow"
+        )
+        rule_list2 = self.process.create_rule(
+            rules[0], check_stats=True, msg="Succeeded to create (2) flow"
+        )
+        rule_list = rule_list1 + rule_list2
+        self.process.check_rule(port_id=0, stats=True, rule_list=rule_list)
+        # send a pkt to check the switch rule is work for its high priority
+        self.pmdout.wait_link_status_up(self.dut_ports[0])
+        self.pmdout.wait_link_status_up(self.dut_ports[0])
+        out = self.process.send_pkt_get_out(pkts[0], port_id=0)
+        self.process.check_rx_packets(
+            out, check_param={"queue": 1}, expect_pkt=1, stats=True
+        )
+        self.logger.info("pass: queue id is 1")
+        # remove the switch rule and check the fdir rule is work
+        self.process.destroy_rule(port_id=0, rule_id=rule_list2)
+        out = self.process.send_pkt_get_out(pkts[0], port_id=0)
+        self.process.check_rx_packets(
+            out, check_param={"queue": 3}, expect_pkt=1, stats=True
+        )
+        self.logger.info("pass: queue id is 3")
+        self.pmdout.execute_cmd("flow flush 0")
+
     def tear_down(self):
         """
         Run after each test case.
         """
-        self.pmdout.execute_cmd("quit", "# ")
+        self.pmdout.quit()
 
     def tear_down_all(self):
         """
diff --git a/tests/TestSuite_rteflow_priority.py b/tests/TestSuite_rteflow_priority.py
deleted file mode 100644
index 813df85c..00000000
--- a/tests/TestSuite_rteflow_priority.py
+++ /dev/null
@@ -1,529 +0,0 @@
-# SPDX-License-Identifier: BSD-3-Clause
-# Copyright(c) 2019 Intel Corporation
-#
-
-"""
-DPDK Test suite.
-
-Test rte_flow priority
-"""
-
-import imp
-import re
-import string
-import sys
-import time
-from time import sleep
-
-from scapy.utils import PcapWriter, socket, struct
-
-import framework.utils as utils
-from framework.pktgen import PacketGeneratorHelper
-from framework.pmd_output import PmdOutput
-from framework.settings import HEADER_SIZE
-from framework.test_case import TestCase
-
-imp.reload(sys)
-
-
-class TestRteflowPriority(TestCase):
-    def set_up_all(self):
-        """
-        Run at the start of each test suite.
-
-        PMD prerequisites.
-        """
-        self.dut_ports = self.dut.get_ports(self.nic)
-        localPort = self.tester.get_local_port(self.dut_ports[0])
-        self.__tx_iface = self.tester.get_interface(localPort)
-        cores = self.dut.get_core_list("1S/5C/1T")
-        self.coreMask = utils.create_mask(cores)
-        self.portMask = utils.create_mask([self.dut_ports[0]])
-        self.path = self.dut.apps_name["test-pmd"]
-
-    def set_up(self):
-        """
-        Run before each test case.
-        """
-        pass
-
-    #
-    # Utility methods and other non-test code.
-    #
-    ###########################################################################
-    scapyCmds = []
-
-    def check_link(self):
-        # check status in test case, dut and tester both should be up.
-        self.pmd_output = PmdOutput(self.dut)
-        res = self.pmd_output.wait_link_status_up("all", timeout=30)
-        if res is True:
-            for i in range(15):
-                out = self.tester.get_port_status(self.dut_ports[0])
-                if out == "up":
-                    break
-                else:
-                    time.sleep(1)
-            return True
-        else:
-            return False
-
-    def send_pkt(self, cmd):
-        """
-        Send packages and verify behavior.
-        """
-        self.tester.scapyCmds.append(cmd)
-        self.tester.scapy_execute()
-
-    def get_packet_number(self, out, match_string):
-        """
-        get the rx packets number.
-        """
-
-        out_lines = out.splitlines()
-        pkt_num = 0
-        for i in range(len(out_lines)):
-            if match_string in out_lines[i]:
-                result_scanner = r"RX-packets:\s?(\d+)"
-                scanner = re.compile(result_scanner, re.DOTALL)
-                m = scanner.search(out_lines[i + 1])
-                pkt_num = int(m.group(1))
-                break
-        return pkt_num
-
-    def check_queue_rx_packets_number(self, out, queue_id):
-        """
-        check the queue rx packets number.
-        """
-        match_string = "------- Forward Stats for RX Port= 0/Queue= %d" % queue_id
-        pkt_num = self.get_packet_number(out, match_string)
-        return pkt_num
-
-    #
-    # test cases.
-    #
-    ###########################################################################
-
-    def test_priority_in_pipeline_mode(self):
-        """
-        priority is active in pipeline mode.
-        """
-        # start testpmd in pipeline mode
-        # genarate eal
-        command = (
-            self.path
-            + '-c %s -n 4 -a %s,pipeline-mode-support=1 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10'
-            % (
-                self.coreMask,
-                self.dut.ports_info[0]["pci"],
-                utils.create_mask([self.dut_ports[0]]),
-            )
-        )
-        out = self.dut.send_expect(command, "testpmd> ", 120)
-        self.logger.debug(out)
-
-        self.dut.send_expect("set fwd rxonly", "testpmd> ", 15)
-        self.dut.send_expect("set verbose 1", "testpmd> ", 15)
-        self.dut.send_expect("rx_vxlan_port add 4789 0", "testpmd> ", 15)
-
-        # create fdir and switch rules with different priority
-        out = self.dut.send_expect(
-            "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 1 / end ",
-            "testpmd>",
-            15,
-        )
-        self.verify("Successed" and "(2)" in out, "failed: rule map to wrong filter")
-        out = self.dut.send_expect(
-            "flow create 0 priority 0 ingress pattern eth / ipv4 / udp / vxlan / eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / udp src is 25 dst is 23 / end actions queue index 2 / end ",
-            "testpmd>",
-            15,
-        )
-        self.verify("Successed" and "(2)" in out, "failed: rule map to wrong filter")
-        out = self.dut.send_expect(
-            "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.4 dst is 192.168.0.7 tos is 4 ttl is 20 / tcp src is 25 dst is 23 / end actions queue index 3 / end ",
-            "testpmd>",
-            15,
-        )
-        self.verify("Successed" and "(1)" in out, "failed: rule map to wrong filter")
-        out = self.dut.send_expect(
-            "flow create 0 priority 1 ingress pattern eth / ipv4 / udp / vxlan / eth / ipv4 src is 192.168.0.4 dst is 192.168.0.7 / udp src is 25 dst is 23 / end actions queue index 4 / end ",
-            "testpmd>",
-            15,
-        )
-        self.verify("Successed" and "(1)" in out, "failed: rule map to wrong filter")
-        out = self.dut.send_expect("flow list 0", "testpmd> ", 15)
-        self.logger.info(out)
-        self.verify("3" in out, "failed: flow rules created error")
-
-        # send pkts and check the rules are written to different filter tables and the rules can work
-        self.dut.send_expect("start", "testpmd>", 20)
-        a = self.check_link()
-        self.verify(a, "failed: link can not up")
-        self.send_pkt(
-            'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)],iface="%s")'
-            % (self.__tx_iface)
-        )
-        out = self.dut.send_expect("stop", "testpmd>", 20)
-        pkt_num = self.check_queue_rx_packets_number(out, 1)
-        self.verify(pkt_num == 1, "failed: the flow rule can not work")
-        self.logger.info("pass: queue id is 1")
-
-        self.dut.send_expect("start", "testpmd>", 20)
-        self.send_pkt(
-            'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP()/UDP()/VXLAN()/Ether()/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/UDP(sport=25,dport=23)/Raw("x"*80)],iface="%s")'
-            % (self.__tx_iface)
-        )
-        out = self.dut.send_expect("stop", "testpmd>", 20)
-        pkt_num = self.check_queue_rx_packets_number(out, 2)
-        self.verify(pkt_num == 1, "failed: the flow rule can not work")
-        self.logger.info("pass: queue id is 2")
-
-        self.dut.send_expect("start", "testpmd>", 20)
-        self.send_pkt(
-            'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP(src="192.168.0.4",dst="192.168.0.7",tos=4,ttl=20)/TCP(sport=25,dport=23)/Raw("x"*80)],iface="%s")'
-            % (self.__tx_iface)
-        )
-        out = self.dut.send_expect("stop", "testpmd>", 20)
-        pkt_num = self.check_queue_rx_packets_number(out, 3)
-        self.verify(pkt_num == 1, "failed: the flow rule can not work")
-        self.logger.info("pass: queue id is 3")
-
-        self.dut.send_expect("start", "testpmd>", 20)
-        self.send_pkt(
-            'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP()/UDP()/VXLAN()/Ether()/IP(src="192.168.0.4",dst="192.168.0.7")/UDP(sport=25,dport=23)/Raw("x"*80)],iface="%s")'
-            % (self.__tx_iface)
-        )
-        out = self.dut.send_expect("stop", "testpmd>", 20)
-        pkt_num = self.check_queue_rx_packets_number(out, 4)
-        self.verify(pkt_num == 1, "failed: the flow rule can not work")
-        self.logger.info("pass: queue id is 4")
-
-        # create rules without priority, only the pattern supported by switch can be created.
-        out = self.dut.send_expect(
-            "flow create 0 ingress pattern eth / ipv4 src is 192.168.1.2 dst is 192.168.0.3 tos is 5 / tcp src is 25 dst is 23 / end actions queue index 1 / end ",
-            "testpmd>",
-            15,
-        )
-        self.verify("Failed" not in out, "failed: default priority 0 is not work")
-        out = self.dut.send_expect(
-            "flow create 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 ttl is 20 / sctp src is 25 dst is 23 / end actions queue index 1 / end ",
-            "testpmd>",
-            15,
-        )
-        self.verify(
-            "Failed" in out,
-            "failed: pattern only support by fdir can not be created in default priority",
-        )
-
-        self.dut.send_expect("flow flush 0", "testpmd>", 20)
-        self.dut.send_expect("quit", "#", 50)
-
-    def test_priority_in_nonpipeline_mode(self):
-        """
-        priority is not active in pipeline mode.
-        """
-
-        # start testpmd without pipeline-mode-support parameter, check the testpmd is launch in non-pipeline mode
-        command = (
-            self.path
-            + '-c %s -n 4 -a %s --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10'
-            % (
-                self.coreMask,
-                self.dut.ports_info[0]["pci"],
-                utils.create_mask([self.dut_ports[0]]),
-            )
-        )
-        out = self.dut.send_expect(command, "testpmd> ", 120)
-        self.logger.debug(out)
-
-        out = self.dut.send_expect(
-            "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / end actions queue index 2 / mark / end",
-            "testpmd>",
-            15,
-        )
-        self.verify(
-            "Successed" and "(1)" in out, "failed: rule can't be created to fdir"
-        )
-        out = self.dut.send_expect(
-            "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / end actions queue index 2 / mark / end",
-            "testpmd>",
-            15,
-        )
-        self.verify(
-            "Failed" in out,
-            "failed: default value of priority is 0 in non-pipeline mode",
-        )
-        self.dut.send_expect("flow flush 0", "testpmd>", 20)
-        self.dut.send_expect("quit", "#", 50)
-
-        # restart testpmd with pipeline-mode-support=0, check the testpmd is launch in non-pipeline mode
-        command = (
-            self.path
-            + '-c %s -n 4 -a %s,pipeline-mode-support=0 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10'
-            % (
-                self.coreMask,
-                self.dut.ports_info[0]["pci"],
-                utils.create_mask([self.dut_ports[0]]),
-            )
-        )
-        out = self.dut.send_expect(command, "testpmd> ", 120)
-        self.logger.debug(out)
-
-        out = self.dut.send_expect(
-            "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / end actions queue index 2 / mark / end",
-            "testpmd>",
-            15,
-        )
-        self.verify(
-            "Successed" and "(1)" in out, "failed: rule can't be created to fdir"
-        )
-        out = self.dut.send_expect(
-            "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / end actions queue index 2 / mark / end",
-            "testpmd>",
-            15,
-        )
-        self.verify(
-            "Failed" in out,
-            "failed: default value of priority is 0 in non-pipeline mode",
-        )
-        self.dut.send_expect("flow flush 0", "testpmd>", 20)
-        self.dut.send_expect("quit", "#", 50)
-
-    def test_no_destination_high_prority(self):
-        """
-        no destination high priority rule is not acceptable.
-        """
-
-        # start testpmd in pipeline mode
-        command = (
-            self.path
-            + '-c %s -n 4 -a %s,pipeline-mode-support=1 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10'
-            % (
-                self.coreMask,
-                self.dut.ports_info[0]["pci"],
-                utils.create_mask([self.dut_ports[0]]),
-            )
-        )
-        out = self.dut.send_expect(command, "testpmd> ", 120)
-        self.logger.debug(out)
-
-        # create no destination high priority rules, check the rules can not be created.
-        out = self.dut.send_expect(
-            "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions / end",
-            "testpmd>",
-            15,
-        )
-        self.verify(
-            "Bad argument" in out,
-            "failed: no destination high priority rule is not acceptable",
-        )
-        out = self.dut.send_expect(
-            "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end",
-            "testpmd>",
-            15,
-        )
-        self.verify(
-            "Bad argument" in out,
-            "failed: no destination high priority rule is not acceptable",
-        )
-        self.dut.send_expect("quit", "#", 50)
-
-    def test_create_fdir_rule_with_priority_0(self):
-        """
-        create a rule only supported by fdir filter with priority 0 is not acceptable.
-        """
-
-        # start testpmd in pipeline mode
-        command = (
-            self.path
-            + '-c %s -n 4 -a %s,pipeline-mode-support=1 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10'
-            % (
-                self.coreMask,
-                self.dut.ports_info[0]["pci"],
-                utils.create_mask([self.dut_ports[0]]),
-            )
-        )
-        out = self.dut.send_expect(command, "testpmd> ", 120)
-        self.logger.debug(out)
-
-        # create rules only supported by fdir with priority 0, check the rules can not be created.
-        out = self.dut.send_expect(
-            "flow create 0 priority 0 ingress pattern eth / ipv6 src is 1111:2222:3333:4444:5555:6666:7777:8888 dst is 1111:2222:3333:4444:5555:6666:7777:9999 / sctp src is 25 dst is 23 / end actions queue index 1 / end",
-            "testpmd>",
-            15,
-        )
-        self.verify("Failed" in out, "failed: priority is not work")
-        out = self.dut.send_expect(
-            "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 ttl is 20 / sctp src is 25 dst is 23 / end actions queue index 1 / end",
-            "testpmd>",
-            15,
-        )
-        self.verify("Failed" in out, "failed: priority is not work")
-        self.dut.send_expect("quit", "#", 50)
-
-    def test_create_switch_rule_with_priority_1(self):
-        """
-        create a rule only supported by switch filter with priority 1 is not acceptable.
-        """
-
-        # start testpmd in pipeline mode
-        command = (
-            self.path
-            + '-c %s -n 4 -a %s,pipeline-mode-support=1 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10'
-            % (
-                self.coreMask,
-                self.dut.ports_info[0]["pci"],
-                utils.create_mask([self.dut_ports[0]]),
-            )
-        )
-        out = self.dut.send_expect(command, "testpmd> ", 120)
-        self.logger.debug(out)
-
-        # create rules only supported by switch with priority 1, check the rules can not be created.
-        out = self.dut.send_expect(
-            "flow create 0 priority 1 ingress pattern eth / ipv4 / nvgre / eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / end actions queue index 3 / end",
-            "testpmd>",
-            15,
-        )
-        self.verify("Failed" in out, "failed: priority is not work")
-        out = self.dut.send_expect(
-            "flow create 0 priority 1 ingress pattern eth / ipv4 / nvgre / eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / udp src is 25 dst is 23 / end actions queue index 3 / end",
-            "testpmd>",
-            15,
-        )
-        self.verify("Failed" in out, "failed: priority is not work")
-        self.dut.send_expect("quit", "#", 50)
-
-    def test_rules_with_same_parameters_different_action(self):
-        """
-        it's acceptable to create same rules with different filter in pipeline mode.
-        """
-
-        # start testpmd in pipeline mode
-        command = (
-            self.path
-            + '-c %s -n 4 -a %s,pipeline-mode-support=1 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10'
-            % (
-                self.coreMask,
-                self.dut.ports_info[0]["pci"],
-                utils.create_mask([self.dut_ports[0]]),
-            )
-        )
-        out = self.dut.send_expect(command, "testpmd> ", 120)
-
-        self.dut.send_expect("set fwd rxonly", "testpmd> ", 15)
-        self.dut.send_expect("set verbose 1", "testpmd> ", 15)
-
-        # create rules with same parameters but different action
-        out = self.dut.send_expect(
-            "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 1 / end",
-            "testpmd>",
-            15,
-        )
-        self.verify(
-            "Successed" and "(2)" in out, "failed: switch rule can't be created"
-        )
-        out = self.dut.send_expect(
-            "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 3 / end",
-            "testpmd>",
-            15,
-        )
-        self.verify("Successed" and "(1)" in out, "failed: fdir rule can't be created")
-
-        # send a pkt to check the switch rule is work for its high priority
-        self.dut.send_expect("start", "testpmd>", 20)
-        a = self.check_link()
-        self.verify(a, "failed: link can not up")
-
-        self.send_pkt(
-            'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:01")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)],iface="%s")'
-            % (self.__tx_iface)
-        )
-        out = self.dut.send_expect("stop", "testpmd>", 20)
-        pkt_num = self.check_queue_rx_packets_number(out, 1)
-        self.verify(pkt_num == 1, "failed: the flow rule can not work")
-        self.logger.info("pass: queue id is 1")
-
-        # remove the switch rule and check the fdir rule is work
-        self.dut.send_expect("flow destroy 0 rule 0", "testpmd>", 15)
-        self.dut.send_expect("start", "testpmd>", 20)
-        self.send_pkt(
-            'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:02")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)],iface="%s")'
-            % (self.__tx_iface)
-        )
-        out = self.dut.send_expect("stop", "testpmd>", 20)
-        pkt_num = self.check_queue_rx_packets_number(out, 3)
-        self.verify(pkt_num == 1, "failed: the flow rule can not work")
-        self.logger.info("pass: queue id is 3")
-
-        self.dut.send_expect("flow flush 0", "testpmd>", 15)
-        self.dut.send_expect("quit", "#", 50)
-
-        # restart testpmd in pipeline mode
-        command = (
-            self.path
-            + '-c %s -n 4 -a %s,pipeline-mode-support=1 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10'
-            % (
-                self.coreMask,
-                self.dut.ports_info[0]["pci"],
-                utils.create_mask([self.dut_ports[0]]),
-            )
-        )
-        out = self.dut.send_expect(command, "testpmd> ", 120)
-        self.logger.debug(out)
-
-        self.dut.send_expect("set fwd rxonly", "testpmd> ", 15)
-        self.dut.send_expect("set verbose 1", "testpmd> ", 15)
-
-        # create rules with same parameters but different action
-        out = self.dut.send_expect(
-            "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 3 / end",
-            "testpmd>",
-            15,
-        )
-        self.verify("Successed" and "(1)" in out, "failed: fdir rule can't be created")
-        out = self.dut.send_expect(
-            "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 1 / end",
-            "testpmd>",
-            15,
-        )
-        self.verify(
-            "Successed" and "(2)" in out, "failed: switch rule can't be created"
-        )
-
-        # send a pkt to check the switch rule is work for its high priority
-        self.dut.send_expect("start", "testpmd>", 20)
-        a = self.check_link()
-        self.verify(a, "failed: link can not up")
-        self.send_pkt(
-            'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:01")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)],iface="%s")'
-            % (self.__tx_iface)
-        )
-        out = self.dut.send_expect("stop", "testpmd>", 20)
-        pkt_num = self.check_queue_rx_packets_number(out, 1)
-        self.verify(pkt_num == 1, "failed: the flow rule can not work")
-        self.logger.info("pass: queue id is 1")
-
-        # remove the switch rule and check the fdir rule is work
-        self.dut.send_expect("flow destroy 0 rule 1", "testpmd>", 15)
-        self.dut.send_expect("start", "testpmd>", 20)
-        self.send_pkt(
-            'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:02")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)],iface="%s")'
-            % (self.__tx_iface)
-        )
-        out = self.dut.send_expect("stop", "testpmd>", 20)
-        pkt_num = self.check_queue_rx_packets_number(out, 3)
-        self.verify(pkt_num == 1, "failed: the flow rule can not work")
-        self.logger.info("pass: queue id is 3")
-
-        self.dut.send_expect("flow flush 0", "testpmd>", 20)
-        self.dut.send_expect("quit", "#", 50)
-
-    #
-    ###########################################################################
-
-    def tear_down_all(self):
-        pass
-
-    def tear_down(self):
-        self.dut.kill_all()
