From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by dpdk.org (Postfix) with ESMTP id 2C7832C72 for ; Thu, 17 Sep 2015 03:22:31 +0200 (CEST) Received: from orsmga003.jf.intel.com ([10.7.209.27]) by fmsmga102.fm.intel.com with ESMTP; 16 Sep 2015 18:22:28 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.17,543,1437462000"; d="scan'208";a="646347693" Received: from pgsmsx102.gar.corp.intel.com ([10.221.44.80]) by orsmga003.jf.intel.com with ESMTP; 16 Sep 2015 18:22:26 -0700 Received: from shsmsx151.ccr.corp.intel.com (10.239.6.50) by PGSMSX102.gar.corp.intel.com (10.221.44.80) with Microsoft SMTP Server (TLS) id 14.3.224.2; Thu, 17 Sep 2015 09:22:25 +0800 Received: from shsmsx102.ccr.corp.intel.com ([169.254.2.179]) by SHSMSX151.ccr.corp.intel.com ([169.254.3.12]) with mapi id 14.03.0248.002; Thu, 17 Sep 2015 09:22:23 +0800 From: "Mo, YufengX" To: "dts@dpdk.org" Thread-Topic: [dts 3/4] add unified packet type module and test suite unified packet type flag feature on different NICs. For more details, please reference to test plan. Thread-Index: AQHQ8OVuFxLmGd+ohk2e0oS3onLfy54/7FJA Date: Thu, 17 Sep 2015 01:22:22 +0000 Message-ID: References: <1442452074-4148-1-git-send-email-yufengx.mo@intel.com> <1442452074-4148-4-git-send-email-yufengx.mo@intel.com> In-Reply-To: <1442452074-4148-4-git-send-email-yufengx.mo@intel.com> Accept-Language: zh-CN, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.239.127.40] Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Subject: Re: [dts] [dts 3/4] add unified packet type module and test suite unified packet type flag feature on different NICs. For more details, please reference to test plan. X-BeenThere: dts@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: test suite reviews and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 17 Sep 2015 01:22:33 -0000 Sorry for mistake. Ignore this patchset.=20 -----Original Message----- From: Mo, YufengX=20 Sent: September 17, 2015 9:08 AM To: dts@dpdk.org Cc: Mo, YufengX Subject: [dts 3/4] add unified packet type module and test suite unified pa= cket type flag feature on different NICs. For more details, please referenc= e to test plan. From: yufengmx Signed-off-by: yufengmx --- tests/TestSuite_uni_pkt.py | 364 +++++++++++++++++++++++++++++++++++++++++= ++++ 1 file changed, 364 insertions(+) create mode 100644 tests/TestSuite_uni_pkt.py diff --git a/tests/TestSuite_uni_pkt.py b/tests/TestSuite_uni_pkt.py new fi= le mode 100644 index 0000000..ca72e75 --- /dev/null +++ b/tests/TestSuite_uni_pkt.py @@ -0,0 +1,364 @@ +# BSD LICENSE +# +# Copyright(c) 2010-2014 Intel Corporation. All rights reserved. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without #=20 +modification, are permitted provided that the following conditions #=20 +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 #=20 +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT #=20 +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR #=20 +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT #=20 +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, #=20 +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT #=20 +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, #=20 +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY #=20 +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT #=20 +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE #=20 +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +""" +DPDK Test suite. + +Unified packet type flag is supposed to recognize packet types and=20 +support all possible PMDs. + +This 32 bits of packet_type can be divided into several sub fields to=20 +indicate different packet type information of a packet. The initial=20 +design is to divide those bits into fields for L2 types, L3 types, L4=20 +types, tunnel types, inner L2 types, inner L3 types and inner L4 types.=20 +All PMDs should translate the offloaded packet types into these 7=20 +fields of information, for user applications """ + +import dts +from test_case import TestCase +from exception import VerifyFailure +from packet import Packet +import time + + +class TestUniPacket(TestCase): + + def set_up_all(self): + """ + Run at the start of each test suite. + """ + ports =3D self.dut.get_ports() + self.verify(len(ports) >=3D 2, "Insufficient ports for testing") + valports =3D [_ for _ in ports if self.tester.get_local_port(_) != =3D -1] + # start testpmd + self.dut_port =3D valports[0] + tester_port =3D self.tester.get_local_port(self.dut_port) + self.tester_iface =3D self.tester.get_interface(tester_port) + self.dut.send_expect( + "./%s/app/testpmd -c f -n 4 -- -i --txqflags=3D0x0" % self.tar= get, "testpmd>", 20) + self.dut.send_expect("set fwd rxonly", "testpmd>") + self.dut.send_expect("set verbose 1", "testpmd>") + self.dut.send_expect("start", "testpmd>") + + def set_up(self): + """ + Run before each test case. + Nothing to do. + """ + pass + + def run_test(self, pkt_types): + time.sleep(1) + for pkt_type in pkt_types.keys(): + pkt_names =3D pkt_types[pkt_type] + pkt =3D Packet(pkt_type=3Dpkt_type) + pkt.send_pkt(tx_port=3Dself.tester_iface) + out =3D self.dut.get_session_output(timeout=3D2) + for pkt_layer_name in pkt_names: + if pkt_layer_name not in out: + print dts.RED("Fail to detect %s" % pkt_layer_name) + raise VerifyFailure("Failed to detect %s" % pkt_layer_= name) + print dts.GREEN("Detected %s successfully" % pkt_type) + + def test_l2pkt_detect(self): + """ + Check whether L2 packet can be detected" + """ + self.verify("fortville" in self.nic, + "L2 packet detect only support by Fortville") + self.L2_types =3D { + "TIMESYNC": "(outer) L2 type: ETHER_Timesync", + "ARP": "(outer) L2 type: ETHER_ARP", + "LLDP": "(outer) L2 type: ETHER_LLDP", + } + + for l2_type in self.L2_types.keys(): + pkt_name =3D self.L2_types[l2_type] + pkt =3D Packet(pkt_type=3Dl2_type) + pkt.send_pkt(tx_port=3Dself.tester_iface) + out =3D self.dut.get_session_output(timeout=3D2) + if pkt_name in out: + print dts.GREEN("Detected L2 %s successfully" % l2_type) + else: + raise VerifyFailure("Failed to detect L2 %s" % l2_type) + + def test_IPv4_L4(self): + """ + checked that whether L3 and L4 packet can be normally detected. + """ + if "fortville" in self.nic.lower(): + outerL4Type =3D "(outer) L4 type: L4_NONFRAG" + elif "niantic" in self.nic.lower() or "i350" in self.nic.lower(): + outerL4Type =3D "(outer) L4 type: Unknown" + + pktType =3D { + "MAC_IP_PKT": ["(outer) L2 type: ETHER", "(oute= r) L3 type: IPV4", outerL4Type], + "MAC_IP_UDP_PKT": ["(outer) L4 type: UDP"], + "MAC_IP_TCP_PKT": ["(outer) L4 type: TCP"], + "MAC_IP_SCTP_PKT": ["(outer) L4 type: SCTP"], + "MAC_IP_ICMP_PKT": ["(outer) L4 type: ICMP"], + "MAC_IPFRAG_TCP_PKT": ["(outer) L2 type: ETHER", "(oute= r) L3 type: IPV4_EXT_UNKNOWN", "(outer) L4 type: L4_FRAG"], + "MAC_IPihl_PKT": ["(outer) L3 type: IPV4_EXT", "(o= uter) L4 type: Unknown"], + "MAC_IPihl_SCTP_PKT": ["(outer) L3 type: IPV4_EXT", "(o= uter) L4 type: SCTP"] + } + + # delete the unsupported packet based on nic type + if "fortville" in self.nic.lower(): + pktType.pop("MAC_IPihl_PKT") + pktType.pop("MAC_IPihl_SCTP_PKT") + elif "niantic" in self.nic.lower() or "i350" in self.nic.lower(): + pktType.pop("MAC_IP_ICMP_PKT") + pktType.pop("MAC_IPFRAG_TCP_PKT") + + self.run_test(pktType) + + def test_IPv6_L4(self): + """ + checked that whether IPv6 and L4 packet can be normally detected. + """ + if "fortville" in self.nic.lower(): + outerL4Type =3D "(outer) L4 type: L4_NONFRAG" + outerL3Type =3D "(outer) L3 type: IPV6_EXT_UNKNOWN" + elif "niantic" in self.nic.lower() or "i350" in self.nic.lower(): + outerL4Type =3D "(outer) L4 type: Unknown" + outerL3Type =3D "(outer) L3 type: IPV6" + + pktType =3D { + "MAC_IPv6_PKT": ["(outer) L2 type: ETHER", outerL3Typ= e, outerL4Type], + "MAC_IPv6_UDP_PKT": ["(outer) L4 type: UDP"], + "MAC_IPv6_TCP_PKT": ["(outer) L4 type: TCP"], + "MAC_IPv6FRAG_PKT_F": ["(outer) L3 type: IPV6_EXT_UNKNOWN",= "(outer) L4 type: L4_FRAG"], + "MAC_IPv6FRAG_PKT_N": ["(outer) L3 type: IPV6_EXT", "(outer= ) L4 type: Unknown"] + } + + # delete the unsupported packet based on nic type + if "fortville" in self.nic.lower(): + pktType.pop("MAC_IPv6FRAG_PKT_N") + elif "niantic" in self.nic.lower() or "i350" in self.nic.lower(): + pktType.pop("MAC_IPv6FRAG_PKT_F") + + self.run_test(pktType) + + def test_IP_in_IPv4_tunnel(self): + """ + checked that whether IP in IPv4 tunnel packet can be normally + detected by Fortville. + """ + self.verify("fortville" in self.nic, + "IP in IPv4 tunnel packet type detect only support=20 + by Fortville") + + pktType =3D { + "MAC_IP_IPFRAG_UDP_PKT": ["(outer) L2 type: ETHER", "(out= er) L3 type: IPV4_EXT_UNKNOWN", "(outer) L4 type: Unknown", "Tunnel type: I= P", "Inner L2 type: Unknown", "Inner L3 type: IPV4_EXT_UNKNOWN", "Inner L4 = type: L4_FRAG"], + "MAC_IP_IP_PKT": ["Inner L4 type: L4_NONFRAG"], + "MAC_IP_IP_UDP_PKT": ["Inner L4 type: UDP"], + "MAC_IP_IP_TCP_PKT": ["Inner L4 type: TCP"], + "MAC_IP_IP_SCTP_PKT": ["Inner L4 type: SCTP"], + "MAC_IP_IP_ICMP_PKT": ["Inner L4 type: ICMP"], + "MAC_IP_IPv6FRAG_PKT": ["Inner L3 type: IPV6_EXT_UNKNOW= N", "Inner L4 type: L4_FRAG"], + "MAC_IP_IPv6_PKT": ["Inner L4 type: L4_NONFRAG"], + "MAC_IP_IPv6_UDP_PKT": ["Inner L4 type: UDP"], + "MAC_IP_IPv6_TCP_PKT": ["Inner L4 type: TCP"], + "MAC_IP_IPv6_SCTP_PKT": ["Inner L4 type: SCTP"], + "MAC_IP_IPv6_ICMP_PKT": ["Inner L4 type: ICMP"] + } + + self.run_test(pktType) + + def test_IPv6_in_IPv4_tunnel(self): + """ + checked that whether IPv4 in IPv6 tunnel packet can be normally + detected by Niantic and i350. + """ + if "niantic" not in self.nic.lower() and "i350" not in self.nic.lo= wer(): + return + + pktType =3D { + "MAC_IP_IPv6_PKT": ["(outer) L2 type: ETHER", "(out= er) L3 type: IPV4", "(outer) L4 type: Unknown", "Tunnel type: IP", "Inner L= 2 type: Unknown", "Inner L3 type: IPV6", "Inner L4 type: Unknown"], + "MAC_IP_IPv6EXT2_PKT": ["Inner L3 type: IPV6_EXT"], + "MAC_IP_IPv6_UDP_PKT": ["Inner L4 type: UDP"], + "MAC_IP_IPv6_TCP_PKT": ["Inner L4 type: TCP"], + "MAC_IP_IPv6EXT2_UDP_PKT": ["Inner L3 type: IPV6_EXT", "Inn= er L4 type: UDP"], + "MAC_IP_IPv6EXT2_TCP_PKT": ["Inner L3 type: IPV6_EXT", "Inn= er L4 type: TCP"] + } + self.run_test(pktType) + + def test_IP_in_IPv6_tunnel(self): + """ + checked that whether IP in IPv6 tunnel packet can be normally + detected by Fortville. + """ + self.verify("fortville" in self.nic, + "IP in IPv6 tunnel packet type detect only support=20 + by Fortville") + + pktType =3D { + "MAC_IP_IPFRAG_UDP_PKT": ["(outer) L2 type: ETHER", "(out= er) L3 type: IPV4_EXT_UNKNOWN", "(outer) L4 type: Unknown", "Tunnel type: I= P", "Inner L2 type: Unknown", "Inner L3 type: IPV4_EXT_UNKNOWN", "Inner L4 = type: L4_FRAG"], + "MAC_IP_IP_PKT": ["Inner L4 type: L4_NONFRAG"], + "MAC_IP_IP_UDP_PKT": ["Inner L4 type: UDP"], + "MAC_IP_IP_TCP_PKT": ["Inner L4 type: TCP"], + "MAC_IP_IP_SCTP_PKT": ["Inner L4 type: SCTP"], + "MAC_IP_IP_ICMP_PKT": ["Inner L4 type: ICMP"], + "MAC_IP_IPv6FRAG_PKT": ["Inner L3 type: IPV6_EXT_UNKNOW= N", "Inner L4 type: L4_FRAG"], + "MAC_IP_IPv6_PKT": ["Inner L4 type: L4_NONFRAG"], + "MAC_IP_IPv6_UDP_PKT": ["Inner L4 type: UDP"], + "MAC_IP_IPv6_TCP_PKT": ["Inner L4 type: TCP"], + "MAC_IP_IPv6_SCTP_PKT": ["Inner L4 type: SCTP"], + "MAC_IP_IPv6_ICMP_PKT": ["Inner L4 type: ICMP"] + } + self.run_test(pktType) + + def test_NVGRE_tunnel(self): + """ + checked that whether NVGRE tunnel packet can be normally detected + by Fortville. + """ + self.verify("fortville" in self.nic, + "NVGRE tunnel packet type detect only support by=20 + Fortville") + + pktType =3D { + "MAC_IP_NVGRE_MAC_IPFRAG_PKT": ["(outer) L2 type:= ETHER", "(outer) L3 type: IPV4_EXT_UNKNOWN", "(outer) L4 type: Unknown", "= Tunnel type: GRENAT", "Inner L2 type: ETHER", "Inner L3 type: IPV4_EXT_UNKN= OWN", "Inner L4 type: L4_FRAG"], + "MAC_IP_NVGRE_MAC_IP_PKT": ["Inner L4 type: L= 4_NONFRAG"], + "MAC_IP_NVGRE_MAC_VLAN_PKT": ["Inner L2 type: E= THER_VLAN", "Inner L4 type: Unknown"], + "MAC_IP_NVGRE_MAC_VLAN_IPFRAG_PKT": ["Inner L3 type: I= PV4_EXT_UNKNOWN", "Inner L4 type: L4_FRAG"], + "MAC_IP_NVGRE_MAC_VLAN_IP_PKT": ["Inner L4 type: L= 4_NONFRAG"], + "MAC_IP_NVGRE_MAC_VLAN_IP_UDP_PKT": ["Inner L4 type: U= DP"], + "MAC_IP_NVGRE_MAC_VLAN_IP_TCP_PKT": ["Inner L4 type: T= CP"], + "MAC_IP_NVGRE_MAC_VLAN_IP_SCTP_PKT": ["Inner L4 type: S= CTP"], + "MAC_IP_NVGRE_MAC_VLAN_IP_ICMP_PKT": ["Inner L4 type: I= CMP"], + "MAC_IP_NVGRE_MAC_VLAN_IPv6FRAG_PKT": ["Inner L3 type: I= PV6_EXT_UNKNOWN", "Inner L4 type: L4_FRAG"], + "MAC_IP_NVGRE_MAC_VLAN_IPv6_PKT": ["Inner L4 type: L= 4_NONFRAG"], + "MAC_IP_NVGRE_MAC_VLAN_IPv6_UDP_PKT": ["Inner L4 type: U= DP"], + "MAC_IP_NVGRE_MAC_VLAN_IPv6_TCP_PKT": ["Inner L4 type: T= CP"], + "MAC_IP_NVGRE_MAC_VLAN_IPv6_SCTP_PKT": ["Inner L4 type: S= CTP"], + "MAC_IP_NVGRE_MAC_VLAN_IPv6_ICMP_PKT": ["Inner L4 type: I= CMP"] + } + self.run_test(pktType) + + def test_NVGRE_in_IPv6_tunnel(self): + """ + checked that whether NVGRE in IPv6 tunnel packet can be normally + detected by Fortville. + """ + self.verify("fortville" in self.nic, + "NVGRE in IPv6 detect only support by Fortville") + + pkt_types =3D { + "MAC_IPv6_NVGRE_MAC_PKT": ["(outer) L2 type: ETHER= ", "(outer) L3 type: IPV6_EXT_UNKNOWN", "(outer) L4 type: Unknown", "Tunnel= type: GRENAT", "Inner L2 type: ETHER", "Inner L3 type: Unknown", "Inner L4= type: Unknown"], + "MAC_IPv6_NVGRE_MAC_IPFRAG_PKT": ["Inner L3 type: IPV4_EX= T_UNKNOWN", "Inner L4 type: L4_FRAG"], + "MAC_IPv6_NVGRE_MAC_IP_PKT": ["Inner L4 type: L4_NONF= RAG"], + "MAC_IPv6_NVGRE_MAC_IP_UDP_PKT": ["Inner L4 type: UDP"], + "MAC_IPv6_NVGRE_MAC_IP_TCP_PKT": ["Inner L4 type: TCP"], + "MAC_IPv6_NVGRE_MAC_IP_SCTP_PKT": ["Inner L4 type: SCTP"], + "MAC_IPv6_NVGRE_MAC_IP_ICMP_PKT": ["Inner L4 type: ICMP"], + "MAC_IPv6_NVGRE_MAC_IPv6FRAG_PKT": ["Inner L3 type: IPV6_EX= T_UNKNOWN", "Inner L4 type: L4_FRAG"], + "MAC_IPv6_NVGRE_MAC_IPv6_PKT": ["Inner L4 type: L4_NONF= RAG"], + "MAC_IPv6_NVGRE_MAC_IPv6_UDP_PKT": ["Inner L4 type: UDP"], + "MAC_IPv6_NVGRE_MAC_IPv6_TCP_PKT": ["Inner L4 type: TCP"], + "MAC_IPv6_NVGRE_MAC_IPv6_SCTP_PKT": ["Inner L4 type: SCTP"], + "MAC_IPv6_NVGRE_MAC_IPv6_ICMP_PKT": ["Inner L4 type: ICMP"], + "MAC_IPv6_NVGRE_MAC_VLAN_IPFRAG_PKT": ["Inner L2 type: ETHER_V= LAN", "Inner L3 type: IPV4_EXT_UNKNOWN", "Inner L4 type: L4_FRAG"], + "MAC_IPv6_NVGRE_MAC_VLAN_IP_PKT": ["Inner L4 type: L4_NONF= RAG"], + "MAC_IPv6_NVGRE_MAC_VLAN_IP_UDP_PKT": ["Inner L4 type: UDP"], + "MAC_IPv6_NVGRE_MAC_VLAN_IP_TCP_PKT": ["Inner L4 type: TCP"], + "MAC_IPv6_NVGRE_MAC_VLAN_IP_SCTP_PKT": ["Inner L4 type: SCTP"]= , + "MAC_IPv6_NVGRE_MAC_VLAN_IP_ICMP_PKT": ["Inner L4 type: ICMP"]= , + "MAC_IPv6_NVGRE_MAC_VLAN_IPv6FRAG_PKT": ["Inner L3 type: IPV6_= EXT_UNKNOWN", "Inner L4 type: L4_FRAG"], + "MAC_IPv6_NVGRE_MAC_VLAN_IPv6_PKT": ["Inner L4 type: L4_NO= NFRAG"], + "MAC_IPv6_NVGRE_MAC_VLAN_IPv6_UDP_PKT": ["Inner L4 type: UDP"]= , + "MAC_IPv6_NVGRE_MAC_VLAN_IPv6_TCP_PKT": ["Inner L4 type: TCP"]= , + "MAC_IPv6_NVGRE_MAC_VLAN_IPv6_SCTP_PKT": ["Inner L4 type: SCTP= "], + "MAC_IPv6_NVGRE_MAC_VLAN_IPv6_ICMP_PKT": ["Inner L4 type: ICMP= "], + } + + self.run_test(pkt_types) + + def test_GRE_tunnel(self): + """ + checked that whether GRE tunnel packet can be normally detected by= Fortville. + """ + self.verify("fortville" in self.nic, + "GRE tunnel packet type detect only support by=20 + Fortville") + + pktType =3D { + "MAC_IP_GRE_IPFRAG_PKT": ["(outer) L2 type: ETHER", "= (outer) L3 type: IPV4_EXT_UNKNOWN", "(outer) L4 type: Unknown", "Tunnel typ= e: GRENAT", "Inner L2 type: Unknown", "Inner L3 type: IPV4_EXT_UNKNOWN", "I= nner L4 type: L4_FRAG"], + "MAC_IP_GRE_IP_PKT": ["Inner L4 type: L4_NONFRAG"= ], + "MAC_IP_GRE_IP_UDP_PKT": ["Inner L4 type: UDP"], + "MAC_IP_GRE_IP_TCP_PKT": ["Inner L4 type: TCP"], + "MAC_IP_GRE_IP_SCTP_PKT": ["Inner L4 type: SCTP"], + "MAC_IP_GRE_IP_ICMP_PKT": ["Inner L4 type: ICMP"], + "MAC_IP_GRE_PKT": ["Inner L3 type: Unknown", "= Inner L4 type: Unknown"] + } + self.run_test(pktType) + + def test_Vxlan_tunnel(self): + """ + checked that whether Vxlan tunnel packet can be normally detected = by + Fortville. + """ + self.verify("fortville" in self.nic, + "Vxlan tunnel packet type detect only support by=20 + Fortville") + + self.dut.send_expect("rx_vxlan_port add 4789 0", "testpmd>", 10) + self.dut.send_expect("set fwd rxonly", "testpmd>") + self.dut.send_expect("set verbose 1", "testpmd>") + self.dut.send_expect("start", "testpmd>") + + pktType =3D { + "MAC_IP_UDP_VXLAN_MAC_IPFRAG_PKT": ["(outer) L2 type: E= THER", "(outer) L3 type: IPV4_EXT_UNKNOWN", "(outer) L4 type: Unknown", "Tu= nnel type: GRENAT", "Inner L2 type: ETHER", "Inner L3 type: IPV4_EXT_UNKNOW= N", "Inner L4 type: L4_FRAG"], + "MAC_IP_UDP_VXLAN_MAC_IP_PKT": ["Inner L4 type: L4_= NONFRAG"], + "MAC_IP_UDP_VXLAN_MAC_IP_UDP_PKT": ["Inner L4 type: UDP= "], + "MAC_IP_UDP_VXLAN_MAC_IP_TCP_PKT": ["Inner L4 type: TCP= "], + "MAC_IP_UDP_VXLAN_MAC_IP_SCTP_PKT": ["Inner L4 type: SCT= P"], + "MAC_IP_UDP_VXLAN_MAC_IP_ICMP_PKT": ["Inner L4 type: ICM= P"], + "MAC_IP_UDP_VXLAN_MAC_IPv6FRAG_PKT": ["Inner L3 type: IPV= 6_EXT_UNKNOWN", "Inner L4 type: L4_FRAG"], + "MAC_IP_UDP_VXLAN_MAC_IPv6_PKT": ["Inner L4 type: L4_= NONFRAG"], + "MAC_IP_UDP_VXLAN_MAC_IPv6_UDP_PKT": ["Inner L4 type: UDP= "], + "MAC_IP_UDP_VXLAN_MAC_IPv6_TCP_PKT": ["Inner L4 type: TCP= "], + "MAC_IP_UDP_VXLAN_MAC_IPv6_SCTP_PKT": ["Inner L4 type: SCT= P"], + "MAC_IP_UDP_VXLAN_MAC_IPv6_ICMP_PKT": ["Inner L4 type: ICM= P"], + "MAC_IP_UDP_VXLAN_MAC_PKT": ["Inner L3 type: Unk= nown", "Inner L4 type: Unknown"] + } + self.run_test(pktType) + + def tear_down(self): + """ + Run after each test case. + Nothing to do. + """ + pass + + def tear_down_all(self): + """ + Run after each test suite. + Nothing to do. + """ + self.dut.kill_all() + pass -- 1.9.3