[v2,1/7] rte flow: add test plan and test suite
diff mbox series

Message ID 20201023232903.37387-1-ohilyard@iol.unh.edu
State Accepted
Headers show
Series
  • [v2,1/7] rte flow: add test plan and test suite
Related show

Commit Message

Owen Hilyard Oct. 23, 2020, 11:28 p.m. UTC
These are the base test plan and test suite files. Their function is heavily dependent on the following patches due to the runtime generation of test cases to avoid maintainability issues.

Signed-off-by: Owen Hilyard <ohilyard@iol.unh.edu>
---
 test_plans/rte_flow_test_plan.rst | 4114 +++++++++++++++++++++++++++++
 tests/TestSuite_rte_flow.py       |  232 ++
 2 files changed, 4346 insertions(+)
 create mode 100644 test_plans/rte_flow_test_plan.rst
 create mode 100644 tests/TestSuite_rte_flow.py

Comments

Tu, Lijuan Oct. 27, 2020, 5:07 a.m. UTC | #1
> These are the base test plan and test suite files. Their function is heavily
> dependent on the following patches due to the runtime generation of test cases
> to avoid maintainability issues.
> 
> Signed-off-by: Owen Hilyard <ohilyard@iol.unh.edu>

Applied the series, thanks

Patch
diff mbox series

