From patchwork Wed Jun 15 04:38:38 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yogesh Jangra X-Patchwork-Id: 112763 Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 44DAAA0548; Wed, 15 Jun 2022 14:02:19 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 3E5C340222; Wed, 15 Jun 2022 14:02:19 +0200 (CEST) Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by mails.dpdk.org (Postfix) with ESMTP id 6D78640040 for ; Wed, 15 Jun 2022 14:02:17 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1655294537; x=1686830537; h=from:to:cc:subject:date:message-id:in-reply-to: references; bh=TDJB7zr5srWMs0kbMRtN/qGfNsmU0SEXfv5kQiTDx7I=; b=gUw/F94VHkPDIkKEufiqGaIJBr+79j6lsGZm7q7vR6wcb1+okgn3ocAI iuGLxCMP3iiBUFo9uiBrJIotjZDqqSzRoidwuK1zUhSGcsrM6vU1etxma 5fkZv2v+AyqE7E0v2XDBqPNmaY7lkeSuFcTZ/5hG4yVqSI5ZXhQUkJfVO lzam9YdA8pJMqbQRVTSDS7MURVuRo3P2bN9kroHTUSNOTytiZf9/BzT6A DhgJ2LSici/0+1TQv/p7R97xESKdPRMr7VH432j0WtOgdMOf4euoxKNXj LlAmpdnuJQij7puIGcOl84E2fRL16bmI88Osac3sho54zE7PJ1Mpdr71t w==; X-IronPort-AV: E=McAfee;i="6400,9594,10378"; a="267624925" X-IronPort-AV: E=Sophos;i="5.91,302,1647327600"; d="scan'208";a="267624925" Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 15 Jun 2022 05:02:17 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.91,302,1647327600"; d="scan'208";a="571797618" Received: from ena-4.iind.intel.com ([10.190.200.151]) by orsmga002.jf.intel.com with ESMTP; 15 Jun 2022 05:02:15 -0700 From: Yogesh Jangra To: dts@dpdk.org Cc: venkata.suresh.kumar.p@intel.com, kamalakannan.r@intel.com, harshad.suresh.narayane@intel.com Subject: [PATCH 1/2] tests/pipeline: adding testcases for multiple features Date: Wed, 15 Jun 2022 00:38:38 -0400 Message-Id: <1655267919-322663-2-git-send-email-yogesh.jangra@intel.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1655267919-322663-1-git-send-email-yogesh.jangra@intel.com> References: <1655267919-322663-1-git-send-email-yogesh.jangra@intel.com> X-BeenThere: dts@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: test suite reviews and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dts-bounces@dpdk.org This patch include the changes to enhance the pipeline test suite covering mirroring, recirculation, direction flag, extern hash, learner table, and table default parameterized action features. Signed-off-by: Kamalakannan R Signed-off-by: Yogesh Jangra Signed-off-by: Harshad Suresh Narayane Tested-by: Venkata Suresh Kumar P --- tests/TestSuite_pipeline.py | 603 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 597 insertions(+), 6 deletions(-) diff --git a/tests/TestSuite_pipeline.py b/tests/TestSuite_pipeline.py index dd23cc9..309504c 100644 --- a/tests/TestSuite_pipeline.py +++ b/tests/TestSuite_pipeline.py @@ -62,7 +62,6 @@ class TestPipeline(TestCase): for line in input: time = TIMESTAMP.match(line) if time: - # print("time match") if flag_line_completed == 1: flag_line_completed = 0 output.write("\n# Packet {}\n".format(i)) @@ -72,14 +71,11 @@ class TestPipeline(TestCase): continue payload = PAYLOAD.match(line) if payload: - # print("payload match") address = payload.group(1) hex_data = payload.group(2).replace(" ", "") hex_data = " ".join( "".join(part) for part in self.pair_hex_digits(hex_data, 2, " ") ) - # print('{} {}'.format(address, hex_data)) - # print(len(hex_data)) if len(hex_data) < 47: output.write("{:0>6} {:<47}\n".format(address, hex_data)) output.write("\n") @@ -443,7 +439,6 @@ class TestPipeline(TestCase): sleep(1) msg = s.recv(BUFFER_SIZE) response = msg.decode() - # print('Rxd: ' + response) if "pipeline>" not in response: s.close() self.dut.send_expect("^C", "# ", 20) @@ -465,7 +460,6 @@ class TestPipeline(TestCase): sleep(0.1) msg = socket.recv(BUFFER_SIZE) response = msg.decode() - # print('Rxd: ' + response) if expected_rsp not in response: socket.close() self.dut.send_expect("^C", "# ", 20) @@ -643,6 +637,58 @@ class TestPipeline(TestCase): self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) self.dut.send_expect("^C", "# ", 20) + def test_extract_emit_010(self): + + cli_file = "/tmp/pipeline/extract_emit_010/extract_emit_010.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/extract_emit_010/pcap_files/in_1.txt"] * 4 + out_pcap = ["pipeline/extract_emit_010/pcap_files/out_1.txt"] * 4 + filters = ["less 120"] * 4 + tx_port = [0, 1, 2, 3] + rx_port = [0, 1, 2, 3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + self.dut.send_expect("^C", "# ", 20) + + def test_extract_emit_011(self): + + cli_file = "/tmp/pipeline/extract_emit_011/extract_emit_011.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/extract_emit_011/pcap_files/in_1.txt"] * 4 + out_pcap = ["pipeline/extract_emit_011/pcap_files/out_1.txt"] * 4 + filters = ["less 120"] * 4 + tx_port = [0, 1, 2, 3] + rx_port = [0, 1, 2, 3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + self.dut.send_expect("^C", "# ", 20) + + def test_extract_emit_012(self): + + cli_file = "/tmp/pipeline/extract_emit_012/extract_emit_012.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/extract_emit_012/pcap_files/in_1.txt"] * 4 + out_pcap = ["pipeline/extract_emit_012/pcap_files/out_1.txt"] * 4 + filters = ["less 120"] * 4 + tx_port = [0, 1, 2, 3] + rx_port = [0, 1, 2, 3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + self.dut.send_expect("^C", "# ", 20) + + def test_extract_emit_013(self): + + cli_file = "/tmp/pipeline/extract_emit_013/extract_emit_013.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/extract_emit_013/pcap_files/in_1.txt"] * 4 + out_pcap = ["pipeline/extract_emit_013/pcap_files/out_1.txt"] * 4 + filters = ["udp and less 160"] * 4 + tx_port = [0, 1, 2, 3] + rx_port = [0, 1, 2, 3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + self.dut.send_expect("^C", "# ", 20) + def test_and_001(self): cli_file = "/tmp/pipeline/and_001/and_001.cli" @@ -2670,6 +2716,82 @@ class TestPipeline(TestCase): self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) self.dut.send_expect("^C", "# ", 20) + def test_table_005(self): + + cli_file = "/tmp/pipeline/table_005/table_005.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/table_005/pcap_files/in_1.txt"] * 4 + out_pcap = ["pipeline/table_005/pcap_files/out_1.txt"] * 4 + filters = ["tcp"] * 4 + tx_port = [0, 1, 2, 3] + rx_port = [0, 1, 2, 3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + self.dut.send_expect("^C", "# ", 20) + + def test_table_006(self): + + cli_file = "/tmp/pipeline/table_006/table_006.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/table_006/pcap_files/in_1.txt"] + out_pcap = [ + "pipeline/table_006/pcap_files/out_0.txt", + "pipeline/table_006/pcap_files/out_1.txt", + ] + filters = ["udp port 4789 and less 120", "tcp"] + tx_port = [1] + rx_port = [0, 1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + self.dut.send_expect("^C", "# ", 20) + + def test_table_007(self): + + cli_file = "/tmp/pipeline/table_007/table_007.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/table_007/pcap_files/in_1.txt"] * 4 + out_pcap = ["pipeline/table_007/pcap_files/out_1.txt"] * 4 + filters = ["tcp"] * 4 + tx_port = [0, 1, 2, 3] + rx_port = [0, 1, 2, 3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + self.dut.send_expect("^C", "# ", 20) + + def test_table_008(self): + + cli_file = "/tmp/pipeline/table_008/table_008.cli" + self.run_dpdk_app(cli_file) + sleep(1) + s = self.connect_cli_server() + + in_pcap = ["pipeline/table_008/pcap_files/in_1.txt"] * 4 + out_pcap = ["pipeline/table_008/pcap_files/out_1.txt"] * 4 + filters = ["tcp"] * 4 + tx_port = [0, 1, 2, 3] + rx_port = [0, 1, 2, 3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + CLI_CMD = ( + "pipeline PIPELINE0 table table_008_table default " + "/tmp/pipeline/table_008/cmd_files/cmd_2.txt\n" + ) + self.socket_send_cmd(s, CLI_CMD, "pipeline> ") + CLI_CMD = "pipeline PIPELINE0 commit\n" + self.socket_send_cmd(s, CLI_CMD, "pipeline> ") + + in_pcap = ["pipeline/table_008/pcap_files/in_1.txt"] * 4 + out_pcap = ["pipeline/table_008/pcap_files/out_2.txt"] * 4 + filters = ["tcp"] * 4 + tx_port = [0, 1, 2, 3] + rx_port = [0, 1, 2, 3] + + sleep(2) + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + s.close() + self.dut.send_expect("^C", "# ", 20) + def test_reg_001(self): cli_file = "/tmp/pipeline/reg_001/reg_001.cli" @@ -5171,6 +5293,446 @@ class TestPipeline(TestCase): self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) self.dut.send_expect("^C", "# ", 20) + def test_learner_003(self): + + cli_file = "/tmp/pipeline/learner_003/learner_003.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/learner_003/pcap_files/in_1.txt"] + out_pcap = ["pipeline/learner_003/pcap_files/out_1.txt"] + filters = ["tcp"] + tx_port = [0] + rx_port = [0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + in_pcap = ["pipeline/learner_003/pcap_files/in_2.txt"] + out_pcap = ["pipeline/learner_003/pcap_files/out_2.txt"] + filters = ["tcp"] + tx_port = [1] + rx_port = [1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + in_pcap = ["pipeline/learner_003/pcap_files/in_3.txt"] + out_pcap = ["pipeline/learner_003/pcap_files/out_3.txt"] + filters = ["tcp"] + tx_port = [2] + rx_port = [2] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + in_pcap = ["pipeline/learner_003/pcap_files/in_4.txt"] + out_pcap = ["pipeline/learner_003/pcap_files/out_4.txt"] + filters = ["tcp"] + tx_port = [3] + rx_port = [3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_learner_004(self): + + cli_file = "/tmp/pipeline/learner_004/learner_004.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/learner_004/pcap_files/in_1.txt"] + out_pcap = ["pipeline/learner_004/pcap_files/out_1.txt"] + out_pcap.append("pipeline/learner_004/pcap_files/out_2.txt") + filters = ["udp port 4789 and less 120", "tcp"] + tx_port = [1] + rx_port = [0, 1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_learner_005(self): + + cli_file = "/tmp/pipeline/learner_005/learner_005.cli" + self.run_dpdk_app(cli_file) + sleep(1) + s = self.connect_cli_server() + + in_pcap = ["pipeline/learner_005/pcap_files/in_1.txt"] + out_pcap = ["pipeline/learner_005/pcap_files/out_1.txt"] + out_pcap.append("pipeline/learner_005/pcap_files/out_2.txt") + filters = ["udp port 4789 and less 120", "tcp"] + tx_port = [1] + rx_port = [0, 1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + CLI_CMD = ( + "pipeline PIPELINE0 learner learn_005 default " + "/tmp/pipeline/learner_005/cmd_files/cmd_1.txt\n" + ) + self.socket_send_cmd(s, CLI_CMD, "pipeline> ") + CLI_CMD = "pipeline PIPELINE0 commit\n" + self.socket_send_cmd(s, CLI_CMD, "pipeline> ") + + in_pcap = ["pipeline/learner_005/pcap_files/in_2.txt"] + out_pcap = ["pipeline/learner_005/pcap_files/out_3.txt"] + out_pcap.append("pipeline/learner_005/pcap_files/out_3.txt") + filters = ["tcp"] * 2 + tx_port = [2] + rx_port = [2] + + sleep(2) + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + s.close() + self.dut.send_expect("^C", "# ", 20) + + def test_learner_006(self): + + cli_file = "/tmp/pipeline/learner_006/learner_006.cli" + self.run_dpdk_app( + cli_file, "pipeline PIPELINE0 port out 3 link LINK3 txq 0 bsz 1\n" + ) + sleep(1) + s = self.connect_cli_server() + + CLI_CMD = ( + "pipeline PIPELINE0 build /tmp/pipeline/learner_006/learner_006.spec\n" + ) + self.socket_send_cmd(s, CLI_CMD, "Error -22 at line 65: Action config error.") + + s.close() + self.dut.send_expect("^C", "# ", 20) + + def test_learner_007(self): + + cli_file = "/tmp/pipeline/learner_007/learner_007.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/learner_007/pcap_files/in_1.txt"] + out_pcap = ["pipeline/learner_007/pcap_files/out_1.txt"] + filters = ["tcp"] * 4 + + tx_port = [0] + rx_port = [0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [0] + rx_port = [1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + sleep(30) + + tx_port = [0] + rx_port = [0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_learner_008(self): + + cli_file = "/tmp/pipeline/learner_008/learner_008.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/learner_008/pcap_files/in_1.txt"] + out_pcap = ["pipeline/learner_008/pcap_files/out_1.txt"] + filters = ["tcp"] * 4 + + tx_port = [0] + rx_port = [0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [0] + rx_port = [1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + sleep(60) + + in_pcap = ["pipeline/learner_008/pcap_files/in_2.txt"] + out_pcap_1 = "pipeline/learner_008/pcap_files/out_21.txt" + out_pcap_2 = "pipeline/learner_008/pcap_files/out_22.txt" + + out_pcap = [out_pcap_1, out_pcap_2] + tx_port = [0] + rx_port = [1, 0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_learner_009(self): + + cli_file = "/tmp/pipeline/learner_009/learner_009.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/learner_009/pcap_files/in_1.txt"] + out_pcap = ["pipeline/learner_009/pcap_files/out_1.txt"] + filters = ["tcp"] * 4 + + tx_port = [0] + rx_port = [0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + sleep(30) + + tx_port = [0] + rx_port = [1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + sleep(40) + + tx_port = [0] + rx_port = [0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_learner_010(self): + + cli_file = "/tmp/pipeline/learner_010/learner_010.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/learner_010/pcap_files/in_1.txt"] + out_pcap = ["pipeline/learner_010/pcap_files/out_1.txt"] + filters = ["tcp"] * 4 + + tx_port = [0] + rx_port = [0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [0] + rx_port = [1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + sleep(30) + + tx_port = [0] + rx_port = [0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [0] + rx_port = [1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_learner_011(self): + + cli_file = "/tmp/pipeline/learner_011/learner_011.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/learner_011/pcap_files/in_1.txt"] + out_pcap = ["pipeline/learner_011/pcap_files/out_1.txt"] + filters = ["tcp"] * 4 + + tx_port = [0] + rx_port = [0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [0] + rx_port = [1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + sleep(60) + + in_pcap = ["pipeline/learner_011/pcap_files/in_2.txt"] + out_pcap_1 = "pipeline/learner_011/pcap_files/out_21.txt" + out_pcap_2 = "pipeline/learner_011/pcap_files/out_22.txt" + out_pcap = [out_pcap_1, out_pcap_2] + + tx_port = [0] + rx_port = [1, 0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_mirror_001(self): + + cli_file = "/tmp/pipeline/mirror_001/mirror_001.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/mirror_001/pcap_files/in_1.txt"] + out_pcap_1 = "pipeline/mirror_001/pcap_files/out_11.txt" + out_pcap_2 = "pipeline/mirror_001/pcap_files/out_12.txt" + + out_pcap = [out_pcap_1, out_pcap_2] + + filters = ["udp port 5000"] * 4 + tx_port = [0] + rx_port = [0, 1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [1] + rx_port = [1, 2] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [2] + rx_port = [2, 3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [3] + rx_port = [3, 0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_mirror_002(self): + + cli_file = "/tmp/pipeline/mirror_002/mirror_002.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/mirror_002/pcap_files/in_1.txt"] + out_pcap_1 = "pipeline/mirror_002/pcap_files/out_11.txt" + out_pcap_2 = "pipeline/mirror_002/pcap_files/out_12.txt" + + out_pcap = [out_pcap_1, out_pcap_2] + + filters = ["udp port 5000"] * 4 + tx_port = [0] + rx_port = [0, 1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [1] + rx_port = [1, 2] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [2] + rx_port = [2, 3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [3] + rx_port = [3, 0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_mirror_003(self): + + cli_file = "/tmp/pipeline/mirror_003/mirror_003.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/mirror_003/pcap_files/in_1.txt"] + out_pcap_1 = "pipeline/mirror_003/pcap_files/out_11.txt" + out_pcap_2 = "pipeline/mirror_003/pcap_files/out_12.txt" + out_pcap_3 = "pipeline/mirror_003/pcap_files/out_13.txt" + out_pcap_4 = "pipeline/mirror_003/pcap_files/out_14.txt" + + out_pcap = [out_pcap_1, out_pcap_3] + + filters = ["udp port 5000"] * 4 + tx_port = [0] + rx_port = [0, 1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + out_pcap = [out_pcap_1, out_pcap_4] + tx_port = [1] + rx_port = [1, 2] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + out_pcap = [out_pcap_1, out_pcap_2] + tx_port = [2] + rx_port = [2, 3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + out_pcap = [out_pcap_1, out_pcap_2] + tx_port = [3] + rx_port = [3, 0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_mirror_004(self): + + cli_file = "/tmp/pipeline/mirror_004/mirror_004.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/mirror_004/pcap_files/in_1.txt"] + out_pcap_1 = "pipeline/mirror_004/pcap_files/out_11.txt" + out_pcap_2 = "pipeline/mirror_004/pcap_files/out_12.txt" + + out_pcap = [out_pcap_1, out_pcap_2] + + filters = ["udp port 5000"] * 4 + tx_port = [0] + rx_port = [0, 1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [1] + rx_port = [1, 2] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [2] + rx_port = [2, 3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + tx_port = [3] + rx_port = [3, 0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_mirror_005(self): + + cli_file = "/tmp/pipeline/mirror_005/mirror_005.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/mirror_005/pcap_files/in_1.txt"] + out_pcap_1 = "pipeline/mirror_005/pcap_files/out_11.txt" + out_pcap_2 = "pipeline/mirror_005/pcap_files/out_12.txt" + out_pcap_3 = "pipeline/mirror_005/pcap_files/out_13.txt" + + out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3] + + filters = ["udp port 5000"] * 4 + tx_port = [0] + rx_port = [0, 1, 2] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_mirror_006(self): + + cli_file = "/tmp/pipeline/mirror_006/mirror_006.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/mirror_006/pcap_files/in_1.txt"] + out_pcap_1 = "pipeline/mirror_006/pcap_files/out_11.txt" + out_pcap_2 = "pipeline/mirror_006/pcap_files/out_12.txt" + out_pcap_3 = "pipeline/mirror_006/pcap_files/out_13.txt" + + out_pcap = [out_pcap_1, out_pcap_2, out_pcap_3] + + filters = ["udp port 5000"] * 4 + tx_port = [0] + rx_port = [0, 1, 2] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_mirror_007(self): + + cli_file = "/tmp/pipeline/mirror_007/mirror_007.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/mirror_007/pcap_files/in_1.txt"] + out_pcap_1 = "pipeline/mirror_007/pcap_files/out_11.txt" + out_pcap_2 = "pipeline/mirror_007/pcap_files/out_12.txt" + + out_pcap = [out_pcap_1, out_pcap_2] + + filters = ["udp port 500"] * 4 + tx_port = [0] + rx_port = [0, 1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + + def test_recirculate_001(self): + + cli_file = "/tmp/pipeline/recirculate_001/recirculate_001.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/recirculate_001/pcap_files/in_1.txt"] + out_pcap = ["pipeline/recirculate_001/pcap_files/out_1.txt"] + + filters = ["udp port 54505"] * 4 + tx_port = [0] + rx_port = [0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap, filters) + + self.dut.send_expect("^C", "# ", 20) + def test_annotation_001(self): cli_file = "/tmp/pipeline/annotation_001/annotation_001.cli" @@ -5258,6 +5820,35 @@ class TestPipeline(TestCase): self.dut.send_expect("^C", "# ", 20) + def test_direction_001(self): + + cli_file = "/tmp/pipeline/direction_001/direction_001.cli" + self.run_dpdk_app(cli_file) + + in_pcap = ["pipeline/direction_001/pcap_files/in_1.txt"] + out_pcap_1 = ["pipeline/direction_001/pcap_files/out_1.txt"] + out_pcap_2 = ["pipeline/direction_001/pcap_files/out_2.txt"] + + filters = ["udp port 5000"] + + tx_port = [0] + rx_port = [0] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap_1, filters) + + tx_port = [1] + rx_port = [1] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap_1, filters) + + tx_port = [2] + rx_port = [2] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap_2, filters) + + tx_port = [3] + rx_port = [3] + self.send_and_sniff_multiple(tx_port, rx_port, in_pcap, out_pcap_2, filters) + + self.dut.send_expect("^C", "# ", 20) + def tear_down(self): """ Run after each test case.