test suite reviews and discussions
 help / color / mirror / Atom feed
* [dts] [PATCH V2 1/2] tests/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp: add new cases according to testplan
@ 2023-01-04 10:02 Song Jiale
  2023-01-04 10:02 ` [dts] [PATCH V2 2/2] test_plans/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp: add 9 subcase Song Jiale
  0 siblings, 1 reply; 3+ messages in thread
From: Song Jiale @ 2023-01-04 10:02 UTC (permalink / raw)
  To: dts; +Cc: Song Jiale

add 9 subcases according to testplan.

Signed-off-by: Song Jiale <songx.jiale@intel.com>
---

v2:
-add comment

 ...advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp.py | 835 ++++++++++++++++--
 1 file changed, 737 insertions(+), 98 deletions(-)

diff --git a/tests/TestSuite_ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp.py b/tests/TestSuite_ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp.py
index 0c24188a..90e441d4 100644
--- a/tests/TestSuite_ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp.py
+++ b/tests/TestSuite_ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp.py
@@ -55,6 +55,8 @@ mac_ipv4_pfcp_session = {
             "send_packet": mac_ipv4_pfcp_session_packets["match"][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
         #     'send_packet': [i for i in mac_ipv4_pfcp_session_packets['mismatch']],
         #     'action': 'check_no_hash_or_different',
@@ -105,6 +107,8 @@ mac_ipv6_pfcp_session = {
             "send_packet": mac_ipv6_pfcp_session_packets["match"][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
         #     'send_packet': [i for i in mac_ipv6_pfcp_session_packets['mismatch']],
         #     'action': 'check_no_hash_or_different',
@@ -155,6 +159,8 @@ mac_ipv4_l2tpv3 = {
             "send_packet": mac_ipv4_l2tpv3_packets["match"][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
         #     'send_packet': [i for i in mac_ipv4_l2tpv3_packets['mismatch']],
         #     'action': 'check_no_hash_or_different',
@@ -205,6 +211,8 @@ mac_ipv6_l2tpv3 = {
             "send_packet": mac_ipv6_l2tpv3_packets["match"][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
         #     'send_packet': [i for i in mac_ipv6_l2tpv3_packets['mismatch']],
         #     'action': 'check_no_hash_or_different',
@@ -255,6 +263,8 @@ mac_ipv4_esp = {
             "send_packet": mac_ipv4_esp_packets["match"][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
         #     'send_packet': [
         #         i for i in mac_ipv4_esp_packets['mismatch']],
@@ -309,6 +319,8 @@ mac_ipv4_udp_esp = {
             "send_packet": mac_ipv4_udp_esp_packets["match"][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
         #     'send_packet': [i for i in mac_ipv4_udp_esp_packets['mismatch']],
         #     'action': 'check_no_hash_or_different',
@@ -359,6 +371,8 @@ mac_ipv6_esp = {
             "send_packet": mac_ipv6_esp_packets["match"][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
         #     'send_packet': [i for i in mac_ipv6_esp_packets['mismatch']],
         #     'action': 'check_no_hash_or_different',
@@ -412,6 +426,8 @@ mac_ipv6_udp_esp = {
             "send_packet": mac_ipv6_udp_esp_packets["match"][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
         #     'send_packet': [i for i in mac_ipv6_udp_esp_packets['mismatch']],
         #     'action': 'check_no_hash_or_different',
@@ -462,6 +478,8 @@ mac_ipv4_ah = {
             "send_packet": mac_ipv4_ah_packets["match"][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
         #     'send_packet': mac_ipv4_ah_packets['mismatch'],
         #     'action': 'check_no_hash_or_different',
@@ -512,6 +530,8 @@ mac_ipv6_ah = {
             "send_packet": mac_ipv6_ah_packets["match"][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
         #     'send_packet': [i for i in mac_ipv6_ah_packets['mismatch']],
         #     'action': 'check_no_hash_or_different',
@@ -523,9 +543,9 @@ mac_ipv6_ah = {
     ],
 }
 
-mac_vlan_ipv4_pay_packets = {
+mac_vlan_ipv4_vlan_packets = {
     "match": {
-        "mac_vlan_ipv4_pay": [
+        "mac_vlan_ipv4_vlan": [
             'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/Raw("x" * 80)'.format(
                 vf0_mac
             ),
@@ -544,37 +564,98 @@ mac_vlan_ipv4_pay_packets = {
     ],
 }
 
-mac_vlan_ipv4_pay = {
-    "sub_casename": "mac_vlan_ipv4_pay",
+mac_vlan_ipv4_vlan = {
+    "sub_casename": "mac_vlan_ipv4_vlan",
     "port_id": 0,
     "rule": "flow create 0 ingress pattern eth / vlan / ipv4 / end actions rss types c-vlan end key_len 0 queues end / end",
     "test": [
         {
-            "send_packet": mac_vlan_ipv4_pay_packets["match"]["mac_vlan_ipv4_pay"][0],
+            "send_packet": mac_vlan_ipv4_vlan_packets["match"]["mac_vlan_ipv4_vlan"][0],
             "action": "save_hash",
         },
         {
-            "send_packet": mac_vlan_ipv4_pay_packets["match"]["mac_vlan_ipv4_pay"][1],
+            "send_packet": mac_vlan_ipv4_vlan_packets["match"]["mac_vlan_ipv4_vlan"][1],
             "action": "check_hash_different",
         },
         {
-            "send_packet": mac_vlan_ipv4_pay_packets["match"]["mac_vlan_ipv4_pay"][2],
+            "send_packet": mac_vlan_ipv4_vlan_packets["match"]["mac_vlan_ipv4_vlan"][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
-        #     'send_packet': mac_vlan_ipv4_pay_packets['mismatch'][0],
-        #     'action': 'check_no_hash_or_different',
+        #     "send_packet": mac_vlan_ipv4_vlan_packets["mismatch"][0],
+        #     "action": "check_no_hash_or_different",
         # },
     ],
     "post-test": [
         {"send_packet": pkt, "action": "check_no_hash_or_different"}
-        for pkt in mac_vlan_ipv4_pay_packets["match"]["mac_vlan_ipv4_pay"]
+        for pkt in mac_vlan_ipv4_vlan_packets["match"]["mac_vlan_ipv4_vlan"]
     ],
 }
 
-mac_vlan_ipv4_udp_pay_packets = {
+mac_vlan_ipv4_l3dst_packets = {
     "match": {
-        "mac_vlan_ipv4_udp_pay": [
+        "mac_vlan_ipv4_l3dst": [
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.3")/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:99", dst="{}",type=0x8100)/Dot1Q(vlan=2,type=0x0800)/IP(src="192.168.1.3", dst="192.168.1.2")/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+        ],
+    },
+    "mismatch": [
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/Raw("x" * 80)'.format(
+            vf0_mac
+        )
+    ],
+}
+
+mac_vlan_ipv4_l3dst = {
+    "sub_casename": "mac_vlan_ipv4_l3dst",
+    "port_id": 0,
+    "rule": "flow create 0 ingress pattern eth / vlan / ipv4 / end actions rss types ipv4 l3-dst-only end key_len 0 queues end / end",
+    "test": [
+        {
+            "send_packet": mac_vlan_ipv4_l3dst_packets["match"]["mac_vlan_ipv4_l3dst"][
+                0
+            ],
+            "action": "save_hash",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_l3dst_packets["match"]["mac_vlan_ipv4_l3dst"][
+                1
+            ],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_l3dst_packets["match"]["mac_vlan_ipv4_l3dst"][
+                2
+            ],
+            "action": "check_hash_same",
+        },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
+        # {
+        #     "send_packet": mac_vlan_ipv4_l3dst_packets["mismatch"][0],
+        #     "action": "check_no_hash_or_different",
+        # },
+    ],
+    "post-test": [
+        {"send_packet": pkt, "action": "check_no_hash_or_different"}
+        for pkt in mac_vlan_ipv4_l3dst_packets["match"]["mac_vlan_ipv4_l3dst"]
+    ],
+}
+
+mac_vlan_ipv4_pay = [mac_vlan_ipv4_vlan, mac_vlan_ipv4_l3dst]
+
+mac_vlan_ipv4_udp_vlan_packets = {
+    "match": {
+        "mac_vlan_ipv4_udp_vlan": [
             'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
                 vf0_mac
             ),
@@ -596,43 +677,171 @@ mac_vlan_ipv4_udp_pay_packets = {
     ],
 }
 
-mac_vlan_ipv4_udp_pay = {
-    "sub_casename": "mac_vlan_ipv4_udp_pay",
+mac_vlan_ipv4_udp_vlan = {
+    "sub_casename": "mac_vlan_ipv4_udp_vlan",
     "port_id": 0,
     "rule": "flow create 0 ingress pattern eth / vlan / ipv4 / udp / end actions rss types c-vlan end key_len 0 queues end / end",
     "test": [
         {
-            "send_packet": mac_vlan_ipv4_udp_pay_packets["match"][
-                "mac_vlan_ipv4_udp_pay"
+            "send_packet": mac_vlan_ipv4_udp_vlan_packets["match"][
+                "mac_vlan_ipv4_udp_vlan"
             ][0],
             "action": "save_hash",
         },
         {
-            "send_packet": mac_vlan_ipv4_udp_pay_packets["match"][
-                "mac_vlan_ipv4_udp_pay"
+            "send_packet": mac_vlan_ipv4_udp_vlan_packets["match"][
+                "mac_vlan_ipv4_udp_vlan"
             ][1],
             "action": "check_hash_different",
         },
         {
-            "send_packet": mac_vlan_ipv4_udp_pay_packets["match"][
-                "mac_vlan_ipv4_udp_pay"
+            "send_packet": mac_vlan_ipv4_udp_vlan_packets["match"][
+                "mac_vlan_ipv4_udp_vlan"
             ][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
-        #     'send_packet': mac_vlan_ipv4_udp_pay_packets['mismatch'],
-        #     'action': 'check_no_hash_or_different',
+        #     "send_packet": mac_vlan_ipv4_udp_vlan_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
+        # },
+    ],
+    "post-test": [
+        {"send_packet": pkt, "action": "check_no_hash_or_different"}
+        for pkt in mac_vlan_ipv4_udp_vlan_packets["match"]["mac_vlan_ipv4_udp_vlan"]
+    ],
+}
+
+mac_vlan_ipv4_udp_l3src_packets = {
+    "match": {
+        "mac_vlan_ipv4_udp_l3src": [
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.3", dst="192.168.1.2")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:99", dst="{}",type=0x8100)/Dot1Q(vlan=2,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.4")/UDP(sport=19,dport=99)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+        ]
+    },
+    "mismatch": [
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/TCP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+    ],
+}
+
+mac_vlan_ipv4_udp_l3src = {
+    "sub_casename": "mac_vlan_ipv4_udp_l3src",
+    "port_id": 0,
+    "rule": "flow create 0 ingress pattern eth / vlan / ipv4 / udp / end actions rss types ipv4 l3-src-only end key_len 0 queues end / end",
+    "test": [
+        {
+            "send_packet": mac_vlan_ipv4_udp_l3src_packets["match"][
+                "mac_vlan_ipv4_udp_l3src"
+            ][0],
+            "action": "save_hash",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_udp_l3src_packets["match"][
+                "mac_vlan_ipv4_udp_l3src"
+            ][1],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_udp_l3src_packets["match"][
+                "mac_vlan_ipv4_udp_l3src"
+            ][2],
+            "action": "check_hash_same",
+        },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
+        # {
+        #     "send_packet": mac_vlan_ipv4_udp_l3src_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
+        # },
+    ],
+    "post-test": [
+        {"send_packet": pkt, "action": "check_no_hash_or_different"}
+        for pkt in mac_vlan_ipv4_udp_l3src_packets["match"]["mac_vlan_ipv4_udp_l3src"]
+    ],
+}
+
+mac_vlan_ipv4_udp_l4dst_packets = {
+    "match": {
+        "mac_vlan_ipv4_udp_l4dst": [
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=25,dport=24)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:99", dst="{}",type=0x8100)/Dot1Q(vlan=2,type=0x0800)/IP(src="192.168.1.3", dst="192.168.1.4")/UDP(sport=19,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+        ]
+    },
+    "mismatch": [
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/TCP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+    ],
+}
+
+mac_vlan_ipv4_udp_l4dst = {
+    "sub_casename": "mac_vlan_ipv4_udp_l4dst",
+    "port_id": 0,
+    "rule": "flow create 0 ingress pattern eth / vlan / ipv4 / udp / end actions rss types ipv4-udp l4-dst-only end key_len 0 queues end / end",
+    "test": [
+        {
+            "send_packet": mac_vlan_ipv4_udp_l4dst_packets["match"][
+                "mac_vlan_ipv4_udp_l4dst"
+            ][0],
+            "action": "save_hash",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_udp_l4dst_packets["match"][
+                "mac_vlan_ipv4_udp_l4dst"
+            ][1],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_udp_l4dst_packets["match"][
+                "mac_vlan_ipv4_udp_l4dst"
+            ][2],
+            "action": "check_hash_same",
+        },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
+        # {
+        #    "send_packet": mac_vlan_ipv4_udp_l4dst_packets["mismatch"],
+        #    "action": "check_no_hash_or_different",
         # },
     ],
     "post-test": [
         {"send_packet": pkt, "action": "check_no_hash_or_different"}
-        for pkt in mac_vlan_ipv4_udp_pay_packets["match"]["mac_vlan_ipv4_udp_pay"]
+        for pkt in mac_vlan_ipv4_udp_l4dst_packets["match"]["mac_vlan_ipv4_udp_l4dst"]
     ],
 }
 
-mac_vlan_ipv4_tcp_pay_packets = {
+mac_vlan_ipv4_udp_pay = [
+    mac_vlan_ipv4_udp_vlan,
+    mac_vlan_ipv4_udp_l3src,
+    mac_vlan_ipv4_udp_l4dst,
+]
+
+mac_vlan_ipv4_tcp_vlan_packets = {
     "match": {
-        "mac_vlan_ipv4_tcp_pay": [
+        "mac_vlan_ipv4_tcp_vlan": [
             'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/TCP(sport=25,dport=23)/Raw("x" * 80)'.format(
                 vf0_mac
             ),
@@ -654,43 +863,118 @@ mac_vlan_ipv4_tcp_pay_packets = {
     ],
 }
 
-mac_vlan_ipv4_tcp_pay = {
-    "sub_casename": "mac_vlan_ipv4_tcp_pay",
+mac_vlan_ipv4_tcp_vlan = {
+    "sub_casename": "mac_vlan_ipv4_tcp_vlan",
     "port_id": 0,
     "rule": "flow create 0 ingress pattern eth / vlan / ipv4 / tcp / end actions rss types c-vlan end key_len 0 queues end / end",
     "test": [
         {
-            "send_packet": mac_vlan_ipv4_tcp_pay_packets["match"][
-                "mac_vlan_ipv4_tcp_pay"
+            "send_packet": mac_vlan_ipv4_tcp_vlan_packets["match"][
+                "mac_vlan_ipv4_tcp_vlan"
             ][0],
             "action": "save_hash",
         },
         {
-            "send_packet": mac_vlan_ipv4_tcp_pay_packets["match"][
-                "mac_vlan_ipv4_tcp_pay"
+            "send_packet": mac_vlan_ipv4_tcp_vlan_packets["match"][
+                "mac_vlan_ipv4_tcp_vlan"
             ][1],
             "action": "check_hash_different",
         },
         {
-            "send_packet": mac_vlan_ipv4_tcp_pay_packets["match"][
-                "mac_vlan_ipv4_tcp_pay"
+            "send_packet": mac_vlan_ipv4_tcp_vlan_packets["match"][
+                "mac_vlan_ipv4_tcp_vlan"
             ][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
-        #     'send_packet': mac_vlan_ipv4_tcp_pay_packets['mismatch'],
-        #     'action': 'check_no_hash_or_different',
+        #     "send_packet": mac_vlan_ipv4_tcp_vlan_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
+        # },
+    ],
+    "post-test": [
+        {"send_packet": pkt, "action": "check_no_hash_or_different"}
+        for pkt in mac_vlan_ipv4_tcp_vlan_packets["match"]["mac_vlan_ipv4_tcp_vlan"]
+    ],
+}
+
+mac_vlan_ipv4_tcp_l3src_l4src_packets = {
+    "match": {
+        "mac_vlan_ipv4_tcp_l3src_l4src": [
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/TCP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.3", dst="192.168.1.2")/TCP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/TCP(sport=22,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:99", dst="{}",type=0x8100)/Dot1Q(vlan=2,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.4")/TCP(sport=25,dport=99)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+        ]
+    },
+    "mismatch": [
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/TCP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+    ],
+}
+
+mac_vlan_ipv4_tcp_l3src_l4src = {
+    "sub_casename": "mac_vlan_ipv4_tcp_l3src_l4src",
+    "port_id": 0,
+    "rule": "flow create 0 ingress pattern eth / vlan / ipv4 / tcp / end actions rss types ipv4-tcp l3-src-only l4-src-only end key_len 0 queues end / end",
+    "test": [
+        {
+            "send_packet": mac_vlan_ipv4_tcp_l3src_l4src_packets["match"][
+                "mac_vlan_ipv4_tcp_l3src_l4src"
+            ][0],
+            "action": "save_hash",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_tcp_l3src_l4src_packets["match"][
+                "mac_vlan_ipv4_tcp_l3src_l4src"
+            ][1],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_tcp_l3src_l4src_packets["match"][
+                "mac_vlan_ipv4_tcp_l3src_l4src"
+            ][2],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_tcp_l3src_l4src_packets["match"][
+                "mac_vlan_ipv4_tcp_l3src_l4src"
+            ][3],
+            "action": "check_hash_same",
+        },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
+        # {
+        #     "send_packet": mac_vlan_ipv4_tcp_l3src_l4src_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
         # },
     ],
     "post-test": [
         {"send_packet": pkt, "action": "check_no_hash_or_different"}
-        for pkt in mac_vlan_ipv4_tcp_pay_packets["match"]["mac_vlan_ipv4_tcp_pay"]
+        for pkt in mac_vlan_ipv4_tcp_l3src_l4src_packets["match"][
+            "mac_vlan_ipv4_tcp_l3src_l4src"
+        ]
     ],
 }
 
-mac_vlan_ipv4_sctp_pay_packets = {
+mac_vlan_ipv4_tcp_pay = [mac_vlan_ipv4_tcp_vlan, mac_vlan_ipv4_tcp_l3src_l4src]
+
+mac_vlan_ipv4_sctp_vlan_packets = {
     "match": {
-        "mac_vlan_ipv4_sctp_pay": [
+        "mac_vlan_ipv4_sctp_vlan": [
             'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/SCTP(sport=25,dport=23)/Raw("x" * 80)'.format(
                 vf0_mac
             ),
@@ -712,43 +996,134 @@ mac_vlan_ipv4_sctp_pay_packets = {
     ],
 }
 
-mac_vlan_ipv4_sctp_pay = {
-    "sub_casename": "mac_vlan_ipv4_sctp_pay",
+mac_vlan_ipv4_sctp_vlan = {
+    "sub_casename": "mac_vlan_ipv4_sctp_vlan",
     "port_id": 0,
     "rule": "flow create 0 ingress pattern eth / vlan / ipv4 / sctp / end actions rss types c-vlan end key_len 0 queues end / end",
     "test": [
         {
-            "send_packet": mac_vlan_ipv4_sctp_pay_packets["match"][
-                "mac_vlan_ipv4_sctp_pay"
+            "send_packet": mac_vlan_ipv4_sctp_vlan_packets["match"][
+                "mac_vlan_ipv4_sctp_vlan"
             ][0],
             "action": "save_hash",
         },
         {
-            "send_packet": mac_vlan_ipv4_sctp_pay_packets["match"][
-                "mac_vlan_ipv4_sctp_pay"
+            "send_packet": mac_vlan_ipv4_sctp_vlan_packets["match"][
+                "mac_vlan_ipv4_sctp_vlan"
             ][1],
             "action": "check_hash_different",
         },
         {
-            "send_packet": mac_vlan_ipv4_sctp_pay_packets["match"][
-                "mac_vlan_ipv4_sctp_pay"
+            "send_packet": mac_vlan_ipv4_sctp_vlan_packets["match"][
+                "mac_vlan_ipv4_sctp_vlan"
             ][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
-        #     'send_packet': mac_vlan_ipv4_sctp_pay_packets['mismatch'],
-        #     'action': 'check_no_hash_or_different',
+        #     "send_packet": mac_vlan_ipv4_sctp_vlan_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
+        # },
+    ],
+    "post-test": [
+        {"send_packet": pkt, "action": "check_no_hash_or_different"}
+        for pkt in mac_vlan_ipv4_sctp_vlan_packets["match"]["mac_vlan_ipv4_sctp_vlan"]
+    ],
+}
+
+mac_vlan_ipv4_sctp_all_packets = {
+    "match": {
+        "mac_vlan_ipv4_sctp_all": [
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/SCTP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.3", dst="192.168.1.2")/SCTP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.4")/SCTP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/SCTP(sport=19,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/SCTP(sport=25,dport=99)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:99", dst="{}",type=0x8100)/Dot1Q(vlan=2,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/SCTP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+        ]
+    },
+    "mismatch": [
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/SCTP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+    ],
+}
+
+mac_vlan_ipv4_sctp_all = {
+    "sub_casename": "mac_vlan_ipv4_sctp_all",
+    "port_id": 0,
+    "rule": "flow create 0 ingress pattern eth / vlan / ipv4 / sctp / end actions rss types ipv4-sctp end key_len 0 queues end / end",
+    "test": [
+        {
+            "send_packet": mac_vlan_ipv4_sctp_all_packets["match"][
+                "mac_vlan_ipv4_sctp_all"
+            ][0],
+            "action": "save_hash",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_sctp_all_packets["match"][
+                "mac_vlan_ipv4_sctp_all"
+            ][1],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_sctp_all_packets["match"][
+                "mac_vlan_ipv4_sctp_all"
+            ][2],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_sctp_all_packets["match"][
+                "mac_vlan_ipv4_sctp_all"
+            ][3],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_sctp_all_packets["match"][
+                "mac_vlan_ipv4_sctp_all"
+            ][4],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv4_sctp_all_packets["match"][
+                "mac_vlan_ipv4_sctp_all"
+            ][5],
+            "action": "check_hash_same",
+        },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
+        # {
+        #     "send_packet": mac_vlan_ipv4_sctp_all_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
         # },
     ],
     "post-test": [
         {"send_packet": pkt, "action": "check_no_hash_or_different"}
-        for pkt in mac_vlan_ipv4_sctp_pay_packets["match"]["mac_vlan_ipv4_sctp_pay"]
+        for pkt in mac_vlan_ipv4_sctp_all_packets["match"]["mac_vlan_ipv4_sctp_all"]
     ],
 }
 
-mac_vlan_ipv6_pay_packets = {
+mac_vlan_ipv4_sctp_pay = [mac_vlan_ipv4_sctp_vlan, mac_vlan_ipv4_sctp_all]
+
+mac_vlan_ipv6_vlan_packets = {
     "match": {
-        "mac_vlan_ipv6_pay": [
+        "mac_vlan_ipv6_vlan": [
             'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/Raw("x" * 80)'.format(
                 vf0_mac
             ),
@@ -767,37 +1142,98 @@ mac_vlan_ipv6_pay_packets = {
     ],
 }
 
-mac_vlan_ipv6_pay = {
-    "sub_casename": "mac_vlan_ipv6_pay",
+mac_vlan_ipv6_vlan = {
+    "sub_casename": "mac_vlan_ipv6_vlan",
     "port_id": 0,
     "rule": "flow create 0 ingress pattern eth / vlan / ipv6 / end actions rss types c-vlan end key_len 0 queues end / end",
     "test": [
         {
-            "send_packet": mac_vlan_ipv6_pay_packets["match"]["mac_vlan_ipv6_pay"][0],
+            "send_packet": mac_vlan_ipv6_vlan_packets["match"]["mac_vlan_ipv6_vlan"][0],
             "action": "save_hash",
         },
         {
-            "send_packet": mac_vlan_ipv6_pay_packets["match"]["mac_vlan_ipv6_pay"][1],
+            "send_packet": mac_vlan_ipv6_vlan_packets["match"]["mac_vlan_ipv6_vlan"][1],
             "action": "check_hash_different",
         },
         {
-            "send_packet": mac_vlan_ipv6_pay_packets["match"]["mac_vlan_ipv6_pay"][2],
+            "send_packet": mac_vlan_ipv6_vlan_packets["match"]["mac_vlan_ipv6_vlan"][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
-        #     'send_packet': mac_vlan_ipv6_pay_packets['mismatch'],
-        #     'action': 'check_no_hash_or_different',
+        #     "send_packet": mac_vlan_ipv6_vlan_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
+        # },
+    ],
+    "post-test": [
+        {"send_packet": pkt, "action": "check_no_hash_or_different"}
+        for pkt in mac_vlan_ipv6_vlan_packets["match"]["mac_vlan_ipv6_vlan"]
+    ],
+}
+
+mac_vlan_ipv6_l3src_packets = {
+    "match": {
+        "mac_vlan_ipv6_l3src": [
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1537", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:99", dst="{}",type=0x8100)/Dot1Q(vlan=2,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2023")/Raw("y" * 80)'.format(
+                vf0_mac
+            ),
+        ]
+    },
+    "mismatch": [
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/Raw("x" * 80)'.format(
+            vf0_mac
+        )
+    ],
+}
+
+mac_vlan_ipv6_l3src = {
+    "sub_casename": "mac_vlan_ipv6_l3src",
+    "port_id": 0,
+    "rule": "flow create 0 ingress pattern eth / vlan / ipv6 / end actions rss types ipv6 l3-src-only end key_len 0 queues end / end",
+    "test": [
+        {
+            "send_packet": mac_vlan_ipv6_l3src_packets["match"]["mac_vlan_ipv6_l3src"][
+                0
+            ],
+            "action": "save_hash",
+        },
+        {
+            "send_packet": mac_vlan_ipv6_l3src_packets["match"]["mac_vlan_ipv6_l3src"][
+                1
+            ],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv6_l3src_packets["match"]["mac_vlan_ipv6_l3src"][
+                2
+            ],
+            "action": "check_hash_same",
+        },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
+        # {
+        #     "send_packet": mac_vlan_ipv6_l3src_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
         # },
     ],
     "post-test": [
         {"send_packet": pkt, "action": "check_no_hash_or_different"}
-        for pkt in mac_vlan_ipv6_pay_packets["match"]["mac_vlan_ipv6_pay"]
+        for pkt in mac_vlan_ipv6_l3src_packets["match"]["mac_vlan_ipv6_l3src"]
     ],
 }
 
-mac_vlan_ipv6_udp_pay_packets = {
+mac_vlan_ipv6_pay = [mac_vlan_ipv6_vlan, mac_vlan_ipv6_l3src]
+
+mac_vlan_ipv6_udp_vlan_packets = {
     "match": {
-        "mac_vlan_ipv6_udp_pay": [
+        "mac_vlan_ipv6_udp_vlan": [
             'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
                 vf0_mac
             ),
@@ -819,43 +1255,107 @@ mac_vlan_ipv6_udp_pay_packets = {
     ],
 }
 
-mac_vlan_ipv6_udp_pay = {
-    "sub_casename": "mac_vlan_ipv6_udp_pay",
+mac_vlan_ipv6_udp_vlan = {
+    "sub_casename": "mac_vlan_ipv6_udp_vlan",
     "port_id": 0,
     "rule": "flow create 0 ingress pattern eth / vlan / ipv6 / udp / end actions rss types c-vlan end key_len 0 queues end / end",
     "test": [
         {
-            "send_packet": mac_vlan_ipv6_udp_pay_packets["match"][
-                "mac_vlan_ipv6_udp_pay"
+            "send_packet": mac_vlan_ipv6_udp_vlan_packets["match"][
+                "mac_vlan_ipv6_udp_vlan"
             ][0],
             "action": "save_hash",
         },
         {
-            "send_packet": mac_vlan_ipv6_udp_pay_packets["match"][
-                "mac_vlan_ipv6_udp_pay"
+            "send_packet": mac_vlan_ipv6_udp_vlan_packets["match"][
+                "mac_vlan_ipv6_udp_vlan"
             ][1],
             "action": "check_hash_different",
         },
         {
-            "send_packet": mac_vlan_ipv6_udp_pay_packets["match"][
-                "mac_vlan_ipv6_udp_pay"
+            "send_packet": mac_vlan_ipv6_udp_vlan_packets["match"][
+                "mac_vlan_ipv6_udp_vlan"
             ][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
-        #     'send_packet': mac_vlan_ipv6_udp_pay_packets['mismatch'],
-        #     'action': 'check_no_hash_or_different',
+        #     "send_packet": mac_vlan_ipv6_udp_vlan_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
+        #  },
+    ],
+    "post-test": [
+        {"send_packet": pkt, "action": "check_no_hash_or_different"}
+        for pkt in mac_vlan_ipv6_udp_vlan_packets["match"]["mac_vlan_ipv6_udp_vlan"]
+    ],
+}
+
+mac_vlan_ipv6_udp_l4src_packets = {
+    "match": {
+        "mac_vlan_ipv6_udp_l4src": [
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/UDP(sport=19,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:99", dst="{}",type=0x8100)/Dot1Q(vlan=2,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1537", dst="CDCD:910A:2222:5498:8475:1111:3900:2023")/UDP(sport=25,dport=99)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+        ]
+    },
+    "mismatch": [
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/TCP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+    ],
+}
+
+mac_vlan_ipv6_udp_l4src = {
+    "sub_casename": "mac_vlan_ipv6_udp_l4src",
+    "port_id": 0,
+    "rule": "flow create 0 ingress pattern eth / vlan / ipv6 / udp / end actions rss types ipv6-udp l4-src-only end key_len 0 queues end / end",
+    "test": [
+        {
+            "send_packet": mac_vlan_ipv6_udp_l4src_packets["match"][
+                "mac_vlan_ipv6_udp_l4src"
+            ][0],
+            "action": "save_hash",
+        },
+        {
+            "send_packet": mac_vlan_ipv6_udp_l4src_packets["match"][
+                "mac_vlan_ipv6_udp_l4src"
+            ][1],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv6_udp_l4src_packets["match"][
+                "mac_vlan_ipv6_udp_l4src"
+            ][2],
+            "action": "check_hash_same",
+        },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
+        # {
+        #     "send_packet": mac_vlan_ipv6_udp_l4src_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
         # },
     ],
     "post-test": [
         {"send_packet": pkt, "action": "check_no_hash_or_different"}
-        for pkt in mac_vlan_ipv6_udp_pay_packets["match"]["mac_vlan_ipv6_udp_pay"]
+        for pkt in mac_vlan_ipv6_udp_l4src_packets["match"]["mac_vlan_ipv6_udp_l4src"]
     ],
 }
 
-mac_vlan_ipv6_tcp_pay_packets = {
+mac_vlan_ipv6_udp_pay = [mac_vlan_ipv6_udp_vlan, mac_vlan_ipv6_udp_l4src]
+
+mac_vlan_ipv6_tcp_vlan_packets = {
     "match": {
-        "mac_vlan_ipv6_tcp_pay": [
+        "mac_vlan_ipv6_tcp_vlan": [
             'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/TCP(sport=25,dport=23)/Raw("x" * 80)'.format(
                 vf0_mac
             ),
@@ -877,43 +1377,107 @@ mac_vlan_ipv6_tcp_pay_packets = {
     ],
 }
 
-mac_vlan_ipv6_tcp_pay = {
-    "sub_casename": "mac_vlan_ipv6_tcp_pay",
+mac_vlan_ipv6_tcp_vlan = {
+    "sub_casename": "mac_vlan_ipv6_tcp_vlan",
     "port_id": 0,
     "rule": "flow create 0 ingress pattern eth / vlan / ipv6 / tcp / end actions rss types c-vlan end key_len 0 queues end / end",
     "test": [
         {
-            "send_packet": mac_vlan_ipv6_tcp_pay_packets["match"][
-                "mac_vlan_ipv6_tcp_pay"
+            "send_packet": mac_vlan_ipv6_tcp_vlan_packets["match"][
+                "mac_vlan_ipv6_tcp_vlan"
             ][0],
             "action": "save_hash",
         },
         {
-            "send_packet": mac_vlan_ipv6_tcp_pay_packets["match"][
-                "mac_vlan_ipv6_tcp_pay"
+            "send_packet": mac_vlan_ipv6_tcp_vlan_packets["match"][
+                "mac_vlan_ipv6_tcp_vlan"
             ][1],
             "action": "check_hash_different",
         },
         {
-            "send_packet": mac_vlan_ipv6_tcp_pay_packets["match"][
-                "mac_vlan_ipv6_tcp_pay"
+            "send_packet": mac_vlan_ipv6_tcp_vlan_packets["match"][
+                "mac_vlan_ipv6_tcp_vlan"
             ][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
-        #     'send_packet': mac_vlan_ipv6_tcp_pay_packets['mismatch'],
-        #     'action': 'check_no_hash_or_different',
+        #     "send_packet": mac_vlan_ipv6_tcp_vlan_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
+        # },
+    ],
+    "post-test": [
+        {"send_packet": pkt, "action": "check_no_hash_or_different"}
+        for pkt in mac_vlan_ipv6_tcp_vlan_packets["match"]["mac_vlan_ipv6_tcp_vlan"]
+    ],
+}
+
+mac_vlan_ipv6_tcp_l3dst_packets = {
+    "match": {
+        "mac_vlan_ipv6_tcp_l3dst": [
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/TCP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2023")/TCP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:99", dst="{}",type=0x8100)/Dot1Q(vlan=2,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1537", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/TCP(sport=19,dport=99)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+        ]
+    },
+    "mismatch": [
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/TCP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+    ],
+}
+
+mac_vlan_ipv6_tcp_l3dst = {
+    "sub_casename": "mac_vlan_ipv6_tcp_l3dst",
+    "port_id": 0,
+    "rule": "flow create 0 ingress pattern eth / vlan / ipv6 / tcp / end actions rss types ipv6-tcp l3-dst-only end key_len 0 queues end / end",
+    "test": [
+        {
+            "send_packet": mac_vlan_ipv6_tcp_l3dst_packets["match"][
+                "mac_vlan_ipv6_tcp_l3dst"
+            ][0],
+            "action": "save_hash",
+        },
+        {
+            "send_packet": mac_vlan_ipv6_tcp_l3dst_packets["match"][
+                "mac_vlan_ipv6_tcp_l3dst"
+            ][1],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv6_tcp_l3dst_packets["match"][
+                "mac_vlan_ipv6_tcp_l3dst"
+            ][2],
+            "action": "check_hash_same",
+        },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
+        # {
+        #     "send_packet": mac_vlan_ipv6_tcp_l3dst_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
         # },
     ],
     "post-test": [
         {"send_packet": pkt, "action": "check_no_hash_or_different"}
-        for pkt in mac_vlan_ipv6_tcp_pay_packets["match"]["mac_vlan_ipv6_tcp_pay"]
+        for pkt in mac_vlan_ipv6_tcp_l3dst_packets["match"]["mac_vlan_ipv6_tcp_l3dst"]
     ],
 }
 
-mac_vlan_ipv6_sctp_pay_packets = {
+mac_vlan_ipv6_tcp_pay = [mac_vlan_ipv6_tcp_vlan, mac_vlan_ipv6_tcp_l3dst]
+
+mac_vlan_ipv6_sctp_vlan_packets = {
     "match": {
-        "mac_vlan_ipv6_sctp_pay": [
+        "mac_vlan_ipv6_sctp_vlan": [
             'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/SCTP(sport=25,dport=23)/Raw("x" * 80)'.format(
                 vf0_mac
             ),
@@ -935,40 +1499,115 @@ mac_vlan_ipv6_sctp_pay_packets = {
     ],
 }
 
-mac_vlan_ipv6_sctp_pay = {
-    "sub_casename": "mac_vlan_ipv6_sctp_pay",
+mac_vlan_ipv6_sctp_vlan = {
+    "sub_casename": "mac_vlan_ipv6_sctp_vlan",
     "port_id": 0,
     "rule": "flow create 0 ingress pattern eth / vlan / ipv6 / sctp / end actions rss types c-vlan end key_len 0 queues end / end",
     "test": [
         {
-            "send_packet": mac_vlan_ipv6_sctp_pay_packets["match"][
-                "mac_vlan_ipv6_sctp_pay"
+            "send_packet": mac_vlan_ipv6_sctp_vlan_packets["match"][
+                "mac_vlan_ipv6_sctp_vlan"
             ][0],
             "action": "save_hash",
         },
         {
-            "send_packet": mac_vlan_ipv6_sctp_pay_packets["match"][
-                "mac_vlan_ipv6_sctp_pay"
+            "send_packet": mac_vlan_ipv6_sctp_vlan_packets["match"][
+                "mac_vlan_ipv6_sctp_vlan"
             ][1],
             "action": "check_hash_different",
         },
         {
-            "send_packet": mac_vlan_ipv6_sctp_pay_packets["match"][
-                "mac_vlan_ipv6_sctp_pay"
+            "send_packet": mac_vlan_ipv6_sctp_vlan_packets["match"][
+                "mac_vlan_ipv6_sctp_vlan"
             ][2],
             "action": "check_hash_same",
         },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
         # {
-        #     'send_packet': mac_vlan_ipv6_sctp_pay_packets['mismatch'],
-        #     'action': 'check_no_hash_or_different',
+        #     "send_packet": mac_vlan_ipv6_sctp_vlan_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
         # },
     ],
     "post-test": [
         {"send_packet": pkt, "action": "check_no_hash_or_different"}
-        for pkt in mac_vlan_ipv6_sctp_pay_packets["match"]["mac_vlan_ipv6_sctp_pay"]
+        for pkt in mac_vlan_ipv6_sctp_vlan_packets["match"]["mac_vlan_ipv6_sctp_vlan"]
+    ],
+}
+
+mac_vlan_ipv6_sctp_l3dst_l4dst_packets = {
+    "match": {
+        "mac_vlan_ipv6_sctp_l3dst_l4dst": [
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/SCTP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2023")/SCTP(sport=25,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/SCTP(sport=25,dport=99)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+            'Ether(src="10:22:33:44:55:99", dst="{}",type=0x8100)/Dot1Q(vlan=2,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1537", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/SCTP(sport=19,dport=23)/Raw("x" * 80)'.format(
+                vf0_mac
+            ),
+        ]
+    },
+    "mismatch": [
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/SCTP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
+        'Ether(src="10:22:33:44:55:66", dst="{}",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/UDP(sport=25,dport=23)/Raw("x" * 80)'.format(
+            vf0_mac
+        ),
     ],
 }
 
+mac_vlan_ipv6_sctp_l3dst_l4dst = {
+    "sub_casename": "mac_vlan_ipv6_sctp_l3dst_l4dst",
+    "port_id": 0,
+    "rule": "flow create 0 ingress pattern eth / vlan / ipv6 / sctp / end actions rss types ipv6-sctp l3-dst-only l4-dst-only end key_len 0 queues end / end",
+    "test": [
+        {
+            "send_packet": mac_vlan_ipv6_sctp_l3dst_l4dst_packets["match"][
+                "mac_vlan_ipv6_sctp_l3dst_l4dst"
+            ][0],
+            "action": "save_hash",
+        },
+        {
+            "send_packet": mac_vlan_ipv6_sctp_l3dst_l4dst_packets["match"][
+                "mac_vlan_ipv6_sctp_l3dst_l4dst"
+            ][1],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv6_sctp_l3dst_l4dst_packets["match"][
+                "mac_vlan_ipv6_sctp_l3dst_l4dst"
+            ][2],
+            "action": "check_hash_different",
+        },
+        {
+            "send_packet": mac_vlan_ipv6_sctp_l3dst_l4dst_packets["match"][
+                "mac_vlan_ipv6_sctp_l3dst_l4dst"
+            ][3],
+            "action": "check_hash_same",
+        },
+        # According to testplan, case does not need to test the package of mismatch
+        # If need to test in the future, you can directly uncomment
+        # {
+        #     "send_packet": mac_vlan_ipv6_sctp_l3dst_l4dst_packets["mismatch"],
+        #     "action": "check_no_hash_or_different",
+        # },
+    ],
+    "post-test": [
+        {"send_packet": pkt, "action": "check_no_hash_or_different"}
+        for pkt in mac_vlan_ipv6_sctp_l3dst_l4dst_packets["match"][
+            "mac_vlan_ipv6_sctp_l3dst_l4dst"
+        ]
+    ],
+}
+
+mac_vlan_ipv6_sctp_pay = [mac_vlan_ipv6_sctp_vlan, mac_vlan_ipv6_sctp_l3dst_l4dst]
+
 
 class ICE_advance_iavf_rss_vlan_ah_l2tp_pfcp(TestCase):
     def set_up_all(self):
-- 
2.25.1


^ permalink raw reply	[flat|nested] 3+ messages in thread

* [dts] [PATCH V2 2/2] test_plans/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp: add 9 subcase
  2023-01-04 10:02 [dts] [PATCH V2 1/2] tests/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp: add new cases according to testplan Song Jiale
@ 2023-01-04 10:02 ` Song Jiale
  2023-01-10  7:13   ` Tu, Lijuan
  0 siblings, 1 reply; 3+ messages in thread
From: Song Jiale @ 2023-01-04 10:02 UTC (permalink / raw)
  To: dts; +Cc: Song Jiale, Peng Yuan, Weiyuan Li

add 9 subcases to test the dst and src rss rules of L3 and L4 layers with vf.

Signed-off-by: Peng Yuan <yuan.peng@intel.com>
Signed-off-by: Song Jiale <songx.jiale@intel.com>
---
Acked-by: Yuan Peng <yuan.peng@intel.com>
Tested-by: Weiyuan Li <weiyuanx.li@intel.com>

 ...vf_rss_vlan_esp_ah_l2tp_pfcp_test_plan.rst | 461 ++++++++++++++++++
 1 file changed, 461 insertions(+)

diff --git a/test_plans/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp_test_plan.rst b/test_plans/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp_test_plan.rst
index 2acf665f..82c88fe0 100644
--- a/test_plans/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp_test_plan.rst
+++ b/test_plans/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp_test_plan.rst
@@ -598,6 +598,8 @@ Test case: MAC_IPV6_AH
 
 Test case: MAC_VLAN_IPV4_PAY
 ============================
+Subcase: MAC_VLAN_IPV4_VLAN
+---------------------------
 
 1. validate a rule for RSS type of MAC_VLAN_IPV4_PAY::
 
@@ -645,8 +647,59 @@ Test case: MAC_VLAN_IPV4_PAY
    check the rule not exists.
    send the first packet in matched packets, check the hash value of this packet is different with before.
 
+Subcase: MAC_VLAN_IPV4_L3DST
+--------------------------------
+
+1. validate a rule for RSS type of MAC_VLAN_IPV4_PAY::
+
+     testpmd> flow validate 0 ingress pattern eth / vlan / ipv4 / end actions rss types ipv4 l3-dst-only end key_len 0 queues end / end
+
+   get the message::
+
+     Flow rule validated
+
+   check the flow list::
+
+     testpmd> flow list 0
+
+   check the rule not exists in the list.
+
+2. create a rule for RSS type of MAC_VLAN_IPV4_PAY::
+
+     testpmd> flow create 0 ingress pattern eth / vlan / ipv4 / end actions rss types ipv4 l3-dst-only end key_len 0 queues end / end
+     testpmd> flow list 0
+
+   check the rule exists in the list.
+
+3. send matched packets
+
+   * MAC_VLAN_IPV4_PAY packet::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     change the field [l3 dst address], send packets::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.3")/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash value is different from the first packet.
+     change other fields, send packets::
+
+       sendp([Ether(src="10:22:33:44:55:99", dst="00:11:22:33:44:53",type=0x8100)/Dot1Q(vlan=2,type=0x0800)/IP(src="192.168.1.3", dst="192.168.1.2")/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are the same as the first packet.
+
+4. destroy the rule::
+
+     testpmd> flow destroy 0 rule 0
+     testpmd> flow list 0
+
+   check the rule not exists.
+   send the matched packets, check the hash values of the packets are not exist.
+
 Test case: MAC_VLAN_IPV4_UDP_PAY
 ================================
+Subcase: MAC_VLAN_IPV4_UDP_VLAN
+-------------------------------
 
 1. validate a rule for RSS type of MAC_VLAN_IPV4_UDP_PAY::
 
@@ -694,8 +747,108 @@ Test case: MAC_VLAN_IPV4_UDP_PAY
    check the rule not exists.
    send the first packet in matched packets, check the hash value of this packet is different with before.
 
+Subcase: MAC_VLAN_IPV4_UDP_L3SRC
+--------------------------------
+
+1. validate a rule for RSS type of MAC_VLAN_IPV4_UDP_PAY::
+
+     testpmd> flow validate 0 ingress pattern eth / vlan / ipv4 / udp / end actions rss types ipv4 l3-src-only end key_len 0 queues end / end
+
+   get the message::
+
+     Flow rule validated
+
+   check the flow list::
+
+     testpmd> flow list 0
+
+   check the rule not exists in the list.
+
+2. create a rule for RSS type of MAC_VLAN_IPV4_UDP_PAY::
+
+     testpmd> flow create 0 ingress pattern eth / vlan / ipv4 / udp / end actions rss types ipv4 l3-src-only end key_len 0 queues end / end
+     testpmd> flow list 0
+
+   check the rule exists in the list.
+
+3. send matched packets
+
+   * MAC_VLAN_IPV4_UDP_PAY packet::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     change the field [l3 src address], send packets::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.3", dst="192.168.1.2")/UDP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are different from the first packet.
+     change other fields, send packets::
+
+       sendp([Ether(src="10:22:33:44:55:99", dst="00:11:22:33:44:53",type=0x8100)/Dot1Q(vlan=2,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.4")/UDP(sport=19,dport=99)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are the same as as the first packet.
+
+4. destroy the rule::
+
+     testpmd> flow destroy 0 rule 0
+     testpmd> flow list 0
+
+   check the rule not exists.
+   send the matched packets, check the hash values of the packets are not exist.
+
+Subcase: MAC_VLAN_IPV4_UDP_L4DST
+--------------------------------
+
+1. validate a rule for RSS type of MAC_VLAN_IPV4_UDP_PAY::
+
+     testpmd> flow validate 0 ingress pattern eth / vlan / ipv4 / udp / end actions rss types ipv4-udp l4-dst-only end key_len 0 queues end / end
+
+   get the message::
+
+     Flow rule validated
+
+   check the flow list::
+
+     testpmd> flow list 0
+
+   check the rule not exists in the list.
+
+2. create a rule for RSS type of MAC_VLAN_IPV4_UDP_PAY::
+
+     testpmd> flow create 0 ingress pattern eth / vlan / ipv4 / udp / end actions rss types ipv4-udp l4-dst-only end key_len 0 queues end / end
+     testpmd> flow list 0
+
+   check the rule exists in the list.
+
+3. send matched packets
+
+   * MAC_VLAN_IPV4_UDP_PAY packet::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     change the field [l4 dst address], send packets::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=25,dport=24)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are different from the first packet.
+     change other fields, send packets::
+
+       sendp([Ether(src="10:22:33:44:55:99", dst="00:11:22:33:44:53",type=0x8100)/Dot1Q(vlan=2,type=0x0800)/IP(src="192.168.1.3", dst="192.168.1.4")/UDP(sport=19,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are the same as as the first packet.
+
+4. destroy the rule::
+
+     testpmd> flow destroy 0 rule 0
+     testpmd> flow list 0
+
+   check the rule not exists.
+   send the matched packets, check the hash values of the packets are not exist.
+
 Test case: MAC_VLAN_IPV4_TCP_PAY
 ================================
+Subcase: MAC_VLAN_IPV4_TCP_VLAN
+-------------------------------
 
 1. validate a rule for RSS type of MAC_VLAN_IPV4_TCP_PAY::
 
@@ -743,8 +896,60 @@ Test case: MAC_VLAN_IPV4_TCP_PAY
    check the rule not exists.
    send the first packet in matched packets, check the hash value of this packet is different with before.
 
+Subcase: MAC_VLAN_IPV4_TCP_l3SRC_L4SRC
+--------------------------------------
+
+1. validate a rule for RSS type of MAC_VLAN_IPV4_TCP_PAY::
+
+     testpmd> flow validate 0 ingress pattern eth / vlan / ipv4 / tcp / end actions rss types ipv4-tcp l3-src-only l4-src-only end key_len 0 queues end / end
+
+   get the message::
+
+     Flow rule validated
+
+   check the flow list::
+
+     testpmd> flow list 0
+
+   check the rule not exists in the list.
+
+2. create a rule for RSS type of MAC_VLAN_IPV4_TCP_PAY::
+
+     testpmd> flow create 0 ingress pattern eth / vlan / ipv4 / tcp / end actions rss types ipv4-tcp l3-src-only l4-src-only end key_len 0 queues end / end
+     testpmd> flow list 0
+
+   check the rule exists in the list.
+
+3. send matched packets
+
+   * MAC_VLAN_IPV4_TCP_PAY packet::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/TCP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     change the field [l3 src address and l4 sport], send packets::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.3", dst="192.168.1.2")/TCP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/TCP(sport=22,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are different from the first packet.
+     change other fields, send packets::
+
+       sendp([Ether(src="10:22:33:44:55:99", dst="00:11:22:33:44:53",type=0x8100)/Dot1Q(vlan=2,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.4")/TCP(sport=25,dport=99)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are the same as as the first packet.
+
+4. destroy the rule::
+
+     testpmd> flow destroy 0 rule 0
+     testpmd> flow list 0
+
+   check the rule not exists.
+   send the matched packets, check the hash values of the packets are not exist.
+
 Test case: MAC_VLAN_IPV4_SCTP_PAY
 =================================
+Subcase: MAC_VLAN_IPV4_SCTP_VLAN
+--------------------------------
 
 1. validate a rule for RSS type of MAC_VLAN_IPV4_SCTP_PAY::
 
@@ -792,8 +997,62 @@ Test case: MAC_VLAN_IPV4_SCTP_PAY
    check the rule not exists.
    send the first packet in matched packets, check the hash value of this packet is different with before.
 
+Subcase: MAC_VLAN_IPV4_SCTP_ALL
+-------------------------------
+
+1. validate a rule for RSS type of MAC_VLAN_IPV4_SCTP_PAY::
+
+     testpmd> flow validate 0 ingress pattern eth / vlan / ipv4 / sctp / end actions rss types ipv4-sctp end key_len 0 queues end / end
+
+   get the message::
+
+     Flow rule validated
+
+   check the flow list::
+
+     testpmd> flow list 0
+
+   check the rule not exists in the list.
+
+2. create a rule for RSS type of MAC_VLAN_IPV4_SCTP_PAY::
+
+     testpmd> flow create 0 ingress pattern eth / vlan / ipv4 / sctp / end actions rss types ipv4-sctp end key_len 0 queues end / end
+     testpmd> flow list 0
+
+   check the rule exists in the list.
+
+3. send matched packets
+
+   * MAC_VLAN_IPV4_SCTP_PAY packet::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/SCTP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     change the field [ipv4-sctp], send packets::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.3", dst="192.168.1.2")/SCTP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.4")/SCTP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/SCTP(sport=19,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/SCTP(sport=25,dport=99)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are different from the first packet.
+     change other fields, send packets::
+
+       sendp([Ether(src="10:22:33:44:55:99", dst="00:11:22:33:44:53",type=0x8100)/Dot1Q(vlan=2,type=0x0800)/IP(src="192.168.1.1", dst="192.168.1.2")/SCTP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are the same as as the first packet.
+
+4. destroy the rule::
+
+     testpmd> flow destroy 0 rule 0
+     testpmd> flow list 0
+
+   check the rule not exists.
+   send the matched packets, check the hash values of the packets are not exist.
+
 Test case: MAC_VLAN_IPV6_PAY
 ============================
+Subcase: MAC_VLAN_IPV6_VLAN
+-------------------------------
 
 1. validate a rule for RSS type of MAC_VLAN_IPV6_PAY::
 
@@ -841,8 +1100,59 @@ Test case: MAC_VLAN_IPV6_PAY
    check the rule not exists.
    send the first packet in matched packets, check the hash value of this packet is different with before.
 
+Subcase: MAC_VLAN_IPV6_L3SRC
+--------------------------------
+
+1. validate a rule for RSS type of MAC_VLAN_IPV6_PAY::
+
+     testpmd> flow validate 0 ingress pattern eth / vlan / ipv6 / end actions rss types ipv6 l3-src-only end key_len 0 queues end / end
+
+   get the message::
+
+     Flow rule validated
+
+   check the flow list::
+
+     testpmd> flow list 0
+
+   check the rule not exists in the list.
+
+2. create a rule for RSS type of MAC_VLAN_IPV6_PAY::
+
+     testpmd> flow create 0 ingress pattern eth / vlan / ipv6 / end actions rss types ipv6 l3-src-only end key_len 0 queues end / end
+     testpmd> flow list 0
+
+   check the rule exists in the list.
+
+3. send matched packets
+
+   * MAC_VLAN_IPV6_PAY packet::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     change the field [l3 src address], send packets::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1537", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are different from the first packet.
+     change other fields, send packets::
+
+       sendp([Ether(src="10:22:33:44:55:99", dst="00:11:22:33:44:53",type=0x8100)/Dot1Q(vlan=2,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2023")/Raw("y" * 80)],iface="ens786f0",count=1)
+
+   check the hash values are the same as the first packet.
+
+4. destroy the rule::
+
+     testpmd> flow destroy 0 rule 0
+     testpmd> flow list 0
+
+   check the rule not exists.
+   send the matched packets, check the hash values of the packets are not exist.
+
 Test case: MAC_VLAN_IPV6_UDP_PAY
 ================================
+Subcase: MAC_VLAN_IPV6_UDP_VLAN
+-------------------------------
 
 1. validate a rule for RSS type of MAC_VLAN_IPV6_UDP_PAY::
 
@@ -890,8 +1200,59 @@ Test case: MAC_VLAN_IPV6_UDP_PAY
    check the rule not exists.
    send the first packet in matched packets, check the hash value of this packet is different with before.
 
+Subcase: MAC_VLAN_IPV6_UDP_L4SRC
+--------------------------------
+
+1. validate a rule for RSS type of MAC_VLAN_IPV6_UDP_PAY::
+
+     testpmd> flow validate 0 ingress pattern eth / vlan / ipv6 / udp / end actions rss types ipv6-udp l4-src-only end key_len 0 queues end / end
+
+   get the message::
+
+     Flow rule validated
+
+   check the flow list::
+
+     testpmd> flow list 0
+
+   check the rule not exists in the list.
+
+2. create a rule for RSS type of MAC_VLAN_IPV6_UDP_PAY::
+
+     testpmd> flow create 0 ingress pattern eth / vlan / ipv6 / udp / end actions rss types ipv6-udp l4-src-only end key_len 0 queues end / end
+     testpmd> flow list 0
+
+   check the rule exists in the list.
+
+3. send matched packets
+
+   * MAC_VLAN_IPV6_UDP_PAY packet::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/UDP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     change the field [l4 src address], send packets::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/UDP(sport=19,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are different from the first packet.
+     change other fields, send packets::
+
+       sendp([Ether(src="10:22:33:44:55:99", dst="00:11:22:33:44:53",type=0x8100)/Dot1Q(vlan=2,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1537", dst="CDCD:910A:2222:5498:8475:1111:3900:2023")/UDP(sport=25,dport=99)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are the same as the first packet.
+
+4. destroy the rule::
+
+     testpmd> flow destroy 0 rule 0
+     testpmd> flow list 0
+
+   check the rule not exists.
+   send the matched packets, check the hash values of the packets are not exist.
+
 Test case: MAC_VLAN_IPV6_TCP_PAY
 ================================
+Subcase: MAC_VLAN_IPV6_TCP_VLAN
+-------------------------------
 
 1. validate a rule for RSS type of MAC_VLAN_IPV6_TCP_PAY::
 
@@ -939,8 +1300,59 @@ Test case: MAC_VLAN_IPV6_TCP_PAY
    check the rule not exists.
    send the first packet in matched packets, check the hash value of this packet is different with before.
 
+Subcase: MAC_VLAN_IPV6_TCP_L3DST
+--------------------------------
+
+1. validate a rule for RSS type of MAC_VLAN_IPV6_TCP_PAY::
+
+     testpmd> flow validate 0 ingress pattern eth / vlan / ipv6 / tcp / end actions rss types ipv6-tcp l3-dst-only end key_len 0 queues end / end
+
+   get the message::
+
+     Flow rule validated
+
+   check the flow list::
+
+     testpmd> flow list 0
+
+   check the rule not exists in the list.
+
+2. create a rule for RSS type of MAC_VLAN_IPV6_TCP_PAY::
+
+     testpmd> flow create 0 ingress pattern eth / vlan / ipv6 / tcp / end actions rss types ipv6-tcp l3-dst-only end key_len 0 queues end / end
+     testpmd> flow list 0
+
+   check the rule exists in the list.
+
+3. send matched packets
+
+   * MAC_VLAN_IPV6_TCP_PAY packet::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/TCP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     change the field [l3 dst address], send packets::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2023")/TCP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are different from the first packet.
+     change other fields, send packets::
+
+       sendp([Ether(src="10:22:33:44:55:99", dst="00:11:22:33:44:53",type=0x8100)/Dot1Q(vlan=2,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1537", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/TCP(sport=19,dport=99)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are the same as the first packet.
+
+4. destroy the rule::
+
+     testpmd> flow destroy 0 rule 0
+     testpmd> flow list 0
+
+   check the rule not exists.
+   send the matched packets, check the hash values of the packets are not exist.
+
 Test case: MAC_VLAN_IPV6_SCTP_PAY
 =================================
+Subcase: MAC_VLAN_IPV6_SCTP_VLAN
+--------------------------------
 
 1. validate a rule for RSS type of MAC_VLAN_IPV6_SCTP_PAY::
 
@@ -988,6 +1400,55 @@ Test case: MAC_VLAN_IPV6_SCTP_PAY
    check the rule not exists.
    send the first packet in matched packets, check the hash value of this packet is different with before.
 
+Subcase: MAC_VLAN_IPV6_SCTP_L3DST_L4DST
+---------------------------------------
+
+1. validate a rule for RSS type of MAC_VLAN_IPV6_SCTP_PAY::
+
+     testpmd> flow validate 0 ingress pattern eth / vlan / ipv6 / sctp / end actions rss types ipv6-sctp l3-dst-only l4-dst-only end key_len 0 queues end / end
+
+   get the message::
+
+     Flow rule validated
+
+   check the flow list::
+
+     testpmd> flow list 0
+
+   check the rule not exists in the list.
+
+2. create a rule for RSS type of MAC_VLAN_IPV6_SCTP_PAY::
+
+     testpmd> flow create 0 ingress pattern eth / vlan / ipv6 / sctp / end actions rss types ipv6-sctp l3-dst-only l4-dst-only end key_len 0 queues end / end
+     testpmd> flow list 0
+
+   check the rule exists in the list.
+
+3. send matched packets
+
+   * MAC_VLAN_IPV6_SCTP_PAY packet::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/SCTP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     change the field [l3 dst address and l4 dport], send packets::
+
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2023")/SCTP(sport=25,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+       sendp([Ether(src="10:22:33:44:55:66", dst="00:11:22:33:44:55",type=0x8100)/Dot1Q(vlan=1,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1536", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/SCTP(sport=25,dport=99)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are different from the first packet.
+     change other fields, send packets::
+
+       sendp([Ether(src="10:22:33:44:55:99", dst="00:11:22:33:44:53",type=0x8100)/Dot1Q(vlan=2,type=0x86dd)/IPv6(src="CDCD:910A:2222:5498:8475:1111:3900:1537", dst="CDCD:910A:2222:5498:8475:1111:3900:2022")/SCTP(sport=19,dport=23)/Raw("x" * 80)],iface="ens786f0",count=1)
+
+     check the hash values are the same as the first packet.
+
+4. destroy the rule::
+
+     testpmd> flow destroy 0 rule 0
+     testpmd> flow list 0
+
+   check the rule not exists.
+   send the matched packets, check the hash values the packets are not exist.
 
 Test case: negative cases
 =========================
-- 
2.25.1


^ permalink raw reply	[flat|nested] 3+ messages in thread

* RE: [dts] [PATCH V2 2/2] test_plans/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp: add 9 subcase
  2023-01-04 10:02 ` [dts] [PATCH V2 2/2] test_plans/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp: add 9 subcase Song Jiale