diff --git a/test_plans/rte_flow_test_plan.rst b/test_plans/rte_flow_test_plan.rst
new file mode 100644
index 0000000..b53f64b
--- /dev/null
+++ b/test_plans/rte_flow_test_plan.rst
@@ -0,0 +1,4114 @@ 
+.. # BSD LICENSE
+    #
+    # Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
+    # Copyright © 2018[, 2020] The University of New Hampshire. All rights reserved.
+    # All rights reserved.
+    #
+    # Redistribution and use in source and binary forms, with or without
+    # modification, are permitted provided that the following conditions
+    # are met:
+    #
+    #   * Redistributions of source code must retain the above copyright
+    #     notice, this list of conditions and the following disclaimer.
+    #   * Redistributions in binary form must reproduce the above copyright
+    #     notice, this list of conditions and the following disclaimer in
+    #     the documentation and/or other materials provided with the
+    #     distribution.
+    #   * Neither the name of Intel Corporation nor the names of its
+    #     contributors may be used to endorse or promote products derived
+    #     from this software without specific prior written permission.
+    #
+    # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+rte_flow Tests
+========================================
+This document contains the test plan for the rte_flow API.
+
+Prerequisites
+=============
+The DUT must have one 10G Ethernet ports connected to one port on
+Tester that are controlled by packet generator::
+
+    dut_port_0 <---> tester_port_0
+
+Assume the DUT 10G Ethernet ports' pci device id is as the following::
+
+    dut_port_0 : "0000:05:00.0"
+    mac_address: "00:00:00:00:01:00"
+
+Bind the port to dpdk igb_uio driver::
+
+    ./usertools/dpdk-devbind.py -b igb_uio 05:00.0
+
+You will also need to have Python 3.6 installed along with scapy to create test packets.
+
+Pattern Item and Property Tests
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+We create a flow rule for each property in each pattern item. We then send one packet that is expected to pass,
+and about four packets that are expected to fail.
+
+We only test one pattern item and one property at a time.
+
+Flow rules are created using **testpmd** and packets are created/sent using **scapy**.
+
+NOTE: Some pattern items and properties could not be tested
+due to the fact that testpmd does not support them. See **dpdk-dts/test_plans/unsupported.rst**
+for a listing of these items and properties.
+
+Item: ETH
+~~~~~~~~~
+
+
+Test Case: dst (destination MAC) rule
+-------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+.. 
+
+2. Set the test flow rule (If the Ethernet destination MAC is equal to 90:61:ae:fd:41:43, send the packet to queue 1):
+
+::
+
+    flow create 0 ingress pattern eth dst is 90:61:ae:fd:41:43 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether(dst="90:61:ae:fd:41:43") / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+           Pkt1 = Ether(dst=\"90:61:ae:fd:41:44") / ('\\x00' * 64)
+           Pkt2 = Ether(dst=\"90:61:ae:fd:41:45") / ('\\x00' * 64)
+           Pkt3 = Ether(dst=\"90:61:ae:fd:41:46") / ('\\x00' * 64)
+           Pkt4 = Ether(dst=\"91:61:ae:fd:41:43") / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Test Case: src (source MAC) rule
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the Ethernet source MAC is equal to 90:61:ae:fd:41:43, send the packet to queue 1)
+
+::
+
+    flow create 0 ingress pattern eth src is 90:61:ae:fd:41:43 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether(dst="90:61:ae:fd:41:43") / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+            Pkt1 = Ether(dst=\"90:61:ae:fd:41:44") / ('\\x00' * 64)
+            Pkt2 = Ether(dst=\"90:61:ae:fd:41:45") / ('\\x00' * 64)
+            Pkt3 = Ether(dst=\"90:61:ae:fd:41:46") / ('\\x00' * 64)
+            Pkt4 = Ether(dst=\"91:61:ae:fd:41:43") / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Test Case: type (EtherType or TPID) rule
+-----------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the Ethernet type is 0x0800, send the packet to queue 1):
+
+::
+
+    flow create 0 ingress pattern eth type is 0x0800 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule: 
+
+::
+
+            Pkt0 = Ether(type=0x0800) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+            Pkt1 = Ether(type=0x0842) / ('\\x00' * 64)
+            Pkt2 = Ether(type=0x8100) / ('\\x00' * 64)
+            Pkt3 = Ether(type=0x9100) / ('\\x00' * 64)
+            Pkt4 = Ether(type=0x8863) / ('\\x00' * 64)
+            Pkt5 = Ether(type=0x9000) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Item: GRE
+~~~~~~~~~
+
+Test Case: protocol (protocol type) rule
+-----------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the GRE protocol is equal to 0x0800,send the packet to queue 1) :
+
+::
+
+
+    flow create 0 ingress pattern gre protocol is 0x0800 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule: 
+
+::
+
+            Pkt0 = Ether() / GRE(proto=0x0800) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+            Pkt1 = Ether() / GRE(proto=0x0842) / ('\\x00' * 64)
+            Pkt2 = Ether() / GRE(proto=0x8100) / ('\\x00' * 64)
+            Pkt3 = Ether() / GRE(proto=0x0806) / ('\\x00' * 64)
+            Pkt4 = Ether() / GRE(proto=0x809B) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Item: ICMP
+~~~~~~~~~~
+
+Test Case: icmp_type (ICMP message type) rule
+----------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the ICMP type is 3, send the packet to queue 1) :
+
+::
+
+
+    flow create 0 ingress pattern icmp type is 3 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule: 
+
+::
+
+            Pkt0 = Ether() / ICMP(type=3) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+            Pkt1 = Ether() / ICMP(type=3) / ('\\x00' * 64)
+            Pkt2 = Ether() / ICMP(type=13) / ('\\x00' * 64)
+            Pkt3 = Ether() / ICMP(type=11) / ('\\x00' * 64)
+            Pkt4 = Ether() / ICMP(type=12) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Test Case: icmp_code (ICMP message code) rule
+-----------------------------------------------
+
+NOTE: ICMP code meaning is dependent on type.
+We tested type 3, code 3.
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the ICMP type is 3 and the ICMP code is 3, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern icmp type is 3 code is 3 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule: 
+
+::
+
+ Pkt0 = Ether() / ICMP(type=3, code=3) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / ICMP(type=3, code=3) / ('\\x00' * 64)
+    Pkt2 = Ether() / ICMP(type=3, code=0) / ('\\x00' * 64)
+    Pkt3 = Ether() / ICMP(type=11, code=1) / ('\\x00' * 64)
+    Pkt4 = Ether() / ICMP(type=12, code=2) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Item: IPv4
+~~~~~~~~~~~
+
+Test Case: tos (Type of Service) rule
+----------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 type of service is 0, send the packet to queue 1) :
+
+::
+
+
+    flow create 0 ingress pattern ipv4 tos is 0 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(tos=0) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(tos=2) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(tos=4) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(tos=8) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(tos=16) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Test Case: ttl (time to live) rule
+-------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 packet's time to live is 64, send the packet to queue 1) :
+
+::
+
+
+   flow create 0 ingress pattern ipv4 ttl is 64 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(ttl=64) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+   Pkt1 = Ether() / IP(ttl=128) / ('\\x00' * 64)
+   Pkt2 = Ether() / IP(ttl=255) / ('\\x00' * 64)
+   Pkt3 = Ether() / IP(ttl=32) / ('\\x00' * 64)
+   Pkt4 = Ether() / IP(ttl=100) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Test Case: proto (IPv4 protocol) rule
+----------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 protocol is 0x06, send the packet to queue 1) :
+
+::
+
+ flow create 0 ingress pattern ipv4 proto is 0x06 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(proto=0x06) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+   Pkt1 = Ether() / IP(proto=0x01) / ('\\x00' * 64)
+   Pkt2 = Ether() / IP(proto=0x11) / ('\\x00' * 64)
+   Pkt3 = Ether() / IP(proto=0x12) / ('\\x00' * 64)
+   Pkt4 = Ether() / IP(proto=0x58) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Test Case: src (IPv4 source) rule
+------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.5, send the packet to queue 1) :
+
+::
+
+   flow create 0 ingress pattern ipv4 src is 192.168.0.5 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=192.168.0.5) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=10.10.10.10) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=132.177.127.6) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=192.168.0.4) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=192.168.0.250) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Test Case: dst (IPv4 destination) rule
+------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 destination is 192.168.0.5, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern ipv4 dst is 192.168.0.5 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=192.168.0.5) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(dst=10.10.10.10) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(dst=132.177.127.6) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(dst=192.168.0.4) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(dst=192.168.0.250) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Item: IPv6
+~~~~~~~~~~~
+
+Test Case: tc (Traffic Class) rule
+------------------------------------
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv6 traffic class is 0, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern ipv6 tc is 0 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IPv6(tc=0) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IPv6(tc=1) / ('\\x00' * 64)
+    Pkt2 = Ether() / IPv6(tc=2) / ('\\x00' * 64)
+    Pkt3 = Ether() / IPv6(tc=4) / ('\\x00' * 64)
+    Pkt4 = Ether() / IPv6(tc=6) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Test Case: flow (Flow Code) rule
+--------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv6 flow code is 0xABCD, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern ipv6 flow is 0xABCD / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IPv6(fl=0xABCD) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+   Pkt1 = Ether() / IPv6(fl=0xABCE) / ('\\x00' * 64)
+   Pkt2 = Ether() / IPv6(fl=0x0001) / ('\\x00' * 64)
+   Pkt3 = Ether() / IPv6(fl=0xFFFF) / ('\\x00' * 64)
+   Pkt4 = Ether() / IPv6(fl=0x1234) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Test Case: proto (IPv6 protocol/next header protocol) rule
+--------------------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv6 protocol is 0x06, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern ipv6 proto is 0x06 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IPv6(nh=6) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+   Pkt1 = Ether() / IPv6(nh=17) / ('\\x00' * 64)
+   Pkt2 = Ether() / IPv6(nh=41) / ('\\x00' * 64)
+   Pkt3 = Ether() / IPv6(nh=0) / ('\\x00' * 64)
+   Pkt4 = Ether() / IPv6(nh=60) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Test Case: hop (Hop Limit) rule
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv6 hop limit is 64, send the packet to queue 1) :
+::
+
+    flow create 0 ingress pattern ipv6 hop is 64 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IPv6(hlim=64) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+   Pkt1 = Ether() / IPv6(hlim=128) / ('\\x00' * 64)
+   Pkt2 = Ether() / IPv6(hlim=32) / ('\\x00' * 64)
+   Pkt3 = Ether() / IPv6(hlim=255) / ('\\x00' * 64)
+   Pkt4 = Ether() / IPv6(hlim=100) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Test Case: dst (IPv6 destination) rule
+---------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv6 destination is 2001:...:b1c2, send the packet to queue 1) :
+
+::
+
+   flow create 0 ingress pattern ipv6 dst is 2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c2 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IPv6(dst=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c2\") / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IPv6(dst=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c3\") / ('\\x00' * 64)
+    Pkt2 = Ether() / IPv6(dst=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c4\") / ('\\x00' * 64)
+    Pkt3 = Ether() / IPv6(dst=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c5\") / ('\\x00' * 64)
+    Pkt4 = Ether() / IPv6(dst=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c6\") / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Test Case: src (IPv6 source) rule
+-----------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv6 destination is 2001:...b1c2, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern ipv6 src is 2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c2 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c2\") / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c3\") / ('\\x00' * 64)
+    Pkt2 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c4\") / ('\\x00' * 64)
+    Pkt3 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c5\") / ('\\x00' * 64)
+    Pkt4 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c6\") / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Item: SCTP
+~~~~~~~~~~~
+
+Test Case: src (source port) rule
+-------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the SCTP source port is 3838, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern sctp src is 3838 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP() / SCTP(sport=3838) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP() / SCTP(sport=3939) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP() / SCTP(sport=5000) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP() / SCTP(sport=1998) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP() / SCTP(sport=1028) / ('\\x00' * 64)
+
+..
+
+Test Case: dst (destination port) rule
+-----------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the SCTP destination port is 3838, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern sctp dst is 3838 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP() / SCTP(dport=3838) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP() / SCTP(dport=3939) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP() / SCTP(dport=5000) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP() / SCTP(dport=1998) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP() / SCTP(dport=1028) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Test Case: tag (SCTP header tag) rule
+--------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the SCTP tag is equal to 12345, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern sctp tag is 12345 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP() / SCTP(tag=12345) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+   Pkt1 = Ether() / IP() / SCTP(tag=12346) / ('\\x00' * 64)
+   Pkt2 = Ether() / IP() / SCTP(tag=12) / ('\\x00' * 64)
+   Pkt3 = Ether() / IP() / SCTP(tag=9999) / ('\\x00' * 64)
+   Pkt4 = Ether() / IP() / SCTP(tag=42) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Test Case: cksum (SCTP header checksum) rule
+-----------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the SCTP checksum is equal to 0x1535b67, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern sctp cksum is 0x01535b67 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP() / SCTP(chksum=0x01535b67)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+   Pkt1 = Ether() / IP() / SCTP(chksum=0x01535b68)
+   Pkt2 = Ether() / IP() / SCTP(chksum=0xdeadbeef)
+   Pkt3 = Ether() / IP() / SCTP(chksum=0x12345678)
+   Pkt4 = Ether() / IP() / SCTP(chksum=0x385030fe)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Item: TCP
+~~~~~~~~~~~
+
+Test Case: src (source port) rule
+--------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the TCP source port is equal to 3838, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern tcp src is 3838 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP() / TCP(sport=3838) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP() / TCP(sport=3939) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP() / TCP(sport=5000) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP() / TCP(sport=1998) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP() / TCP(sport=1028) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Test Case: dst (destination port) rule
+-----------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the TCP destination port is equal to 3838, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern tcp dst is 3838 / end actions queue index 1 / end
+
+..
+
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP() / TCP(dport=3838) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP() / TCP(dport=3939) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP() / TCP(dport=5000) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP() / TCP(dport=1998) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP() / TCP(dport=1028) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Test Case: flags (TCP flags) rule
+-----------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the TCP flags are equal to 0x02, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern tcp flags is 0x02 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP() / TCP(flags=0x02) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP() / TCP(flags=0x01) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP() / TCP(flags=0x04) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP() / TCP(flags=0x08) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP() / TCP(flags=0x10) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Item: UDP
+~~~~~~~~~~~
+
+Test Case: src (source port) rule
+-------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the UDP source port is equal to 3838, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern udp src is 3838 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+    Pkt0 = Ether() / IP() / UDP(sport=3838) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP() / UDP(sport=3939) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP() / UDP(sport=5000) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP() / UDP(sport=1998) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP() / UDP(sport=1028) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Test Case: dst (destination port) rule
+-----------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the UDP destination port is equal to 3838, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern udp dst is 3838 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP() / UDP(dport=3838) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP() / UDP(dport=3939) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP() / UDP(dport=5000) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP() / UDP(dport=1998) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP() / UDP(dport=1028) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Item: VLAN
+~~~~~~~~~~~
+
+Test Case: tci (Tag Control Information) rule
+-----------------------------------------------
+
+NOTE: The VLAN tci is the combination of the fields pcp, dei, and vid.
+We test them altogether as the tci and we test each field individually.
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the vlan tag control information value is 0xaaaa, send the packet to queue 1) :
+
+::
+
+
+    flow create 0 ingress pattern vlan tci is 0xaaaa / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / Dot1Q(prio = 0x0, id = 0x0, vlan = 0xbbb) / ('\\x00' * 64)
+    Pkt2 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xccc) / ('\\x00' * 64)
+    Pkt3 = Ether() / Dot1Q(prio = 0x5, id = 0x1, vlan = 0xaaa) / ('\\x00' * 64)
+    Pkt4 = Ether() / Dot1Q(prio = 0x4, id = 0x0, vlan = 0xaaa) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Test Case: pcp (Priority Code Point) rule
+--------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the VLAN priority code point is equal to 0x0, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern vlan pcp is 0x0 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / Dot1Q(prio=0x0) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / Dot1Q(prio=0x1) / ('\\x00' * 64)
+    Pkt2 = Ether() / Dot1Q(prio=0x2) / ('\\x00' * 64)
+    Pkt3 = Ether() / Dot1Q(prio=0x3) / ('\\x00' * 64)
+    Pkt4 = Ether() / Dot1Q(prio=0x7) / ('\\x00' * 64)
+
+..
+
+Test Case: dei (Drop Eligible Indicator) rule
+-----------------------------------------------
+NOTE: The only two possible values for dei are 0 and 1.
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the VLAN drop eligible indicator is equal to 0, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern vlan dei is 0 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / Dot1Q(id=0)) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / Dot1Q(id=1) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Test Case: vid (VLAN identifier) rule
+-----------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the VLAN identifier is equal to 0xabc, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern vlan vid is 0xabc / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / Dot1Q(vlan=0xabc) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / Dot1Q(vlan=0xaaa) / ('\\x00' * 64)
+    Pkt2 = Ether() / Dot1Q(vlan=0x123) / ('\\x00' * 64)
+    Pkt3 = Ether() / Dot1Q(vlan=0x1f5) / ('\\x00' * 64)
+    Pkt4 = Ether() / Dot1Q(vlan=0x999) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Test Case: tpid (Tag Protocol Identifier) rule
+--------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the VLAN tag protocol identifier is equal to 0x8100, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern vlan tpid is 0x8100 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / Dot1Q(type=0x8100) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / Dot1Q(type=0x0800) / ('\\x00' * 64)
+    Pkt2 = Ether() / Dot1Q(type=0x0842) / ('\\x00' * 64)
+    Pkt3 = Ether() / Dot1Q(type=0x809b) / ('\\x00' * 64)
+    Pkt4 = Ether() / Dot1Q(type=0x86dd) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+
+Item: VXLAN
+~~~~~~~~~~~
+
+Test Case: vni (VXLAN network identifier) rule
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the VXLAN network identifier is equal to 0x112233, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern vxlan vni is 0x112233 / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP() / VXLAN(vni=0x112233) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP() / VXLAN(vni=0x112234) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP() / VXLAN(vni=0x123456) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP() / VXLAN(vni=0xaabbcc) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP() / VXLAN(vni=0x999999) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that only the pass packet was received by queue 1.
+
+Action Item Tests
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+We create a simple flow rule that filters packets by matching IPv4 address (more rules are sometimes applied
+depending on the action being tested). We then send one packet that is expected to pass,
+and about four packets that are expected to fail. We check if the packet that is expected to pass
+has the action we are testing applied to it.
+
+We only test one action and one of the action's properties at a time, unless one property requires the context
+of another.
+
+Flow rules are created using **testpmd** and packets are created/sent using **scapy**.
+
+NOTE: NVGRE_ENCAP and NVGRE_DECAP could not be tested at this time because Scapy does not support NVGRE.
+
+We did not create an RSS test suite because one has already been created.
+
+
+Action: PASSTHRU
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: passthru test
+------------------------------------------------
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, let the packet pass through) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions passthru / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet was allowed to pass through.
+
+Action: FLAG
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: flag test
+------------------------------------------------
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, flag the packet) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions flag / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet was flagged.
+
+Action: DROP
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: drop test
+------------------------------------------------
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, drop the packet) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions drop / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet was dropped.
+
+Action: COUNT
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: test_shared
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, add unshared counter action with id of 1) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions count shared 0 id 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has a counter action added to it.
+
+Test Case: test_id
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, add counter action with id of 1) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions count id 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has a counter action added to it.
+
+Action: MAC_SWAP
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: mac_swap test
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, swap dst and src MAC addresses) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions mac_swap / end
+
+..
+
+3. Send a packet that matches the rule, with defined src and dst MAC addresses:
+
+::
+
+    Pkt0 = Ether(src=\"90:61:ae:fd:41:43\", dst = \"ab:cd:ef:12:34:56\") / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with defined src and dst MAC addresses:
+
+::
+
+    Pkt1 = Ether(src=\"90:61:ae:fd:41:43\", dst = \"ab:cd:ef:12:34:56\") / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether(src=\"90:61:ae:fd:41:43\", dst = \"ab:cd:ef:12:34:56\") / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether(src=\"90:61:ae:fd:41:43\", dst = \"ab:cd:ef:12:34:56\") / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether(src=\"90:61:ae:fd:41:43\", dst = \"ab:cd:ef:12:34:56\") / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its source and destination MAC addresses swapped.
+
+Action: DEC_TTL
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: dec_ttl test
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, decrease its TTL) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions dec_ttl / end
+
+..
+
+3. Send a packet that matches the rule, with a defined ttl:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\", ttl = 128) / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with a defined ttl:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\", ttl = 128) / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its ttl reduced.
+
+Action: JUMP
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: jump test
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, redirect the packet to group 1) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions jump group 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been added to group 1 on the destination device.
+
+
+Action: MARK
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: mark test
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, mark the packet with an id of 0xABCDEF) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions mark id 0xABCDEF / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been marked with the correct id.
+
+Action: QUEUE
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: queue test
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, send the packet to queue 1) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions queue index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been added to queue 1.
+
+Action: PF
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: pf test
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, direct the packet to the physical function of the device) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions pf / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been directed to the physical function of the device.
+
+Action: VF
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: test_original
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, direct the packet to the original virtual function of the device) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions vf original / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been directed to the original virtual function of the device.
+
+Test Case: test_id
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, direct the packet to the virtual function of id 1) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions vf id 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been directed to the virtual function with the id of 1.
+
+
+Action: PHY_PORT
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: test_original
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, direct the packet to the original physical port of the device) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions phy_port original / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been directed to the original physical port of the device.
+
+Test Case: test_index
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, direct the packet to the physical port of index 1) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions phy_port index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been directed to the physical port of index 1.
+
+
+Action: PORT_ID
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: test_original
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, direct the packet to the original DPDK port ID) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions port_id original / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been directed to the original DPDK port ID of the device.
+
+Test Case: test_id
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, direct the packet to the DPDK port of id 1) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions port_id id 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been directed to the DPDK port of id 1.
+
+
+Action: METER
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: meter test
+------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, apply a MTR object with id 1) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions meter mtr_id 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had MTR object with id 1 applied to it.
+
+Action: SECURITY
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: security test
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, apply security session of id 1) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions security security_session 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had security session 1 applied to it.
+
+
+Action: OF_SET_MPLS_TTL
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: of_set_mpls_ttl test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, implement MPLS TTL with a value of 64) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions of_set_mpls_ttl mpls_ttl 64 / end
+
+..
+
+3. Send a packet that matches the rule, with an MPLS layer with assigned ttl:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with MPLS layers with assigned ttl:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its MPLS ttl defined as 64.
+
+Action: OF_DEC_MPLS_TTL
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: of_dec_mpls_ttl test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, decrement the MPLS ttl value) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions of_dec_mpls_ttl / end
+
+..
+
+3. Send a packet that matches the rule, with an MPLS layer with assigned ttl:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with MPLS layers with assigned ttl:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its MPLS ttl decremented.
+
+
+Action: OF_SET_NW_TTL
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: of_set_nw_ttl test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, implement IP TTL with a value of 64) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions of_set_nw_ttl nw_ttl 64 / end
+
+..
+
+3. Send a packet that matches the rule, with a defined TTL in the IP layer:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\", ttl=128)  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with a defined TTL in the IP layer:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\", ttl = 128) /  UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\", ttl = 128) / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its IP TTL defined as 64.
+
+
+Action: OF_DEC_NW_TTL
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: of_dec_nw_ttl test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, decrease the IP TTL) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions of_dec_nw_ttl / end
+
+..
+
+3. Send a packet that matches the rule, with a defined TTL in the IP layer:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\", ttl=128 )  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with a defined TTL in the IP layer:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\", ttl = 128) /  UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\", ttl = 128) / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its IP TTL decremented.
+
+Action: OF_COPY_TTL_OUT
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: of_copy_ttl_out test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, copy the TTL outwards) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions of_copy_ttl_out / end
+
+..
+
+3. Send a packet that matches the rule, with a defined TTL in the IP layer:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with a defined TTL in the IP layer:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\", ttl = 128) /  UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\", ttl = 128) / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its TTL copied outwards.
+
+Action: OF_COPY_TTL_IN
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: of_copy_ttl_in test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, copy the TTL inwards) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions of_copy_ttl_in / end
+
+..
+
+3. Send a packet that matches the rule, with a defined TTL in the IP layer:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with a defined TTL in the IP layer:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\", ttl = 128) /  UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\", ttl = 128) / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its TTL copied inwards.
+
+Action: OF_POP_VLAN
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: of_pop_vlan test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, pop the outer VLAN tag) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions of_pop_vlan / end
+
+..
+
+3. Send a packet that matches the rule, with a defined VLAN layer/tag:
+
+::
+
+    Pkt0 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with defined VLAN layers/tags:
+
+::
+
+    Pkt1 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"8.8.8.8\") /  UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its outer (only) VLAN tag popped.
+
+Action: OF_PUSH_VLAN
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: of_push_vlan test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, push a new VLAN tag with EtherType 0x8100) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions of_push_vlan ethertype 0x8100 / end
+
+..
+
+3. Send a packet that matches the rule, with a defined VLAN layer/tag:
+
+::
+
+    Pkt0 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with defined VLAN layers/tags:
+
+::
+
+    Pkt1 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"8.8.8.8\") /  UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had a VLAN tag with EtherType 0x8100 pushed onto it.
+
+Action: OF_SET_VLAN_VID
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+Test Case: of_set_vlan_vid test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the VLAN vid to 0xbbb):
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions of_set_vlan_vid 0xbbb / end
+
+..
+
+3. Send a packet that matches the rule, with a defined VLAN layer/tag:
+
+::
+
+    Pkt0 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with defined VLAN layers/tags:
+
+::
+
+    Pkt1 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"8.8.8.8\") /  UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its VLAN vid set to 0xbbb.
+
+Action: OF_SET_VLAN_PCP
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: of_set_vlan_pcp test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the VLAN pcp to 0x7):
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions of_set_vlan_pcp 0x7 / end
+
+..
+
+3. Send a packet that matches the rule, with a defined VLAN layer/tag:
+
+::
+
+    Pkt0 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with defined VLAN layers/tags:
+
+::
+
+    Pkt1 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"8.8.8.8\") /  UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / Dot1Q(prio = 0x5, id = 0x0, vlan = 0xaaa) / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its VLAN pcp set to 0x7.
+
+Action: OF_POP_MPLS
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: of_pop_mpls test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, pop the outer MPLS tag) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions of_pop_mpls / end
+
+..
+
+3. Send a packet that matches the rule, with a defined MPLS layer/tag:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with defined MPLS layers/tags:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") /  MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") /  MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") /  MPLS(label = 0xab, ttl=128) /  UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its outer (only) MPLS tag popped.
+
+Action: OF_PUSH_MPLS
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: of_push_mpls test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, push a new MPLS tag with EtherType 0x0806) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions of_push_mpls ethertype 0x0806 / end
+
+..
+
+3. Send a packet that matches the rule, with a defined MPLS layer/tag:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with defined MPLS layers/tags:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") /  MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") /  MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / MPLS(label = 0xab, ttl=128) / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") /  MPLS(label = 0xab, ttl=128) /  UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had an MPLS tag with EtherType 0x0806 pushed onto it.
+
+
+Action: VXLAN_ENCAP
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Test Case: vxlan_encap
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, encapsulate with a VXLAN tag with overlay definition (vni) 0x112233) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions vxlan_encap definition 0x112233 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") /  UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") /  UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") /  UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been encapsulated with a VXLAN tag with vni 0x112233.
+
+Action: VXLAN_DECAP
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: vxlan_decap
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, strip all VXLAN headers :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions vxlan_decap / end
+
+..
+
+3. Send a packet that matches the rule, with a VXLAN header:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\")  / UDP() / VXLAN() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with VXLAN headers:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") /  UDP() / VXLAN() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") /  UDP() / VXLAN() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / VXLAN() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / VXLAN()/  ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its VXLAN header stripped.
+
+Action: RAW_ENCAP
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: test_data
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, encapsulate with a VLAN tag with the header value 0x8100aaaa:
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions raw_encap data 0x8100aaaa / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been encapsulated with a VLAN tag with the header value 0x8100aaaa.
+
+Test Case: test_preserve
+---------------------------------
+
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1,
+encapsulate with a VLAN tag with the header value of 0x8100aaaa and a preserve bitmask of 0xffffffff:
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions raw_encap data 0x8100aaaa preserve 0xffffffff / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") /  UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been encapsulated with a VLAN tag with the header value 0x8100aaaa
+and has a preserve bitmask of 0xffffffff.
+
+Test Case: test_size
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1,
+encapsulate with a VLAN tag with the header value of 0x8100aaaa and a data (header) size of 32.
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions raw_encap data 0x8100aaaa size 32/ end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") /  UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been encapsulated with a VLAN tag with the header value 0x8100aaaa
+and has a size of 32.
+
+Action: RAW_DECAP
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: test_data
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, decapsulate a VLAN tag with the header value 0x8100aaaa:
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions raw_decap data 0x8100aaaa / end
+
+..
+
+3. Send a packet that matches the rule, with a matching VLAN header:
+
+::
+
+    Pkt0 = Ether() /  Dot1Q(prio = 0x5, id = 0x0, vlan = 0xbbb) / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with matching VLAN headers:
+
+::
+
+    Pkt1 = Ether() /  Dot1Q(prio = 0x5, id = 0x0, vlan = 0xbbb) / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() /  Dot1Q(prio = 0x5, id = 0x0, vlan = 0xbbb) / IP(src=\"10.0.30.99\") /  UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() /  Dot1Q(prio = 0x5, id = 0x0, vlan = 0xbbb) / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() /  Dot1Q(prio = 0x5, id = 0x0, vlan = 0xbbb) / IP(src=\"132.177.0.99\") /  UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its VLAN tag decapsulated.
+
+
+Test Case: test_size
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, decapsulate a VLAN tag with the header value 0x8100aaaa
+and header size of 32:
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions raw_decap data 0x8100aaaa size 32 / end
+
+..
+
+3. Send a packet that matches the rule, with a matching VLAN header:
+
+::
+
+    Pkt0 = Ether() /  Dot1Q(prio = 0x5, id = 0x0, vlan = 0xbbb) / IP(src=\"192.168.0.1\")  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with matching VLAN headers:
+
+::
+
+    Pkt1 = Ether() /  Dot1Q(prio = 0x5, id = 0x0, vlan = 0xbbb) / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() /  Dot1Q(prio = 0x5, id = 0x0, vlan = 0xbbb) / IP(src=\"10.0.30.99\") /  UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() /  Dot1Q(prio = 0x5, id = 0x0, vlan = 0xbbb) / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() /  Dot1Q(prio = 0x5, id = 0x0, vlan = 0xbbb) / IP(src=\"132.177.0.99\") /  UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its VLAN tag of size 32 decapsulated.
+
+Action: SET_IPV4_SRC
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: set_ipv4_src test
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the ipv4 src to 172.16.0.10) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions set_ipv4_src ipv4_addr 172.16.0.10 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its IPv4 source address set to 172.16.0.10.
+
+
+Action: SET_IPV4_DST
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: set_ipv4_dst test
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 destination is 192.168.0.1, set the ipv4 dst to 172.16.0.10) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 dst is 192.168.0.1 / udp / end actions set_ipv4_dst ipv4_addr 172.16.0.10 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(dst=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(dst=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(dst=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(dst=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(dst=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its IPv4 destination address set to 172.16.0.10.
+
+Action: SET_IPV6_SRC
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: set_ipv6_src test
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv6 source is 2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c2,
+set the ipv6 source to 2001:0000:9d38:6ab8:1c48:9999:aaaa:bbbb) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv6 src is 2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c2 / udp /
+    end actions set_ipv6_src ipv6_addr 2001:0000:9d38:6ab8:1c48:9999:aaaa:bbbb / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c2\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c3\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c4\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c5\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c6\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its IPv6 source address set to 2001:0000:9d38:6ab8:1c48:9999:aaaa:bbbb.
+
+Action: SET_IPV6_DST
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: set_ipv6_dst test
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv6 destination is 2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c2,
+set the ipv6 dst to 2001:0000:9d38:6ab8:1c48:9999:aaaa:bbbb) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv6 src is 2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c2 / udp /
+    end actions set_ipv6_dst ipv6_addr 2001:0000:9d38:6ab8:1c48:9999:aaaa:bbbb / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IPv6(dst=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c2\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IPv6(dst=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c3\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IPv6(dst=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c4\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IPv6(dst=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c5\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IPv6(dst=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c6\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its IPv6 destination address set to  2001:0000:9d38:6ab8:1c48:9999:aaaa:bbbb.
+
+Action: SET_TP_SRC
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: test_udp
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the tcp/udp source port to 1998:
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions set_tp_src 1998/ end
+
+..
+
+3. Send a packet that matches the rule with a defined UDP source port:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP(sport=3838) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule with defined UDP source ports:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP(sport=3838) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP(sport=3838) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP(sport=3838) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP(sport=3838) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its UDP source port set to 1998.
+
+Test Case: test_tcp
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the tcp/udp source port to 1998:
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / tcp / end actions set_tp_src 1998 / end
+
+..
+
+3. Send a packet that matches the rule with a defined TCP source port:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / TCP(sport=3838) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule with defined TCP source ports:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / TCP(sport=3838) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / TCP(sport=3838) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / TCP(sport=3838) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / TCP(sport=3838) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its TCP source port set to 1998.
+
+Action: SET_TP_DST
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+Test Case: test_udp
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 destination is 192.168.0.1, set the tcp/udp destination port to 1998:
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions set_tp_dst 1998/ end
+
+..
+
+3. Send a packet that matches the rule with a defined UDP destination port:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP(dport=3838) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule with defined UDP destination ports:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP(dport=3838) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP(dport=3838) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP(dport=3838) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP(dport=3838) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its UDP destination port set to 1998.
+
+Test Case: test_tcp
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the tcp/udp destination port to 1998:
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / tcp / end actions set_tp_dst 1998 / end
+
+..
+
+3. Send a packet that matches the rule with a defined TCP destination port:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / TCP(dport=3838) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule with defined TCP destination ports:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / TCP(dport=3838) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / TCP(dport=3838) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / TCP(dport=3838) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / TCP(dport=3838) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its TCP destination port set to 1998.
+Action: SET_TTL
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: set_ttl test
+---------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set TTL to a value of 64) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions set_ttl ttl_value 64 / end
+
+..
+
+3. Send a packet that matches the rule, with a defined TTL in the IP layer:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\", ttl=128)  / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with a defined TTL in the IP layer:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\", ttl = 128) / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\", ttl = 128) /  UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\", ttl = 128) / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its TTL defined as 64.
+
+Action: SET_MAC_SRC
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: set_mac_src test
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set MAC src to 10:20:30:40:50:60) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions set_mac_src mac_addr 10:20:30:40:50:60 / end
+
+..
+
+3. Send a packet that matches the rule, with a defined src MAC address:
+
+::
+
+    Pkt0 = Ether(src=\"90:61:ae:fd:41:43\") / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with defined src MAC addresses:
+
+::
+
+    Pkt1 = Ether(src=\"90:61:ae:fd:41:43\") / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether(src=\"90:61:ae:fd:41:43\" ) / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether(src=\"90:61:ae:fd:41:43\" ) / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether(src=\"90:61:ae:fd:41:43\" ) / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its source MAC address set to 10:20:30:40:50:60.
+
+Action: SET_MAC_DST
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: set_mac_dst test
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set MAC dst to 10:20:30:40:50:60) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions set_mac_dst mac_addr 10:20:30:40:50:60 / end
+
+..
+
+3. Send a packet that matches the rule, with a defined dst MAC address:
+
+::
+
+    Pkt0 = Ether(src=\"90:61:ae:fd:41:43\") / IP(dst =\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with defined dst MAC addresses:
+
+::
+
+    Pkt1 = Ether(dst=\"90:61:ae:fd:41:43\") / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether(dst=\"90:61:ae:fd:41:43\" ) / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether(dst=\"90:61:ae:fd:41:43\" ) / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether(dst=\"90:61:ae:fd:41:43\" ) / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its destination MAC address set to 10:20:30:40:50:60.
+
+Action: INC_TCP_SEQ
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: inc_tcp_seq test
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, increase the TCP seq value:
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / tcp / end actions inc_tcp_seq / end
+
+..
+
+3. Send a packet that matches the rule with a defined TCP seq value:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / TCP(seq=2) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule with defined TCP seq values:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / TCP(seq=2) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / TCP(seq=2) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / TCP(seq=2) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / TCP(seq=2) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its TCP seq value increased.
+
+Action: DEC_TCP_SEQ
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: dec_tcp_seq test
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, decrease the TCP seq value:
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / tcp / end actions dec_tcp_seq / end
+
+..
+
+3. Send a packet that matches the rule with a defined TCP seq value:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / TCP(seq=2) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule with defined TCP seq values:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / TCP(seq=2) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / TCP(seq=2) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / TCP(seq=2) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / TCP(seq=2) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its TCP seq value decreased.
+
+Action: INC_TCP_ACK
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: inc_tcp_ack test
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, increase the TCP ack value:
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / tcp / end actions inc_tcp_ack / end
+
+..
+
+3. Send a packet that matches the rule with a defined TCP ack value:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / TCP(ack=2) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule with defined TCP ack values:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / TCP(ack=2) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / TCP(ack=2) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / TCP(ack=2) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / TCP(ack=2) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its TCP ack value increased.
+
+Action: DEC_TCP_ACK
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: dec_tcp_ack test
+----------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, decrease the TCP ack value:
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / tcp / end actions dec_tcp_ack / end
+
+..
+
+3. Send a packet that matches the rule with a defined TCP ack value:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / TCP(ack=2) / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule with defined TCP ack values:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / TCP(ack=2) / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / TCP(ack=2) / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / TCP(ack=2) / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / TCP(ack=2) / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its TCP ack value decreased.
+
+Action: SET_TAG
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: test_data
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, tag the packet with the value 0xabc) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions set_tag data 0xabc / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been tagged with the correct data.
+
+Test Case: test_mask
+------------------------------------------------
+
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, tag the packet with the value 0xabc and mask 0xcba) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions set_tag data 0xabc mask 0xcba / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been tagged with the correct data and mask.
+
+
+Test Case: test_index
+------------------------------------------------
+
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the packet tag index 1 to the value 0xabc) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions set_tag data 0xabc index 1 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has been tagged with the correct data on the correct tag index.
+
+
+Action: SET_META
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: test_data
+------------------------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the packet's meta to the value 0xabc) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions set_meta data 0xabc / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had the correct metadata assigned to it.
+
+Test Case: test_mask
+------------------------------------------------
+
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the packet's meta to the value 0xabc and mask 0xcba):
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions set_meta data 0xabc mask 0xcba / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had the correct metadata and mask assigned to it.
+
+Action: SET_IPV4_DSCP
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: set_ipv4_dscp test
+-------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the IPv4 dscp (tos) to 2) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions set_ipv4_dscp 2 / end
+
+..
+
+3. Send a packet that matches the rule with a defined dscp (tos) value:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule with defined dscp (tos) values:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its IPv4 dscp (tos) value set to 2.
+
+
+Action: SET_IPV6_DSCP
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: set_ipv6_dscp test
+-------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv6 src is 2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c2, set its dscp (tc) value to 0x30):
+
+::
+
+    flow create 0 ingress pattern eth / ipv6 src is 2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c2 / udp /
+    end actions set_ipv6_dscp dscp 0x30 / end
+
+..
+
+3. Send a packet that matches the rule, with a defined dscp (tc) value:
+
+::
+
+    Pkt0 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c3\", tc=0) / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule, with defined dscp (tc) values:
+
+::
+
+    Pkt1 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c3\", tc=0) / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c4\", tc=0) / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c5\", tc=0) / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IPv6(src=\"2001:0000:9d38:6ab8:1c48:3a1c:a95a:b1c6\", tc=0) / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its dscp (tc) value set to 0x30.
+
+Action: AGE
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Test Case: test_timeout
+-------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the aging timeout value to 128) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions age timeout 128 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its aging timeout value set to 128.
+
+Test Case: test_reserved
+-------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the aging timeout value to 128 and reserved to 0) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions age timeout 128 reserved 0 / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its aging timeout value set to 128 and reserved bits set to 0.
+
+Test Case: test_context
+-------------------------------
+
+1. Run testpmd in interactive mode with one port bound and available:
+
+::
+
+    build/testpmd -c 3 -- -i
+
+..
+
+2. Set the test flow rule (If the IPv4 source is 192.168.0.1, set the aging timeout value to 128
+   and flow context to the rte_flow pointer) :
+
+::
+
+    flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions age timeout 128 context NULL / end
+
+..
+
+3. Send a packet that matches the rule:
+
+::
+
+    Pkt0 = Ether() / IP(src=\"192.168.0.1\") / UDP() / ('\\x00' * 64)
+
+..
+
+4. Send packets that do not match the rule:
+
+::
+
+    Pkt1 = Ether() / IP(src=\"192.168.0.2\") / UDP() / ('\\x00' * 64)
+    Pkt2 = Ether() / IP(src=\"10.0.30.99\") / UDP() / ('\\x00' * 64)
+    Pkt3 = Ether() / IP(src=\"8.8.8.8\") / UDP() / ('\\x00' * 64)
+    Pkt4 = Ether() / IP(src=\"132.177.0.99\") / UDP() / ('\\x00' * 64)
+
+..
+
+5. Check to make sure that the pass packet has had its aging timeout value set to 128 and its user flow context
+set to the rte_flow pointer.
+
+
+
+
+
+
diff --git a/tests/TestSuite_rte_flow.py b/tests/TestSuite_rte_flow.py
new file mode 100644
index 0000000..0cc9830
--- /dev/null
+++ b/tests/TestSuite_rte_flow.py
@@ -0,0 +1,232 @@ 
+# BSD LICENSE
+#
+# Copyright(c) 2020 Intel Corporation. All rights reserved.
+# Copyright © 2018[, 2019] The University of New Hampshire. All rights reserved.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+#   * Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in
+#     the documentation and/or other materials provided with the
+#     distribution.
+#   * Neither the name of Intel Corporation nor the names of its
+#     contributors may be used to endorse or promote products derived
+#     from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+DPDK Test suite.
+MTU Checks example.
+"""
+import time
+import ipaddress
+from typing import Callable
+
+import utils
+from pmd_output import PmdOutput
+from test_case import TestCase
+
+from test_case import TestCase
+
+from framework.flow import generator
+
+
+class RteFlow(TestCase):
+    #
+    #
+    # Helper methods and setup methods.
+    #
+    # Some of these methods may not be used because they were inlined from a child
+    # of TestCase. This was done because the current test system doesn't support
+    # inheritance.
+    #
+    def exec(self, command: str) -> str:
+        """
+        An abstraction to remove repeated code throughout the subclasses of this class
+        """
+        return self.dut.send_expect(command, "testpmd>")
+
+    def get_mac_address_for_port(self, port_id: int) -> str:
+        return self.dut.get_mac_address(port_id)
+
+    def send_scapy_packet(self, port_id: int, packet: str):
+        itf = self.tester.get_interface(port_id)
+        return self.tester.send_expect(f'sendp({packet}, iface="{itf}")', ">>>", timeout=30)
+
+    def set_up_all(self):
+        """
+        Prerequisite steps for each test suit.
+        """
+        self.dut_ports = self.dut.get_ports()
+        self.verify(len(self.dut_ports) >= 2, "Insufficient ports")
+        self.rx_port = self.dut_ports[0]
+        self.tx_port = self.dut_ports[1]
+
+        self.pmdout = PmdOutput(self.dut)
+        self.pmdout.start_testpmd("default", "--rxq 2 --txq 2")
+        self.exec("set verbose 3")
+        self.exec("set fwd rxonly")
+        self.tester.send_expect("scapy", ">>>")
+
+    def initialize_flow_rule(self, rule: str):
+        output: str = self.exec(f"flow validate {self.dut_ports[0]} {rule}")
+        if "Unsupported pattern" in output:
+            return False
+
+        output = self.exec(f"flow create {self.dut_ports[0]} {rule}")
+        self.verify("created" in output or "Flow rule validated" in output, "Flow rule was not created: " + output)
+        return True
+
+    def send_packets(self, packets, pass_fail_function: Callable[[str], bool], error_message: str):
+        for packet in packets:
+            output = self.send_scapy_packet(0, packet)
+            time.sleep(5)  # Allow the packet to be processed
+            self.verify("Sent" in output, "Broken scapy packet definition: " + packet)
+            output = self.pmdout.get_output()
+            self.verify(pass_fail_function(output),
+                        error_message + "\r\n" + output)
+
+    def do_test_with_callable_tests_for_pass_fail(self, rule: str, pass_packets: frozenset, fail_packets: frozenset,
+                                                  pass_check_function: Callable[[str], bool],
+                                                  fail_check_function: Callable[[str], bool],
+                                                  error_message: str):
+        was_valid: bool = self.initialize_flow_rule(rule)
+        if not was_valid:  # If a PMD rejects a test case, we let it pass
+            return None
+
+        self.exec("start")
+        self.send_packets(pass_packets, pass_check_function, error_message)
+        self.send_packets(fail_packets, fail_check_function, error_message)
+
+    def do_test_with_expected_strings_for_pass_fail(self, rule: str, pass_packets: frozenset,
+                                                    fail_packets: frozenset,
+                                                    pass_expect: str, fail_expect: str, error_message: str):
+        self.do_test_with_callable_tests_for_pass_fail(rule, pass_packets, fail_packets,
+                                                       lambda output: pass_expect in output,
+                                                       lambda output: fail_expect in output,
+                                                       error_message)
+
+    def do_test_with_queue_action(self, rule: str, pass_packets: frozenset, fail_packets: frozenset):
+        self.do_test_with_expected_strings_for_pass_fail(rule, pass_packets, fail_packets,
+                                                         f"port {self.dut_ports[0]}/queue 1",
+                                                         f"port {self.dut_ports[0]}/queue 0",
+                                                         "Error: packet went to the wrong queue")
+
+    def set_up(self):
+        """
+        This is to clear up environment before the case run.
+        """
+
+    def tear_down(self):
+        """
+        Run after each test case.
+        """
+        self.exec(f"flow flush {self.dut_ports[0]}")
+        self.exec("stop")
+
+    def tear_down_all(self):
+        """
+        When the case of this test suite finished, the environment should
+        clear up.
+        """
+        self.tester.send_expect("exit()", "#")
+        self.dut.kill_all()
+        self.tester.kill_all()
+
+    """
+    Edge Cases
+    
+    These are tests which are designed to deal with edge cases.
+    """
+
+    def test_excessive_voids(self):
+        """
+        This test puts far, far too many void tokens in an otherwise valid
+        pattern. This may cause a crash or other issue, due to buffer size
+        constraints or other limits inside of either the parser or the nic.
+        """
+        self.do_test_with_queue_action(
+            "ingress pattern eth / ipv4 / " + (
+                    "void / " * 200) + "udp / end actions queue index 1 / end",
+            frozenset({'Ether() / IP() / UDP() / (\'\\x00\' * 64)'}),
+            frozenset({
+                'Ether() / IP() / TCP() / (\'\\x00\' * 64)',
+                'Ether() / IP() / SCTP() / (\'\\x00\' * 64)',
+                'Ether() / IPv6() / UDP() / (\'\\x00\' * 64)',
+            })
+        )
+
+    def test_excessive_tunneling(self):
+        self.do_test_with_queue_action(
+            "ingress pattern " + ("eth / gre / " * 20) + "eth / ipv4 / udp / end actions queue index 1 / end",
+            frozenset({'Ether() / IP() / UDP() / (\'\\x00\' * 64)'}),
+            frozenset({
+                'Ether() / IP() / TCP() / (\'\\x00\' * 64)',
+                'Ether() / IP() / SCTP() / (\'\\x00\' * 64)',
+                'Ether() / IPv6() / UDP() / (\'\\x00\' * 64)',
+            })
+        )
+
+    """
+    Action Test Cases
+    
+    These are test cases built for testing various actions
+    """
+
+    def test_drop_case1(self):
+        self.do_test_with_callable_tests_for_pass_fail(
+            "ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions drop / end",
+            frozenset({'Ether() / IP(src="192.168.0.1") / UDP() / (\'\\x00\' * 64)'}),
+            frozenset({'Ether() / IP(src="10.0.30.99") / UDP() / (\'\\x00\' * 64)',
+                       'Ether() / IP(src="132.177.0.99") / UDP() / (\'\\x00\' * 64)',
+                       'Ether() / IP(src="192.168.0.2") / UDP() / (\'\\x00\' * 64)',
+                       'Ether() / IP(src="8.8.8.8") / UDP() / (\'\\x00\' * 64)'}),
+            lambda output: "port" not in output,
+            lambda output: "port" in output,
+            "Drop function was not correctly applied")
+
+    def test_queue_case1(self):
+        self.do_test_with_queue_action(
+            "ingress pattern eth / ipv4 src is 192.168.0.1 / udp / end actions queue index 1 / end",
+            frozenset({'Ether() / IP(src="192.168.0.1") / UDP() / (\'\\x00\' * 64)'}), frozenset(
+                {'Ether() / IP(src="10.0.30.99") / UDP() / (\'\\x00\' * 64)',
+                 'Ether() / IP(src="132.177.0.99") / UDP() / (\'\\x00\' * 64)',
+                 'Ether() / IP(src="192.168.0.2") / UDP() / (\'\\x00\' * 64)',
+                 'Ether() / IP(src="8.8.8.8") / UDP() / (\'\\x00\' * 64)'}))
+
+
+def do_runtime_test_generation():
+    """
+    There are enough tests for this suite that it presents a maintainability
+    issue to keep using the generator manually, so this approach is designed
+    """
+    print("Generating test cases for RTE Flow test suite.")
+    pattern_functions = generator.create_test_function_strings(generator.get_patterns_with_properties())
+
+    pattern_function_string = "\n".join(pattern_functions)
+    exec(pattern_function_string)
+
+    # Copy it because a for loop creates local variables, which changes the dict at runtime.
+    locals_copy = filter(lambda name_function_tuple: name_function_tuple[0].startswith("test_"), locals().items())
+
+    for name, function in locals_copy:
+        setattr(RteFlow, name, function)
+
+
+do_runtime_test_generation()