@ 2023-01-10  7:13   ` Tu, Lijuan
  0 siblings, 0 replies; 3+ messages in thread
From: Tu, Lijuan @ 2023-01-10  7:13 UTC (permalink / raw)
  To: Jiale, SongX, dts; +Cc: Jiale, SongX, Peng, Yuan, Li, WeiyuanX

> -----Original Message-----
> From: Song Jiale <songx.jiale@intel.com>
> Sent: Wednesday, January 4, 2023 6:02 PM
> To: dts@dpdk.org
> Cc: Jiale, SongX <songx.jiale@intel.com>; Peng, Yuan <yuan.peng@intel.com>;
> Li, WeiyuanX <weiyuanx.li@intel.com>
> Subject: [dts] [PATCH V2 2/2]
> test_plans/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp: add 9 subcase
> 
> add 9 subcases to test the dst and src rss rules of L3 and L4 layers with vf.
> 
> Signed-off-by: Peng Yuan <yuan.peng@intel.com>
> Signed-off-by: Song Jiale <songx.jiale@intel.com>
> ---
> Acked-by: Yuan Peng <yuan.peng@intel.com>
> Tested-by: Weiyuan Li <weiyuanx.li@intel.com>

Applied, thanks

^ permalink raw reply	[flat|nested] 3+ messages in thread

end of thread, other threads:[~2023-01-10  7:14 UTC | newest]

Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2023-01-04 10:02 [dts] [PATCH V2 1/2] tests/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp: add new cases according to testplan Song Jiale
2023-01-04 10:02 ` [dts] [PATCH V2 2/2] test_plans/ice_advanced_iavf_rss_vlan_esp_ah_l2tp_pfcp: add 9 subcase Song Jiale
2023-01-10  7:13   ` Tu, Lijuan

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).